Merge pull request adafruit#1134 from caternuson/hourglass

Code for LED hourglass

Author: ladyada

CircuitPython_LED_Sand_Hourglass/double_matrix.py

@@ -0,0 +1,53 @@
+import time
+import board
+import adafruit_lsm6ds
+from adafruit_ht16k33 import matrix
+import matrixsand
+
+DELAY = 0.00 # add some delay if you want
+
+# the accelo
+accelo = adafruit_lsm6ds.LSM6DS33(board.I2C())
+
+# the matrix
+matrix1 = matrix.Matrix8x8(board.I2C(), 0x70)
+matrix2 = matrix.Matrix8x8(board.I2C(), 0x71)
+
+# the sand
+sand = matrixsand.MatrixSand(8, 16)
+
+# simple helper
+def update_matrix():
+    for x in range(8):
+        for y in range(16):
+            if y < 8:
+                matrix1[x, y] = sand[x, y]
+            else:
+                matrix2[x, y-8] = sand[x, y]
+
+# add some initial sand
+for sx in range(4):
+    for sy in range(4):
+        sand[sx, sy] = 1
+
+update_matrix()
+
+# loop forever
+while True:
+    # read accelo
+    ax, ay, az = accelo.acceleration
+
+    # rotate coord sys
+    xx = ay
+    yy = ax
+    zz = az
+
+    # iterate the sand
+    updated = sand.iterate((xx, yy, zz))
+
+    # update matrix if needed
+    if updated:
+        update_matrix()
+
+    # sleep
+    time.sleep(DELAY)

CircuitPython_LED_Sand_Hourglass/hourglass.py

@@ -0,0 +1,67 @@
+import time
+import board
+import adafruit_lsm6ds
+from adafruit_ht16k33 import matrix
+import matrixsand
+
+DELAY = 0.05 # overall update rate
+
+# the accelo
+accelo = adafruit_lsm6ds.LSM6DS33(board.I2C())
+
+# the matrices
+m1 = matrix.Matrix8x8(board.I2C(), 0x70)
+m2 = matrix.Matrix8x8(board.I2C(), 0x71)
+
+# the sand
+sand1 = matrixsand.MatrixSand(8, 8)
+sand2 = matrixsand.MatrixSand(8, 8)
+
+# simple helper
+def update_matrix(m, s):
+    for x in range(8):
+        for y in range(8):
+            m[x,y] = s[x,y]
+
+# fill up some sand
+for sx in range(8):
+    for sy in range(8):
+        sand1[sx, sy] = True
+sand1[0,0] = sand1[0,1] = sand1[1,0] = False
+sand1[0,2] = sand1[1,1] = sand1[2,0] = False
+
+update_matrix(m1, sand1)
+update_matrix(m2, sand2)
+
+updated1 = updated2 = False
+
+while True:
+    # read accelo
+    ax, ay, az = accelo.acceleration
+    # rotate coords
+    xx = -ax - ay
+    yy = -ax + ay
+    zz = az
+
+    # move grain of sand from upper to lower?
+    if yy > 0 and sand1[7,7] and not sand2[0,0] and not updated2:
+        sand1[7,7] = False
+        sand2[0,0] = True
+        updated1 = updated2 = True
+    # move grain of sand from lower to upper?
+    elif yy <= 0 and sand2[0,0] and not sand1[7,7] and not updated1:
+        sand2[0,0] = False
+        sand1[7,7] = True
+        updated1 = updated2 = True
+    # nope, just a regular update
+    else:
+        updated1 = sand1.iterate((xx, yy, zz))
+        updated2 = sand2.iterate((xx, yy, zz))
+
+    # update matrices if needed
+    if updated1:
+        update_matrix(m1, sand1)
+    if updated2:
+        update_matrix(m2, sand2)
+
+    time.sleep(DELAY)

CircuitPython_LED_Sand_Hourglass/matrixsand.py

