pico interstate75 support

copy.sh

@@ -0,0 +1,15 @@
+#!/bin/bash
+
+if [ $# -ne 0 ] ; then
+cat << EOF | rshell
+cp pico.py /pyboard
+cp util.py /pyboard
+cp $1 /pyboard/main.py
+EOF
+else
+cat << EOF | rshell
+cp pico.py /pyboard
+cp util.py /pyboard
+cp life.py /pyboard
+EOF
+fi

draw.py

@@ -54,6 +54,12 @@ class DrawText:
                 offset = 12
                 spacing = 2
 
+            # center vertically, in case of
+            # multiple stacked panels
+            # TODO hard-coded offsets assume 32x32 panels
+            if self.gui.height > 32:
+                offset += 16
+
             font = Font(os.path.join(fontDir, filename))
             data = (font, offset, {}, spacing)
             self.fonts[filename[:-4]] = data

mapper.py

@@ -7,7 +7,7 @@
 # think this stuff is worth it, you can buy me a beer in return.   Thomas Buck
 # ----------------------------------------------------------------------------
 
-# Does nothing. Take this as an example for new Mappers.
+# Does nothing. Take this as parent for new mappers.
 class MapperNull:
     def __init__(self, g):
         self.gui = g
@@ -29,17 +29,43 @@ class MapperNull:
     def set_pixel(self, x, y, color):
         self.gui.set_pixel(x, y, color)
 
-# For some reason the red and green LEDs on newer Pimoroni panels
-# are far brighter than on older panels.
+# For some reason the red and green LEDs on older Pimoroni panels
+# are far brighter than on newer panels.
 # Adjust this by multiplying rg channels with 0.75, depending
 # on hard-corded coordinate ranges.
 class MapperColorAdjust(MapperNull):
     def set_pixel(self, x, y, color):
-        # right-most panel, with maximum x coordinates,
-        # is "new" type with brighter LEDs.
-        # rest of panels to the left are less bright.
-        # so adjust brightness of right panel rg channels down.
-        if x < self.gui.panelW:
+        # third panel from the left, with 64 <= x < 96,
+        # is "old" type with brighter LEDs.
+        # rest of panels to the left and right are less bright.
+        # so adjust brightness of inner panel rg channels down.
+        if (x >= (self.gui.panelW * 2)) and (x < (self.gui.panelW * 3)):
             color = (int(color[0] * 0.75), int(color[1] * 0.75), color[2])
 
         self.gui.set_pixel(x, y, color)
+
+# This converts a long 128x32 strip to a 64x64 panel.
+# The Pi is always connected to d, the last subpanel.
+#
+#     (0,  0)            (128, 0)
+#             a  b  c  d
+#     (0, 32)            (128, 32)
+#
+# on the hardware is converted to this for the effects:
+#
+#     (0,  0)      (64, 0)
+#             a  b
+#             c  d
+#     (0, 64)      (64, 64)
+class MapperStripToRect(MapperNull):
+    def __init__(self, g):
+        super().__init__(g)
+        self.width = int(self.gui.width / 2)
+        self.height = self.gui.height * 2
+
+    def set_pixel(self, x, y, color):
+        if y >= self.gui.height:
+            x += self.width
+            y -= self.panelH
+
+        self.gui.set_pixel(x, y, color)

pi.py

@@ -32,7 +32,7 @@ from rgbmatrix import RGBMatrix, RGBMatrixOptions
 from PIL import Image
 
 class PiMatrix:
-    def __init__(self, w = 64, h = 32, panelW = 32, panelH = 32):
+    def __init__(self, w = 32 * 4, h = 32, panelW = 32, panelH = 32):
         self.width = w # x-axis
         self.height = h # y-axis
 

pico.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+
+#
+# ----------------------------------------------------------------------------
+# "THE BEER-WARE LICENSE" (Revision 42):
+# <xythobuz@xythobuz.de> wrote this file.  As long as you retain this notice
+# you can do whatever you want with this stuff. If we meet some day, and you
+# think this stuff is worth it, you can buy me a beer in return.   Thomas Buck
+# ----------------------------------------------------------------------------
+
+import interstate75
+
+
+class PicoMatrix:
+    def __init__(self, w = 32, h = 32):
+        self.width = w # x-axis
+        self.height = h # y-axis
+
+        self.panelW = w # x-axis
+        self.panelH = h # y-axis
+
+        # compatibility to TestGUI
+        self.multiplier = 1.0
+
+        if (w != 32) or (h != 32):
+            raise RuntimeError("TODO not yet supported")
+
+        self.matrix = interstate75.Interstate75(display = interstate75.DISPLAY_INTERSTATE75_32X32)
+
+        self.loop_start() # initialize with blank image for ScrollText constructor
+
+    def loop_start(self):
+        self.matrix.display.clear()
+        return False # no input, never quit on our own
+
+    def loop_end(self):
+        self.matrix.update()
+
+    def loop(self, func = None):
+        while True:
+            if self.loop_start():
+                break
+            if func != None:
+                func()
+            self.loop_end()
+        self.matrix.stop()
+
+    def set_pixel(self, x, y, color):
+        if (x < 0) or (y < 0) or (x >= self.width) or (y >= self.height):
+            return
+
+        pen = self.matrix.display.create_pen(color[0], color[1], color[2])
+        self.matrix.display.set_pen(pen)
+        self.matrix.display.pixel(int(x), int(y))
+
+if __name__ == "__main__":
+    t = PicoMatrix(32, 32)
+    t.loop(lambda: t.set_pixel(15, 15, (255, 255, 255)))

solid.py

@@ -34,6 +34,8 @@ if __name__ == "__main__":
     import util
     t = util.getTarget()
 
+    d = Solid(t, 1.0, (0, 0, 0))
+
     colors = [
         (251, 72, 196), # camp23 pink
         (63, 255, 33), # camp23 green
@@ -45,18 +47,24 @@ if __name__ == "__main__":
         (255, 0, 255),
         (255, 255, 255),
     ]
-    ci = 0
-
-    d = Solid(t, 1.0, colors[ci])
 
     s = time.time()
+    ci = 0
+    n = 0
+    c = (0, 0, 0)
     def helper():
-        global s, colors, ci
+        global s, colors, ci, n, c
 
-        if (time.time() - s) >= 1.0:
+        if (time.time() - s) >= 0.1:
             s = time.time()
-            ci = (ci + 1) % len(colors)
-            c = colors[ci]
+            n += 1
+            if n >= 15:
+                ci = (ci + 1) % len(colors)
+                n = 0
+                c = (0, 0, 0)
+            elif n <= 10:
+                c = colors[ci]
+                c = (int(c[0] * (0.1 * n)), int(c[1] * (0.1 * n)), int(c[2] * (0.1 * n)))
             d.setColor(c)
 
         d.draw()

util.py

@@ -7,39 +7,60 @@
 # think this stuff is worth it, you can buy me a beer in return.   Thomas Buck
 # ----------------------------------------------------------------------------
 
-targetIsPi = None
+targetPlatform = None
 
 def isPi():
-    global targetIsPi
+    global targetPlatform
 
-    if targetIsPi == None:
+    if targetPlatform == None:
         getTarget()
-    return targetIsPi
+
+    return targetPlatform == "pi"
+
+def isPico():
+    global targetPlatform
+
+    if targetPlatform == None:
+        getTarget()
+
+    return targetPlatform == "pico"
 
 def getTarget():
-    global targetIsPi
+    global targetPlatform
 
     target = None
     try:
+        # First we try the Raspberry Pi interface
         from pi import PiMatrix
         pi = PiMatrix()
 
         # TODO hard-coded adjustments
-        from mapper import MapperColorAdjust
-        target = MapperColorAdjust(pi)
+        from mapper import MapperColorAdjust, MapperStripToRect
+        col = MapperColorAdjust(pi)
+        target = MapperStripToRect(col)
 
-        if targetIsPi == None:
+        if targetPlatform == None:
             # only print once
             print("Raspberry Pi Adafruit RGB LED Matrix detected")
+        targetPlatform = "pi"
+    except:
+        try:
+            # Next we try the Pico Interstate75 interface
+            from pico import PicoMatrix
+            target = PicoMatrix()
 
-        targetIsPi = True
-    except ModuleNotFoundError:
-        from test import TestGUI
-        target = TestGUI()
+            if targetPlatform == None:
+                # only print once
+                print("Raspberry Pi Pico Interstate75 RGB LED Matrix detected")
+            targetPlatform = "pico"
+        except:
+            # If this fails fall back to the SDL/pygame GUI
+            from test import TestGUI
+            target = TestGUI()
 
-        if targetIsPi == None:
-            # only print once
-            print("Falling back to GUI debug interface")
+            if targetPlatform == None:
+                # only print once
+                print("Falling back to GUI debug interface")
+            targetPlatform = "tk"
 
-        targetIsPi = False
     return target