Merge branch 'master' into master

Author: ladyada

CLUE_I_Ching/christopher_done_24.bdf

@@ -0,0 +1,130 @@
+import time
+import random
+import displayio
+from adafruit_bitmap_font import bitmap_font
+from adafruit_display_text import label
+from adafruit_clue import clue
+
+#--| User Config |-------------------------------
+BACKGROUND_COLOR = 0xCFBC17
+HEXAGRAM_COLOR   = 0xBB0000
+FONT_COLOR       = 0x005500
+SHAKE_THRESHOLD  = 20
+MELODY = ( (1000, 0.1),  # (freq, duration)
+           (1200, 0.1),
+           (1400, 0.1),
+           (1600, 0.2))
+#--| User Config |-------------------------------
+
+# Defined in order treating each hexagram as a 6 bit value.
+HEXAGRAMS = (
+    "EARTH", "RETURN", "THE ARMY", "PREVAILING", "MODESTY", "  CRYING\nPHEASANT",
+    "ASCENDANCE", "PEACE", "WEARINESS", "THUNDER", "LETTING\n LOOSE",
+    "MARRYING\n MAIDEN", " SMALL\nEXCESS", "ABUNDANCE", "STEADFASTNESS",
+    " GREAT\nINJURY", "SUPPORT", "RETRENCHMENT", "WATER", "FRUGALITY",
+    "ADMONISHMENT", "FULFILLMENT", "THE WELL", "WAITING", "ILLNESS",
+    "THE CHASE", "TRAPPED", "LAKE", "CUTTING", "REVOLUTION", " GREAT\nEXCESS",
+    "STRIDE", "LOSS", "THE CHEEKS", "BLINDNESS", "DECREASE", "MOUNTAIN",
+    "DECORATION", "WORK", "   BIG\nCATTLE", "ADVANCE", "BITING", "UNFULFILLMENT",
+    "ABANDONED", "TRAVELER", "FIRE", "    THE\nCAULDRON", " GREAT\nHARVEST",
+    "VIEW", "INCREASE", "FLOWING", "SINCERITY", "PROGRESS", "FAMILY", "WIND",
+    " SMALL\nCATTLE", "OBSTRUCTION", "PROPRIETY", "THE COURT", "TREADING",
+    "LITTLE\n  PIG", "GATHERING", "RENDEZVOUS", "HEAVEN",
+)
+
+# Grab the CLUE's display
+display = clue.display
+
+# Background fill
+bg_bitmap = displayio.Bitmap(display.width, display.height, 1)
+bg_palette = displayio.Palette(1)
+bg_palette[0] = BACKGROUND_COLOR
+background = displayio.TileGrid(bg_bitmap, pixel_shader=bg_palette)
+
+# Hexagram setup
+sprite_sheet = displayio.Bitmap(11, 4, 2)
+palette = displayio.Palette(2)
+palette.make_transparent(0)
+palette[0] = 0x000000
+palette[1] = HEXAGRAM_COLOR
+
+for x in range(11):
+    sprite_sheet[x, 0] = 1 # - - 0 YIN
+    sprite_sheet[x, 1] = 0
+    sprite_sheet[x, 2] = 1 # --- 1 YANG
+    sprite_sheet[x, 3] = 0
+sprite_sheet[5, 0] = 0
+
+tile_grid = displayio.TileGrid(sprite_sheet, pixel_shader=palette,
+                               width = 1,
+                               height = 6,
+                               tile_width = 11,
+                               tile_height = 2)
+
+hexagram = displayio.Group(max_size=1, x=60, y=15, scale=10)
+hexagram.append(tile_grid)
+
+# Hexagram name label
+# font credit: https://www.instagram.com/cove703/
+font = bitmap_font.load_font("/christopher_done_24.bdf")
+font.load_glyphs(b'ABCDEFGHIJKLMNOPQRSTUVWXYZ')
+hexname = label.Label(font, text=" "*40, color=FONT_COLOR)
+# this will initially hold the "shake for reading" message
+hexname.text = " SHAKE\n   FOR\nREADING"
+hexname.anchor_point = (0.5, 0.0)
+hexname.anchored_position = (120, 120)
+
+# Set up main display group (splash)
+splash = displayio.Group()
+display.show(splash)
+
+# Add background and text label
+splash.append(background)
+splash.append(hexname)
+
+def show_hexagram(number):
+    for i in range(6):
+        tile_grid[5-i] = (number >> i) & 0x01
+
+def show_name(number):
+    hexname.text = HEXAGRAMS[number]
+    hexname.anchored_position = (120, 180)
+
+#===================================
+# MAIN CODE
+#===================================
+print("shake")
+# wait for shake
+while not clue.shake(shake_threshold=SHAKE_THRESHOLD):
+    pass
+
+# calibrate the mystic universe
+x, y, z = clue.acceleration
+random.seed(int(time.monotonic() + abs(x) + abs(y) + abs(z)))
+
+# cast a reading
+reading = random.randrange(64)
+print("reading = ", reading, HEXAGRAMS[reading])
+
+# play a melody
+for note, duration in MELODY:
+    clue.play_tone(note, duration)
+
+# prompt to show
+display.auto_refresh = False
+hexname.text = "      GOT IT\n\nPRESS BUTTON\n       TO SEE"
+hexname.anchored_position = (120, 120)
+display.auto_refresh = True
+while not clue.button_a and not clue.button_b:
+    pass
+
+# and then show it
+display.auto_refresh = False
+splash.append(hexagram)
+show_hexagram(reading)
+show_name(reading)
+display.auto_refresh = True
+
+# hold here until reset
+while True:
+    pass

