support multiple chained panels. color remapping for differing panel brightness.

README.md

 
 You always need:
 
-    pip install pil
-    pip install bdfparser
-    pip install "qrcode[pil]"
-    pip install evdev
+    pip install Pillow bdfparser "qrcode[pil]" evdev
 
 For evdev to find all devices you may need to add your user to the `input` group or run the scripts as root.
 

draw.py

     m = Manager(t)
 
     m.add(ScrollText(t, "tom-thumb Abcdefgh tom-thumb", "tom-thumb",
-                     1, 75, (0, 255, 0), (0, 0, 255)))
+                     1, 75, (0, 255, 0), (0, 0, 25)))
     m.add(ScrollText(t, "antidote Abcdefgh antidote", "antidote",
-                     1, 75, (0, 255, 0), (0, 0, 255)))
+                     1, 75, (0, 255, 0), (0, 0, 25)))
     m.add(ScrollText(t, "uushi Abcdefgh uushi", "uushi",
-                     1, 75, (0, 255, 0), (0, 0, 255)))
+                     1, 75, (0, 255, 0), (0, 0, 25)))
     m.add(ScrollText(t, "lemon Abcdefgh lemon", "lemon",
-                     1, 75, (0, 255, 0), (0, 0, 255)))
+                     1, 75, (0, 255, 0), (0, 0, 25)))
     m.add(ScrollText(t, "ib8x8u Abcdefgh ib8x8u", "ib8x8u",
-                     1, 75, (0, 255, 0), (0, 0, 255)))
+                     1, 75, (0, 255, 0), (0, 0, 25)))
     m.add(ScrollText(t, "iv18x16u Abcdefgh iv18x16u", "iv18x16u",
-                     1, 75, (0, 255, 0), (0, 0, 255)))
+                     1, 75, (0, 255, 0), (0, 0, 25)))
 
     m.restart()
     t.debug_loop(m.draw)

mapper.py

+#!/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
+# ----------------------------------------------------------------------------
+
+# Does nothing. Take this as an example for new Mappers.
+class MapperNull:
+    def __init__(self, g):
+        self.gui = g
+        self.width = self.gui.width
+        self.height = self.gui.height
+        self.multiplier = self.gui.multiplier
+        self.panelW = self.gui.panelW
+        self.panelH = self.gui.panelH
+
+    def loop_start(self):
+        return self.gui.loop_start()
+
+    def loop_end(self):
+        self.gui.loop_end()
+
+    def debug_loop(self, func = None):
+        self.gui.debug_loop(func)
+
+    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.
+# 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 "old" type with less bright LEDs.
+        # rest of panels to the left are brighter.
+        # so adjust brightness of left panel rg channels down.
+        if x < self.gui.panelW:
+            color = (int(color[0] * 0.75), int(color[1] * 0.75), color[2])
+
+        self.gui.set_pixel(x, y, color)

pi.py

 # And the pillow Python Imaging Library:
 # https://github.com/python-pillow/Pillow
 #
+# For the wiring of multiple panels, check out:
+# https://github.com/hzeller/rpi-rgb-led-matrix/blob/master/wiring.md#chains
+#
+# Basically each chain only stretches in the X-direction.
+# For the Y-direction, multiple parallel chains are used.
+# Up to 3 are theoretically possible with the Pi, but my hardware only supports
+# one.
+#
+# The physical layout of the chained panels can be different of course.
+# For four panels, you could do 64x64 or 32x128.
+# But this PiMatrix object will always present it as 128x32,
+# chained in the X-direction.
+#
+# Use the objects from mapper.py to adjust this.
+#
 # ----------------------------------------------------------------------------
 # "THE BEER-WARE LICENSE" (Revision 42):
 # <xythobuz@xythobuz.de> wrote this file.  As long as you retain this notice
 from PIL import Image
 
 class PiMatrix:
-    def __init__(self, w = 32, h = 32):
-        self.width = w
-        self.height = h
+    def __init__(self, w = 64, h = 32, panelW = 32, panelH = 32):
+        self.width = w # x-axis
+        self.height = h # y-axis
+
+        self.panelW = panelW # x-axis
+        self.panelH = panelH # y-axis
+
+        # compatibility to TestGUI
+        self.multiplier = 1.0
 
         options = RGBMatrixOptions()
-        options.rows = w
-        options.cols = h
-        options.chain_length = 1
-        options.parallel = 1
+
+        options.cols = self.panelW # x-axis
+        options.rows = self.panelH # y-axis
+
+        options.chain_length = int(self.width / options.cols) # x-axis
+        options.parallel = int(self.height / options.rows) # y-axis
+
         options.row_address_type = 0
         options.multiplexing = 0
         options.pwm_bits = 11
         options.pwm_lsb_nanoseconds = 130
         options.led_rgb_sequence = 'RGB'
         #options.hardware_mapping = 'regular'  # If you have an Adafruit HAT: 'adafruit-hat'