@@ -0,0 +1,107 @@
+class MatrixSand:
+    """Class to simulate simplified sand physics."""
+
+    def __init__(self, width, height):
+        self._width = width
+        self._height = height
+        self._grains = [False] * width * height
+
+    def __getitem__(self, value):
+        if isinstance(value, tuple):
+            value = value[0] + self._width * value[1]
+        return self._grains[value]
+
+    def __setitem__(self, value, key):
+        if isinstance(value, tuple):
+            value = value[0] + self._width * value[1]
+        self._grains[value] = key
+
+    def _side_count(self, upside_down=False):
+        left = right = 0
+        for x in range(self._width):
+            for y in range(self._height):
+                if x != y and self[x, y]:
+                    if x > y:
+                        right += 1
+                    else:
+                        left += 1
+        if upside_down:
+            return right, left
+        else:
+            return left, right
+
+    def iterate(self, acceleration):
+        """Update sand based on supplied acceleration tuple. Returns True if
+        any motion occurred, otherwise False."""
+        #pylint: disable=too-many-locals,too-many-nested-blocks,too-many-branches
+
+        ax, ay, az = acceleration
+
+        # if z dominates, don't do anything
+        if abs(az) > abs(ax) and abs(az) > abs(ay):
+            return False
+
+        # unit vectors for accelo
+        ix = iy = 0
+        if abs(ax) > 0.01:
+            ratio = abs(ay / ax)
+            if ratio < 2.414: # tan(67.5deg)
+                ix = 1 if ax > 0 else -1
+            if ratio > 0.414: # tan(22.5deg)
+                iy = 1 if ay > 0 else -1
+        else:
+            iy = 1 if ay > 0 else -1
+
+        # buffer
+        new_grains = self._grains[:]
+
+        # flag to indicate change
+        updated = False
+
+        # loop through the grains
+        for x in range(self._width):
+            for y in range(self._height):
+                # is there a grain here?
+                if self[x, y]:
+                    moved = False
+                    # compute new location
+                    newx = x + ix
+                    newy = y + iy
+                    # bounds check
+                    newx = max(min(self._width-1, newx), 0)
+                    newy = max(min(self._height-1, newy), 0)
+                    # wants to move?
+                    if x != newx or y != newy:
+                        moved = True
+                        # is it blocked?
+                        if new_grains[newx + self._width * newy]:
+                            # can we move diagonally?
+                            if not new_grains[x + self._width * newy] and \
+                               not new_grains[newx + self._width * y]:
+                                # can move either way
+                                # move away from fuller side
+                                left, right = self._side_count(ax < 0 and ay < 0)
+                                if left >= right:
+                                    newy = y
+                                elif right > left:
+                                    newx = x
+                            elif not new_grains[x + self._width * newy]:
+                                # move in y only
+                                newx = x
+                            elif not new_grains[newx + self._width * y]:
+                                # move in x only
+                                newy = y
+                            else:
+                                # nope, totally blocked
+                                moved = False
+                    # did it move?
+                    if moved:
+                        new_grains[x + self._width * y] = False
+                        new_grains[newx + self._width * newy] = True
+                        updated = True
+
+        # did things change?
+        if updated:
+            self._grains = new_grains
+
+        return updated

CircuitPython_LED_Sand_Hourglass/single_matrix.py

@@ -0,0 +1,48 @@
+import time
+import board
+import adafruit_lsm6ds
+from adafruit_ht16k33 import matrix
+import matrixsand
+
+DELAY = 0.00 # add some delay if you want
+
+# the accelo
+accelo = adafruit_lsm6ds.LSM6DS33(board.I2C())
+
+# the matrix
+matrix = matrix.Matrix8x8(board.I2C(), 0x70)
+
+# the sand
+sand = matrixsand.MatrixSand(8, 8)
+
+# simple helper
+def update_matrix():
+    for x in range(8):
+        for y in range(8):
+            matrix[x,y] = sand[x,y]
+
+# add some initial sand
+for sx in range(4):
+    for sy in range(4):
+        sand[sx, sy] = 1
+update_matrix()
+
+# loop forever
+while True:
+    # read accelo
+    ax, ay, az = accelo.acceleration
+
+    # rotate coord sys
+    xx = ay
+    yy = ax
+    zz = az
+
+    # iterate the sand
+    updated = sand.iterate((xx, yy, zz))
+
+    # update matrix if needed
+    if updated:
+        update_matrix()
+
+    # sleep
+    time.sleep(DELAY)