initial commit

.gitignore

@@ -0,0 +1 @@
+__pycache__

README.md

@@ -0,0 +1 @@
+Included font from https://github.com/farsil/ibmfonts

draw.py

@@ -0,0 +1,97 @@
+#!/usr/bin/env python
+
+from bdfparser import Font
+from PIL import Image
+import os
+import time
+
+class DrawText:
+    def __init__(self, g):
+        self.gui = g
+
+        scriptDir = os.path.dirname(os.path.realpath(__file__))
+        fontDir = os.path.join(scriptDir, "fonts")
+        self.fonts = []
+        for f in os.listdir(os.fsencode(fontDir)):
+            filename = os.fsdecode(f)
+
+            if not filename.lower().endswith(".bdf"):
+                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.")
+
+            # TODO hard-coded per-font offsets
+            offset = 0
+            if filename == "iv18x16u.bdf":
+                offset = 6
+
+            data = (font, offset)
+            self.fonts.append(data)
+
+    def getGlyph(self, c):
+        f, o = self.fonts[0] # TODO selection of fonts
+        g = f.glyph(c).draw()
+
+        # invert color
+        g = g.replace(1, 2).replace(0, 1).replace(2, 0)
+
+        # render to pixel data
+        img = Image.frombytes('RGBA',
+                              (g.width(), g.height()),
+                              g.tobytes('RGBA'))
+        return (img, o)
+
+    def drawGlyph(self, g, xOff, yOff):
+        for x in range(0, g.width):
+            for y in range(0, g.height):
+                p = g.getpixel((x, y))
+                self.gui.set_pixel(xOff + x, yOff + y, p)
+
+    def text(self, s, offset = 0):
+        w = 0
+        for c in s:
+            g, y = self.getGlyph(c)
+            self.drawGlyph(g, -offset + w, y)
+            w += g.width
+        return w
+
+class ScrollText:
+    def __init__(self, g, t, i = 1, s = 100):
+        self.gui = g
+        self.drawer = DrawText(self.gui)
+        self.text = t
+        self.iterations = i
+        self.speed = 1.0 / s
+
+        self.width = self.drawer.text(self.text)
+        self.offset = -self.gui.width
+        self.last = time.time()
+        self.count = 0
+
+    def restart(self):
+        self.offset = -self.gui.width
+        self.last = time.time()
+        self.count = 0
+
+    def finished(self):
+        return (self.count >= self.iterations)
+
+    def draw(self):
+        if (time.time() - self.last) > self.speed:
+            self.offset = (self.offset + 1)
+            if self.offset >= self.width:
+                self.offset = -self.gui.width
+                self.count += 1
+
+            self.last = time.time()
+
+        self.drawer.text(self.text, self.offset)
+
+if __name__ == "__main__":
+    from test import TestGUI
+    t = TestGUI(32, 32)
+    d = ScrollText(t, "Hello, World!")
+    t.debug_loop(d.draw)

manager.py

@@ -0,0 +1,53 @@
+#!/usr/bin/env python
+
+import time
+
+class Manager:
+    def __init__(self, g):
+        self.gui = g
+        self.screens = []
+        self.index = 0
+        self.lastTime = time.time()
+
+    def add(self, s, d = None):
+        v = (s, d)
+        self.screens.append(v)
+
+    def loop(self):
+        self.screens[self.index][0].draw()
+
+        if self.screens[self.index][1] == None:
+            if self.screens[self.index][0].finished():
+                self.index = (self.index + 1) % len(self.screens)
+                self.lastTime = time.time()
+                self.screens[self.index][0].restart()
+        else:
+            # use given timeout
+            if (time.time() - self.lastTime) > self.screens[self.index][1]:
+                self.index = (self.index + 1) % len(self.screens)
+                self.lastTime = time.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
+
+    t = TestGUI(32, 32)
+    m = Manager(t)
+
+    m.add(SplashScreen(t), 2)
+    m.add(Solid(t, 3.0))
+
+    #m.add(WeatherScreen(t), 4)
+    #m.add(Solid(t, 3.0))
+
+    m.add(ScrollText(t, "This appears once"))
+    m.add(Solid(t, 3.0))
+
+    m.add(ScrollText(t, "And this twice...", 2))
+    m.add(Solid(t, 3.0))
+
+    t.debug_loop(m.loop)

solid.py