-        options.gpio_slowdown = 2
-        options.pixel_mapper_config = "Rotate:270"
+        #options.gpio_slowdown = 2
+        #options.pixel_mapper_config = "Rotate:270"
+
+        # newer Pimoroni 32x32 panels require this setting for additional
+        # initialization of the shift-registers on there.
+        # fortunately this also works for the older type of panels.
+        options.panel_type = "FM6126A"
 
         self.matrix = RGBMatrix(options = options)
 

solid.py

     def __init__(self, g, t = 1.0, c = (0, 0, 0)):
         self.gui = g
         self.time = t
-        self.color = c
+        self.setColor(c)
         self.restart()
 
+    def setColor(self, c):
+        self.color = c
+
     def restart(self):
         self.start = time.time()
 
     import util
     t = util.getTarget()
 
-    d = Solid(t, 1.0, (0, 255, 0))
-    t.debug_loop(d.draw)
+    colors = [
+        (251, 72, 196), # camp23 pink
+        (63, 255, 33), # camp23 green
+        (255, 0, 0),
+        (0, 255, 0),
+        (0, 0, 255),
+        (255, 255, 0),
+        (0, 255, 255),
+        (255, 0, 255),
+        (255, 255, 255),
+    ]
+    ci = 0
+
+    d = Solid(t, 1.0, colors[ci])
+
+    s = time.time()
+    def helper():
+        global s, colors, ci
+
+        if (time.time() - s) >= 1.0:
+            s = time.time()
+            ci = (ci + 1) % len(colors)
+            c = colors[ci]
+            d.setColor(c)
+
+        d.draw()
+
+    t.debug_loop(helper)

splash.py

         self.height = height
 
     def draw(self):
-        self.gui.set_pixel(             0,               0, (255, 255, 255))
-        self.gui.set_pixel(             0, self.height - 1, (  0,   0, 255))
-        self.gui.set_pixel(self.width - 1,               0, (255,   0,   0))
-        self.gui.set_pixel(self.width - 1, self.height - 1, (  0, 255,   0))
+        for x in range(0, int(self.gui.width / self.width)):
+            for y in range(0, int(self.gui.height / self.height)):
+                self.drawOnce(x * self.width, y * self.height)
+
+    def drawOnce(self, x, y):
+        self.gui.set_pixel(             x,               y, (255, 255, 255))
+        self.gui.set_pixel(             x, self.height - 1 + y, (  0,   0, 255))
+        self.gui.set_pixel(self.width - 1 + x,               y, (255,   0,   0))
+        self.gui.set_pixel(self.width - 1 + x, self.height - 1 + y, (  0, 255,   0))
 
         for i in range(0, int(min(self.width, self.height) / 3)):
-            self.gui.set_pixel((self.width / 2) - 1 + i, (self.height / 2) - 1 + i, (255, 255, 255))
-            self.gui.set_pixel((self.width / 2) - 1 - i, (self.height / 2) - 1 - i, (255, 255, 255))
-            self.gui.set_pixel((self.width / 2) - 1 + i, (self.height / 2) - 1 - i, (255, 255, 255))
-            self.gui.set_pixel((self.width / 2) - 1 - i, (self.height / 2) - 1 + i, (255, 255, 255))
+            self.gui.set_pixel((self.width / 2) - 1 + i + x, (self.height / 2) - 1 + i + y, (255, 255, 255))
+            self.gui.set_pixel((self.width / 2) - 1 - i + x, (self.height / 2) - 1 - i + y, (255, 255, 255))
+            self.gui.set_pixel((self.width / 2) - 1 + i + x, (self.height / 2) - 1 - i + y, (255, 255, 255))
+            self.gui.set_pixel((self.width / 2) - 1 - i + x, (self.height / 2) - 1 + i + y, (255, 255, 255))
 
     def finished(self):
         return True

test.py

         self.height = height
         self.multiplier = multiplier
 
+        # compatibility to PiMatrix
+        self.panelW = self.width
+        self.panelH = self.height
+
         pygame.display.init()
         self.screen = pygame.display.set_mode((self.width * self.multiplier, self.height * self.multiplier))
         self.clock = pygame.time.Clock()

util.py

     target = None
     try:
         from pi import PiMatrix
-        target = PiMatrix()
+        pi = PiMatrix()
+
+        # TODO hard-coded adjustments
+        from mapper import MapperColorAdjust
+        target = MapperColorAdjust(pi)
 
         if targetIsPi == None:
             # only print once