CLUE_I_Ching/clue_iching.py

@@ -0,0 +1,136 @@
+import random
+import time
+
+import board
+import displayio
+import framebufferio
+import rgbmatrix
+
+displayio.release_displays()
+
+matrix = rgbmatrix.RGBMatrix(
+    width=64, height=32, bit_depth=3,
+    rgb_pins=[board.D6, board.D5, board.D9, board.D11, board.D10, board.D12],
+    addr_pins=[board.A5, board.A4, board.A3, board.A2],
+    clock_pin=board.D13, latch_pin=board.D0, output_enable_pin=board.D1)
+display = framebufferio.FramebufferDisplay(matrix, auto_refresh=False)
+
+# This bitmap contains the emoji we're going to use. It is assumed
+# to contain 20 icons, each 20x24 pixels. This fits nicely on the 64x32
+# RGB matrix display.
+bitmap_file = open("emoji.bmp", 'rb')
+bitmap = displayio.OnDiskBitmap(bitmap_file)
+
+# Each wheel can be in one of three states:
+STOPPED, RUNNING, BRAKING = range(3)
+
+# Return a duplicate of the input list in a random (shuffled) order.
+def shuffled(seq):
+    return sorted(seq, key=lambda _: random.random())
+
+# The Wheel class manages the state of one wheel. "pos" is a position in
+# scaled integer coordinates, with one revolution being 7680 positions
+# and 1 pixel being 16 positions. The wheel also has a velocity (in positions
+# per tick) and a state (one of the above constants)
+class Wheel(displayio.TileGrid):
+    def __init__(self):
+        # Portions of up to 3 tiles are visible.
+        super().__init__(bitmap=bitmap, pixel_shader=displayio.ColorConverter(),
+                         width=1, height=3, tile_width=20)
+        self.order = shuffled(range(20))
+        self.state = STOPPED
+        self.pos = 0
+        self.vel = 0
+        self.y = 0
+        self.x = 0
+        self.stop_time = time.monotonic_ns()
+
+    def step(self):
+        # Update each wheel for one time step
+        if self.state == RUNNING:
+            # Slowly lose speed when running, but go at least speed 64
+            self.vel = max(self.vel * 9 // 10, 64)
+            if time.monotonic_ns() > self.stop_time:
+                self.state = BRAKING
+        elif self.state == BRAKING:
+            # More quickly lose speed when baking, down to speed 7
+            self.vel = max(self.vel * 85 // 100, 7)
+
+        # Advance the wheel according to the velocity, and wrap it around
+        # after 7680 positions
+        self.pos = (self.pos + self.vel) % 7680
+
+        # Compute the rounded Y coordinate
+        yy = round(self.pos / 16)
+        # Compute the offset of the tile (tiles are 24 pixels tall)
+        yyy = yy % 24
+        # Find out which tile is the top tile
+        off = yy // 24
+
+        # If we're braking and a tile is close to midscreen,
+        # then stop and make sure that tile is exactly centered
+        if self.state == BRAKING and self.vel == 7 and yyy < 4:
+            self.pos = off * 24 * 16
+            self.vel = 0
+            yy = 0
+            self.state = STOPPED
+
+        # Move the displayed tiles to the correct height and make sure the
+        # correct tiles are displayed.
+        self.y = yyy - 20
+        for i in range(3):
+            self[i] = self.order[(19 - i + off) % 20]
+
+    # Set the wheel running again, using a slight bit of randomness.
+    # The 'i' value makes sure the first wheel brakes first, the second
+    # brakes second, and the third brakes third.
+    def kick(self, i):
+        self.state = RUNNING
+        self.vel = random.randint(256, 320)
+        self.stop_time = time.monotonic_ns() + 3000000000 + i * 350000000
+
+# Our fruit machine has 3 wheels, let's create them with a correct horizontal
+# (x) offset and arbitrary vertical (y) offset.
+g = displayio.Group(max_size=3)
+wheels = []
+for idx in range(3):
+    wheel = Wheel()
+    wheel.x = idx * 22
+    wheel.y = -20
+    g.append(wheel)
+    wheels.append(wheel)
+display.show(g)
+
+# Make a unique order of the emoji on each wheel
+orders = [shuffled(range(20)), shuffled(range(20)), shuffled(range(20))]
+
+# And put up some images to start with
+for si, oi in zip(wheels, orders):
+    for idx in range(3):
+        si[idx] = oi[idx]
+
+# We want a way to check if all the wheels are stopped
+def all_stopped():
+    return all(si.state == STOPPED for si in wheels)
+
+# To start with, though, they're all in motion
+for idx, si in enumerate(wheels):
+    si.kick(idx)
+
+# Here's the main loop
+while True:
+    # Refresh the dislpay (doing this manually ensures the wheels move
+    # together, not at different times)
+    display.refresh(minimum_frames_per_second=0)
+    if all_stopped():
+        # Once everything comes to a stop, wait a little bit and then
+        # start everything over again.  Maybe you want to check if the
+        # combination is a "winner" and add a light show or something.
+        for idx in range(100):
+            display.refresh(minimum_frames_per_second=0)
+        for idx, si in enumerate(wheels):
+            si.kick(idx)
+
+    # Otherwise, let the wheels keep spinning...
+    for idx, si in enumerate(wheels):
+        si.step()

CircuitPython_RGBMatrix/emoji.bmp

@@ -0,0 +1,120 @@
+import random
+import time
+
+import board
+import displayio
+import framebufferio
+import rgbmatrix
+
+displayio.release_displays()
+
+# Conway's "Game of Life" is played on a grid with simple rules, based
+# on the number of filled neighbors each cell has and whether the cell itself
+# is filled.
+#   * If the cell is filled, and 2 or 3 neighbors are filled, the cell stays
+#     filled
+#   * If the cell is empty, and exactly 3 neighbors are filled, a new cell
+#     becomes filled
+#   * Otherwise, the cell becomes or remains empty
+#
+# The complicated way that the "m1" (minus 1) and "p1" (plus one) offsets are
+# calculated is due to the way the grid "wraps around", with the left and right
+# sides being connected, as well as the top and bottom sides being connected.
+#
+# This function has been somewhat optimized, so that when it indexes the bitmap
+# a single number [x + width * y] is used instead of indexing with [x, y].
+# This makes the animation run faster with some loss of clarity. More
+# optimizations are probably possible.
+
+def apply_life_rule(old, new):
+    width = old.width
+    height = old.height
+    for y in range(height):
+        yyy = y * width
+        ym1 = ((y + height - 1) % height) * width
+        yp1 = ((y + 1) % height) * width
+        xm1 = width - 1
+        for x in range(width):
+            xp1 = (x + 1) % width
+            neighbors = (
+                old[xm1 + ym1] + old[xm1 + yyy] + old[xm1 + yp1] +
+                old[x   + ym1] +                  old[x   + yp1] +
+                old[xp1 + ym1] + old[xp1 + yyy] + old[xp1 + yp1])
+            new[x+yyy] = neighbors == 3 or (neighbors == 2 and old[x+yyy])
+            xm1 = x
+
+# Fill 'fraction' out of all the cells.
+def randomize(output, fraction=0.33):
+    for i in range(output.height * output.width):
+        output[i] = random.random() < fraction
+
+
+# Fill the grid with a tribute to John Conway
+def conway(output):
+    # based on xkcd's tribute to John Conway (1937-2020) https://xkcd.com/2293/
+    conway_data = [
+        b'  +++   ',
+        b'  + +   ',
+        b'  + +   ',
+        b'   +    ',
+        b'+ +++   ',
+        b' + + +  ',
+        b'   +  + ',
+        b'  + +   ',
+        b'  + +   ',
+    ]
+    for i in range(output.height * output.width):
+        output[i] = 0
+    for i, si in enumerate(conway_data):
+        y = output.height - len(conway_data) - 2 + i
+        for j, cj in enumerate(si):
+            output[(output.width - 8)//2 + j, y] = cj & 1
+
+# bit_depth=1 is used here because we only use primary colors, and it makes
+# the animation run a bit faster because RGBMatrix isn't taking over the CPU
+# as often.
+matrix = rgbmatrix.RGBMatrix(
+    width=64, height=32, bit_depth=1,
+    rgb_pins=[board.D6, board.D5, board.D9, board.D11, board.D10, board.D12],
+    addr_pins=[board.A5, board.A4, board.A3, board.A2],
+    clock_pin=board.D13, latch_pin=board.D0, output_enable_pin=board.D1)
+display = framebufferio.FramebufferDisplay(matrix, auto_refresh=False)
+SCALE = 1
+b1 = displayio.Bitmap(display.width//SCALE, display.height//SCALE, 2)
+b2 = displayio.Bitmap(display.width//SCALE, display.height//SCALE, 2)
+palette = displayio.Palette(2)
+tg1 = displayio.TileGrid(b1, pixel_shader=palette)
+tg2 = displayio.TileGrid(b2, pixel_shader=palette)
+g1 = displayio.Group(max_size=3, scale=SCALE)
+g1.append(tg1)
+display.show(g1)
+g2 = displayio.Group(max_size=3, scale=SCALE)
+g2.append(tg2)
+
+# First time, show the Conway tribute
+palette[1] = 0xffffff
+conway(b1)
+display.auto_refresh = True
+time.sleep(3)
+n = 40
+
+while True:
+    # run 2*n generations.
+    # For the Conway tribute on 64x32, 80 frames is appropriate.  For random
+    # values, 400 frames seems like a good number.  Working in this way, with
+    # two bitmaps, reduces copying data and makes the animation a bit faster
+    for _ in range(n):
+        display.show(g1)
+        apply_life_rule(b1, b2)
+        display.show(g2)
+        apply_life_rule(b2, b1)
+
+    # After 2*n generations, fill the board with random values and
+    # start over with a new color.
+    randomize(b1)
+    # Pick a random color out of 6 primary colors or white.
+    palette[1] = (
+        (0x0000ff if random.random() > .33 else 0) |
+        (0x00ff00 if random.random() > .33 else 0) |
+        (0xff0000 if random.random() > .33 else 0)) or 0xffffff
+    n = 200