@@ -0,0 +1,27 @@
+#!/usr/bin/env python
+
+import time
+
+class Solid:
+    def __init__(self, g, t = 1.0, c = (0, 0, 0)):
+        self.gui = g
+        self.time = t
+        self.color = c
+        self.start = time.time()
+
+    def restart(self):
+        self.start = time.time()
+
+    def finished(self):
+        return (time.time() - self.start) >= self.time
+
+    def draw(self):
+        for x in range(0, self.gui.width):
+            for y in range(0, self.gui.height):
+                self.gui.set_pixel(x, y, self.color)
+
+if __name__ == "__main__":
+    from test import TestGUI
+    t = TestGUI(32, 32)
+    d = ScrollText(t, "Hello, World!")
+    t.debug_loop(d.draw)

splash.py

@@ -0,0 +1,32 @@
+#!/usr/bin/env python
+
+class SplashScreen:
+    def __init__(self, g, width = 32, height = 32):
+        self.gui = g
+        self.width = width
+        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 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))
+
+    def finished(self):
+        return True
+
+    def restart(self):
+        pass
+
+if __name__ == "__main__":
+    from test import TestGUI
+    t = TestGUI()
+    s = SplashScreen(t)
+    s.draw()
+    t.debug_loop(s.draw)

test.py

@@ -0,0 +1,45 @@
+#!/usr/bin/env python
+
+import pygame
+
+class TestGUI:
+    def __init__(self, width = 32, height = 32, multiplier = 16):
+        self.width = width
+        self.height = height
+        self.multiplier = multiplier
+
+        pygame.display.init()
+        self.screen = pygame.display.set_mode((self.width * self.multiplier, self.height * self.multiplier))
+        self.clock = pygame.time.Clock()
+        self.running = True
+
+    def exit(self):
+        pygame.quit()
+
+    def loop_start(self):
+        for event in pygame.event.get():
+            if event.type == pygame.QUIT:
+                return True
+
+        self.screen.fill("black")
+        return False
+
+    def loop_end(self):
+        pygame.display.flip()
+        self.clock.tick(60)
+
+    def debug_loop(self, func = None):
+        while True:
+            if self.loop_start():
+                break
+            if func != None:
+                func()
+            self.loop_end()
+        self.exit()
+
+    def set_pixel(self, x, y, color):
+        pygame.draw.rect(self.screen, color, pygame.Rect(x * self.multiplier, y * self.multiplier, self.multiplier, self.multiplier))
+
+if __name__ == "__main__":
+    t = TestGUI(32, 32)
+    t.debug_loop(lambda: t.set_pixel(15, 15, (255, 255, 255)))

weather.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python
+
+from pyowm.owm import OWM
+from pyowm.utils.config import get_default_config
+
+import time
+
+api_key = "API_KEY_HERE"
+
+class WeatherScreen:
+    def __init__(self, gui, latitude = 47.7174, longitude = 9.3924, language = "de", refresh = 600, width = 32, height = 32):
+        self.gui = gui
+        self.latitude = latitude
+        self.longitude = longitude
+        self.language = language
+        self.refresh = refresh
+        self.width = width
+        self.height = height
+
+        self.lastTime = time.time()
+        self.data = ""
+
+        self.fetchData()
+
+    def fetchData(self):
+        config_dict = get_default_config()
+        config_dict['language'] = self.language
+        owm = OWM(api_key, config_dict)
+        mgr = owm.weather_manager()
+
+        observation = mgr.weather_at_place("Tuttlingen, DE")
+        print(observation.weather.rain)
+        print(observation.weather.snow)
+        print(observation.weather.wind)
+        print(observation.weather.humidity)
+        print(observation.weather.pressure)
+        print(observation.weather.temperature)
+        print(observation.weather.clouds)
+        print(observation.weather.status)
+        print(observation.weather.detailed_status)
+        print(observation.weather.weather_icon_name)
+        print(observation.weather.precipitation_probability)
+
+        #self.data = mgr.one_call(lat=self.latitude, lon=self.longitude)
+        #print(self.data.forecast_hourly[0].wind().get("speed", 0))
+
+    def draw(self):
+        if (time.time() - self.lastTime) > self.refresh:
+            self.fetchData()
+            self.lastTime = time.time()
+
+        # TODO text location
+        # TODO text data
+
+    def finished(self):
+        return True
+
+    def restart(self):
+        pass
+
+if __name__ == "__main__":
+    from test import TestGUI
+    t = TestGUI()
+    s = WeatherScreen(t)
+    s.draw()
+    t.debug_loop(s.draw)