game of life, initial pi support

draw.py

-#!/usr/bin/env python
+#!/usr/bin/env python3
 
 from bdfparser import Font
 from PIL import Image
                 continue
 
             font = Font(os.path.join(fontDir, filename))
-            print(f"{filename} global size is "
-                f"{font.headers['fbbx']} x {font.headers['fbby']} (pixel), "
-                f"it contains {len(font)} glyphs.")
+            #print(f"{filename} global size is "
+            #    f"{font.headers['fbbx']} x {font.headers['fbby']} (pixel), "
+            #    f"it contains {len(font)} glyphs.")
 
             # TODO hard-coded per-font offsets
             offset = 0
         self.speed = 1.0 / s
 
         self.width = self.drawer.text(self.text)
-        self.offset = -self.gui.width
-        self.last = time.time()
-        self.count = 0
+        self.restart()
 
     def restart(self):
         self.offset = -self.gui.width
         self.drawer.text(self.text, self.offset)
 
 if __name__ == "__main__":
-    from test import TestGUI
-    t = TestGUI(32, 32)
+    import platform
+    t = None
+    if platform.machine() == "armv7l":
+        from pi import PiMatrix
+        t = PiMatrix()
+    else:
+        from test import TestGUI
+        t = TestGUI()
     d = ScrollText(t, "Hello, World!")
     t.debug_loop(d.draw)

life.py

+#!/usr/bin/env python3
+
+import time
+import random
+
+class GameOfLife:
+    def __init__(self, g, f = 20, c1 = (255, 255, 255), c2 = (0, 0, 0), t = 30.0):
+        self.gui = g
+        self.interval = 1.0 / f
+        self.colorFG = c1
+        self.colorBG = c2
+        self.timeout = t
+        random.seed()
+        self.restart()
+
+    def restart(self):
+        self.data = self.init()
+        self.start = time.time()
+        self.last = time.time()
+        self.done = False
+
+    def init(self):
+        data = []
+        for x in range(0, self.gui.width):
+            d = []
+            for y in range(0, self.gui.height):
+                v = False
+                if random.randrange(0, 2) == 1:
+                    v = True
+
+                d.append(v)
+            data.append(d)
+        return data
+
+    def finished(self):
+        if self.done or ((time.time() - self.start) > self.timeout):
+            return True
+        return False
+
+    def alive(self, data, x, y):
+        if (x < 0) or (y < 0) or (x >= self.gui.width) or (y >= self.gui.height):
+            return False
+        return data[x][y]
+
+    def live_neighbours(self, data, x, y):
+        c = 0
+        for xOff in range(-1, 2):
+            for yOff in range(-1, 2):
+                if (xOff == 0) and (yOff == 0):
+                    continue
+                if self.alive(data, x + xOff, y + yOff):
+                    c += 1
+        return c
+
+    def step(self):
+        # deep copy
+        old = [x[:] for x in self.data]
+
+        for x in range(0, self.gui.width):
+            for y in range(0, self.gui.height):
+                ln = self.live_neighbours(old, x, y)
+                if old[x][y] and ((ln == 2) or (ln == 3)):
+                    # Any live cell with two or three live neighbours survives.
+                    self.data[x][y] = True
+                elif (not old[x][y]) and (ln == 3):
+                    # Any dead cell with three live neighbours becomes a live cell.
+                    self.data[x][y] = True
+                else:
+                    # All other live cells die in the next generation. Similarly, all other dead cells stay dead.
+                    self.data[x][y] = False
+
+        # compare new and old states
+        same = True
+        for x in range(0, self.gui.width):
+            for y in range(0, self.gui.height):
+                if self.data[x][y] != old[x][y]:
+                    same = False
+                    break
+        self.done = same
+
+    def draw(self):
+        if (time.time() - self.last) > self.interval:
+            self.step()
+            self.last = time.time()
+
+        for x in range(0, self.gui.width):
+            for y in range(0, self.gui.height):
+                if self.data[x][y]:
+                    self.gui.set_pixel(x, y, self.colorFG)
+                else:
+                    self.gui.set_pixel(x, y, self.colorBG)
+
+if __name__ == "__main__":
+    import platform
+    t = None
+    if platform.machine() == "armv7l":
+        from pi import PiMatrix
+        t = PiMatrix()
+    else:
+        from test import TestGUI
+        t = TestGUI()
+    g = GameOfLife(t)
+    def helper():
+        if g.finished():
+            g.restart()
+        g.draw()
+    t.debug_loop(helper)

manager.py

-#!/usr/bin/env python
+#!/usr/bin/env python3
 
 import time
 
                 self.screens[self.index][0].restart()
 
 if __name__ == "__main__":
-    from test import TestGUI
     from splash import SplashScreen
     #from weather import WeatherScreen
     from draw import ScrollText
     from solid import Solid
+    from life import GameOfLife
+
+    import platform
+    t = None
+    if platform.machine() == "armv7l":
+        from pi import PiMatrix
+        t = PiMatrix()
+    else:
+        from test import TestGUI
+        t = TestGUI()
 
