add image reading, http availability checker.

README.md

@@ -22,3 +22,5 @@ This project is licensed as beer-ware:
     ----------------------------------------------------------------------------
 
 The included font from [farsil/ibmfonts](https://github.com/farsil/ibmfonts) is licensed as `CC-BY-SA-4.0`.
+
+The included GIFs are from [GifCities](https://gifcities.org/?q=32)

camp_small.py

@@ -0,0 +1,42 @@
+#!/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
+# ----------------------------------------------------------------------------
+
+if __name__ == "__main__":
+    from splash import SplashScreen
+    from draw import ScrollText
+    from solid import Solid
+    from life import GameOfLife
+    from net import CheckHTTP
+    from image import ImageScreen
+    from manager import Manager
+
+    import util
+    t = util.getTarget()
+
+    splash = SplashScreen(t)
+    t.loop_start()
+    splash.draw()
+    t.loop_end()
+
+    success = Manager(t)
+    success.add(ScrollText(t, "TODO"))
+    success.add(Solid(t, 1.0))
+
+    fail = Manager(t)
+    fail.add(ImageScreen(t, "attention.gif", 0.2, 2, 20.0, (0, 0, 0)))
+    fail.add(ScrollText(t, "The UbaBot Cocktail machine is currently closed. Please come back later for more drinks!", 2))
+    fail.add(Solid(t, 2.0))
+    fail.add(GameOfLife(t, 20, (0, 255, 0), (0, 0, 0), None, 2.0))
+    fail.add(Solid(t, 2.0))
+
+    d = CheckHTTP("http://ubabot.frubar.net")
+    d.success(success)
+    d.fail(fail)
+
+    t.debug_loop(d.draw)

draw.py

@@ -84,9 +84,9 @@ class DrawText:
             if xOff >= -10: # some wiggle room so chars dont disappear
                 self.drawGlyph(g, xOff, y)
         return w
-
+import sys
 class ScrollText:
-    def __init__(self, g, t, i = 1, s = 50):
+    def __init__(self, g, t, i = 1, s = 75):
         self.gui = g
         self.drawer = DrawText(self.gui)
         self.text = t
@@ -106,7 +106,8 @@ class ScrollText:
 
     def draw(self):
         if (time.time() - self.last) > self.speed:
-            self.offset += (time.time() - self.last) / self.speed
+            off = (time.time() - self.last) / self.speed
+            self.offset += int(off)
             self.last = time.time()
             if self.offset >= self.width:
                 self.offset = -self.gui.width
@@ -115,14 +116,8 @@ class ScrollText:
         self.drawer.text(self.text, self.offset, True)
 
 if __name__ == "__main__":
-    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!")
+    import util
+    t = util.getTarget()
+
+    d = ScrollText(t, "This is a long scrolling text. Is it too fast or maybe too slow?")
     t.debug_loop(d.draw)

image.py

@@ -0,0 +1,84 @@
+#!/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
+# ----------------------------------------------------------------------------
+
+from PIL import Image
+import time
+import os
+
+class ImageScreen:
+    def __init__(self, g, p, t = 0.2, i = 1, to = 20.0, bg = None):
+        self.gui = g
+        self.time = t
+        self.iterations = i
+        self.timeout = to
+        self.background = bg
+
+        scriptDir = os.path.dirname(os.path.realpath(__file__))
+        self.path = os.path.join(scriptDir, "images", p)
+        self.image = Image.open(self.path)
+        print(p, self.image.width, self.image.height, self.image.is_animated, self.image.n_frames)
+
+        self.restart()
+
+    def restart(self):
+        self.start = time.time()
+        self.frame = time.time()
+        self.count = 0
+        self.done = 0
+        self.image.seek(0)
+
+    def finished(self):
+        if self.done >= self.iterations:
+            return True
+        return (time.time() - self.start) >= self.timeout
+
+    def draw(self):
+        if self.image.is_animated:
+            if (time.time() - self.frame) >= self.time:
+                self.frame = time.time()
+                self.count = (self.count + 1) % self.image.n_frames
+                if self.count == 0:
+                    self.done += 1
+
+                self.image.seek(self.count)
+
+        p = self.image.getpalette()
+        for x in range(0, self.image.width):
+            for y in range(0, self.image.height):
+                v = self.image.getpixel((x, y))
+                if isinstance(v, int):
+                    c = None
+                    if self.background != None:
+                        if "transparency" in self.image.info:
+                            if v == self.image.info["transparency"]:
+                                c = self.background
+                        else:
+                            if v == self.image.info["background"]:
+                                c = self.background
+                    if c == None:
+                        c = (p[v * 3 + 0], p[v * 3 + 1], p[v * 3 + 2])
+                    self.gui.set_pixel(x, y, c)
+                else:
+                    self.gui.set_pixel(x, y, v)
+
+if __name__ == "__main__":
+    import util
+    t = util.getTarget()
+
+    from manager import Manager
+    m = Manager(t)
+
+    scriptDir = os.path.dirname(os.path.realpath(__file__))
+    imageDir = os.path.join(scriptDir, "images")
+    for f in os.listdir(os.fsencode(imageDir)):
+        filename = os.fsdecode(f)
+        m.add(ImageScreen(t, os.path.join(imageDir, filename)))
+
+    m.restart()
+    t.debug_loop(m.draw)

life.py

@@ -11,21 +11,25 @@ import time
 import random
 
 class GameOfLife:
-    def __init__(self, g, f = 20, c1 = (255, 255, 255), c2 = (0, 0, 0), t = 20.0, rc = None):
+    def __init__(self, g, f = 20, c1 = (255, 255, 255), c2 = (0, 0, 0), t = 20.0, rc = None, bt = 45.0):
         self.gui = g
         self.interval = 1.0 / f
         self.setColors(c1, c2)
         self.timeout = t
         self.randomizeColors = rc
+        self.backupTimeout = bt
         random.seed()
         self.restart()
 
+        self.editDistFinish = 20
+
     def restart(self):
         self.data = self.init()
         self.start = time.time()
         self.last = time.time()
         self.lastColor = time.time()
         self.done = False
+        self.lastDiff = 100
 
         if self.randomizeColors != None:
             self.randomize()
@@ -53,8 +57,18 @@ class GameOfLife:
         return data
 
     def finished(self):
-        if self.done or ((time.time() - self.start) > self.timeout):
+        if self.done:
             return True
+
+        if self.timeout != None:
+            if (time.time() - self.start) > self.timeout:
+                return True
+        else:
+            if self.lastDiff < self.editDistFinish:
+                return True
+            if (time.time() - self.start) > self.backupTimeout:
+                return True
+
         return False
 
     def alive(self, data, x, y):
@@ -93,13 +107,19 @@ class GameOfLife:
                     self.data[x][y] = False
 
         # compare new and old states
-        same = True
+        diff = 0
         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
+                    diff += 1
+                    if self.timeout == None:
+                        if diff >= self.editDistFinish:
+                            break
+                    else:
+                        if diff >= 1:
+                            break
+        self.done = (diff == 0)
+        self.lastDiff = diff
 
     def draw(self):
         if (time.time() - self.last) > self.interval:
@@ -109,7 +129,7 @@ class GameOfLife:
         if (self.randomizeColors != None) and (self.randomizeColors != True):
             if (time.time() - self.lastColor) > self.randomizeColors:
                 self.lastColor = time.time()
-                g.randomize()
+                self.randomize()
 
         for x in range(0, self.gui.width):
             for y in range(0, self.gui.height):
@@ -119,16 +139,10 @@ class GameOfLife:
                     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, 20, (255, 255, 255), (0, 0, 0), 20.0, 2.0)
+    import util
+    t = util.getTarget()
+
+    g = GameOfLife(t, 20, (255, 255, 255), (0, 0, 0), None, 2.0)
 
     def helper():
         if g.finished():

manager.py

@@ -53,19 +53,15 @@ if __name__ == "__main__":
     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()
+    import util
+    t = util.getTarget()
 
-    m = Manager(t)
+    splash = SplashScreen(t)
+    t.loop_start()
+    splash.draw()
+    t.loop_end()
 
-    m.add(SplashScreen(t), 2)
-    m.add(Solid(t, 1.0))
+    m = Manager(t)
 
     m.add(ScrollText(t, "This appears once"))
     m.add(Solid(t, 1.0))

net.py

@@ -0,0 +1,69 @@
+#!/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 time
+import requests
+
+class CheckHTTP:
+    def __init__(self, u, r = 600.0):
+        self.url = u
+        self.refresh = r
+        self.successScreen = None
+        self.failScreen = None
+        self.restart()
+
+    def success(self, s):
+        self.successScreen = s
+
+    def fail(self, f):
+        self.failScreen = f
+
+    def restart(self):
+        self.start = time.time()
+        self.response = None
+        self.request()
+
+        if self.successScreen != None:
+            self.successScreen.restart()
+        if self.failScreen != None:
+            self.failScreen.restart()
+
+    def request(self):
+        if (self.response == None) or ((time.time() - self.start) >= self.refresh):
+            self.start = time.time()
+            try:
+                r = requests.get(self.url)
+                self.response = r.ok
+            except:
+                self.response = False
+
+    def finished(self):
+        self.request()
+        if self.response:
+            return self.successScreen.finished()
+        else:
+            return self.failScreen.finished()
+
+    def draw(self):
+        self.request()
+        if self.response:
+            return self.successScreen.draw()
+        else:
+            return self.failScreen.draw()
+
+if __name__ == "__main__":
+    from draw import ScrollText
+    import util
+    t = util.getTarget()
+
+    d = CheckHTTP("http://xythobuz.de")
+    d.success(ScrollText(t, "Success"))
+    d.fail(ScrollText(t, "Failure"))
+
+    t.debug_loop(d.draw)

solid.py

@@ -28,14 +28,8 @@ class Solid:
                 self.gui.set_pixel(x, y, self.color)
 
 if __name__ == "__main__":
-    import platform
-    t = None
-    if platform.machine() == "armv7l":
-        from pi import PiMatrix
-        t = PiMatrix()
-    else:
-        from test import TestGUI
-        t = TestGUI()
+    import util
+    t = util.getTarget()
 
     d = Solid(t, 1.0, (0, 255, 0))
     t.debug_loop(d.draw)

splash.py

@@ -32,15 +32,7 @@ class SplashScreen:
         pass
 
 if __name__ == "__main__":
-    import platform
-    t = None
-    if platform.machine() == "armv7l":
-        from pi import PiMatrix
-        t = PiMatrix()
-    else:
-        from test import TestGUI
-        t = TestGUI()
-
+    import util
+    t = util.getTarget()
     s = SplashScreen(t)
-    s.draw()
     t.debug_loop(s.draw)

util.py

@@ -0,0 +1,20 @@
+#!/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 platform
+
+def getTarget():
+    t = None
+    if platform.machine() == "armv7l":
+        from pi import PiMatrix
+        t = PiMatrix()
+    else:
+        from test import TestGUI
+        t = TestGUI()
+    return t