-    t = TestGUI(32, 32)
     m = Manager(t)
 
     m.add(SplashScreen(t), 2)
-    m.add(Solid(t, 3.0))
+    m.add(Solid(t, 1.0))
 
     #m.add(WeatherScreen(t), 4)
-    #m.add(Solid(t, 3.0))
+    #m.add(Solid(t, 1.0))
 
     m.add(ScrollText(t, "This appears once"))
-    m.add(Solid(t, 3.0))
+    m.add(Solid(t, 1.0))
 
     m.add(ScrollText(t, "And this twice...", 2))
-    m.add(Solid(t, 3.0))
+    m.add(Solid(t, 1.0))
+
+    m.add(GameOfLife(t, 20, (0, 255, 0), (0, 0, 0), 20.0))
+    m.add(Solid(t, 1.0))
 
     t.debug_loop(m.loop)

pi.py

+#!/usr/bin/env python3
+
+from rgbmatrix import RGBMatrix, RGBMatrixOptions
+from PIL import Image
+
+class PiMatrix:
+    def __init__(self):
+        # TODO configurable
+        self.width = 32
+        self.height = 32
+
+        options = RGBMatrixOptions()
+        options.rows = 32
+        options.cols = 32
+        options.chain_length = 1
+        options.parallel = 1
+        options.row_address_type = 0
+        options.multiplexing = 0
+        options.pwm_bits = 11
+        options.brightness = 100
+        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"
+
+        self.matrix = RGBMatrix(options = options)
+
+        self.loop_start() # initialize with blank image for ScrollText constructor
+
+    def loop_start(self):
+        self.image = Image.new('RGB', (self.width, self.height))
+        return False # no input, never quit on our own
+
+    def loop_end(self):
+        self.matrix.SetImage(self.image.convert('RGB'))
+
+    def debug_loop(self, func = None):
+        while True:
+            if self.loop_start():
+                break
+            if func != None:
+                func()
+            self.loop_end()
+
+    def set_pixel(self, x, y, color):
+        if (x < 0) or (y < 0) or (x >= self.width) or (y >= self.height):
+            return
+
+        self.image.putpixel((int(x), int(y)), color)
+
+if __name__ == "__main__":
+    t = PiMatrix()
+    t.debug_loop(lambda: t.set_pixel(15, 15, (255, 255, 255)))

solid.py

-#!/usr/bin/env python
+#!/usr/bin/env python3
 
 import time
 
         self.gui = g
         self.time = t
         self.color = c
-        self.start = time.time()
+        self.restart()
 
     def restart(self):
         self.start = time.time()
                 self.gui.set_pixel(x, y, self.color)
 
 if __name__ == "__main__":
-    from test import TestGUI
-    t = TestGUI(32, 32)
+    import platform
+    t = None
+    if platform.machine() == "armv7l":
+        from pi import PiMatrix
+        t = PiMatrix()
+    else:
+        from test import TestGUI
+        t = TestGUI()
     d = ScrollText(t, "Hello, World!")
     t.debug_loop(d.draw)

splash.py

-#!/usr/bin/env python
+#!/usr/bin/env python3
 
 class SplashScreen:
     def __init__(self, g, width = 32, height = 32):
         pass
 
 if __name__ == "__main__":
-    from test import TestGUI
-    t = TestGUI()
+    import platform
+    t = None
+    if platform.machine() == "armv7l":
+        from pi import PiMatrix
+        t = PiMatrix()
+    else:
+        from test import TestGUI
+        t = TestGUI()
     s = SplashScreen(t)
     s.draw()
     t.debug_loop(s.draw)

test.py

-#!/usr/bin/env python
+#!/usr/bin/env python3
 
 import pygame
 
         self.exit()
 
     def set_pixel(self, x, y, color):
+        if (x < 0) or (y < 0) or (x >= self.width) or (y >= self.height):
+            return
+
         pygame.draw.rect(self.screen, color, pygame.Rect(x * self.multiplier, y * self.multiplier, self.multiplier, self.multiplier))
 
 if __name__ == "__main__":

weather.py

-#!/usr/bin/env python
+#!/usr/bin/env python3
 
 from pyowm.owm import OWM
 from pyowm.utils.config import get_default_config
 
 import time
 
-api_key = "API_KEY_HERE"
+api_key = "7de9d39fd4476f811000ceecbbe69376"
 
 class WeatherScreen:
     def __init__(self, gui, latitude = 47.7174, longitude = 9.3924, language = "de", refresh = 600, width = 32, height = 32):
         pass
 
 if __name__ == "__main__":
-    from test import TestGUI
-    t = TestGUI()
+    import platform
+    t = None
+    if platform.machine() == "armv7l":
+        from pi import PiMatrix
+        t = PiMatrix()
+    else:
+        from test import TestGUI
+        t = TestGUI()
     s = WeatherScreen(t)
     s.draw()
     t.debug_loop(s.draw)