From 9ed2feb9b1702471abdcc7a41cbcf42dd728bd01 Mon Sep 17 00:00:00 2001
From: Erik Sommer <ersotech@posteo.de>
Date: Mon, 4 Oct 2021 22:30:36 +0200
Subject: [PATCH 1/2] Make all hardware classes singletons

- this removes the need of passing the objects as init values
---
 apps.py      |  20 +++---
 buttons.py   |  33 +++++----
 clock.py     |  14 ++--
 display.py   | 193 ++++++++++++++++++++++++++-------------------------
 main.py      |  22 +++---
 pomodoro.py  |  12 ++--
 rtc.py       |   3 +
 scheduler.py |   7 +-
 speaker.py   |   4 ++
 time_set.py  |  13 ++--
 util.py      |   7 ++
 11 files changed, 178 insertions(+), 150 deletions(-)
 create mode 100644 util.py

diff --git a/apps.py b/apps.py
index 31f848a..ef80e34 100644
--- a/apps.py
+++ b/apps.py
@@ -1,3 +1,7 @@
+from buttons import Buttons
+from display import Display
+
+
 class App:
     def __init__(self, name, label):
         self.name = name
@@ -8,11 +12,11 @@ def __init__(self, name, label):
     def top_button(self, t):
         print("top_button not implemented for " + self.name)
 
-class Apps:
 
-    def __init__(self, display, buttons):
-        self.display = display
-        self.buttons = buttons
+class Apps:
+    def __init__(self, scheduler):
+        self.display = Display(scheduler)
+        self.buttons = Buttons(scheduler)
         self.apps = []
         self.current_app = 0
         self.buttons.add_callback(1, self.next, max=500)
@@ -20,7 +24,7 @@ def __init__(self, display, buttons):
         self.buttons.add_callback(1, self.exit, min=500)
 
     def add(self, app):
-        if len(self.apps)==0:
+        if len(self.apps) == 0:
             app.enable()
         self.apps.append(app)
 
@@ -28,12 +32,12 @@ def next(self, t):
         print("NEXT")
         if len(self.apps) == 0:
             return
-        
+
         app = self.apps[self.current_app]
         if app.active and app.grab_top_button:
             app.top_button(t)
             return
-        
+
         self.apps[self.current_app].disable()
         self.buttons.clear_callbacks(2)
         self.buttons.clear_callbacks(3)
@@ -50,7 +54,7 @@ def previous(self, t):
             self.apps[self.current_app].enable()
 
     def exit(self, t):
-        if len(self.apps) >0:
+        if len(self.apps) > 0:
             self.apps[self.current_app].disable()
             self.current_app = 0
             self.apps[self.current_app].enable()
diff --git a/buttons.py b/buttons.py
index c59221a..8ef4708 100644
--- a/buttons.py
+++ b/buttons.py
@@ -1,17 +1,21 @@
 from machine import Pin
 import time
 
-STATE_UNPRESSED=1
-STATE_PRESSED=2
+from util import singleton
 
-class Buttons:
-    PINS = {
+STATE_UNPRESSED = 1
+STATE_PRESSED = 2
+
+PINS = {
     1: 2,
     2: 17,
     3: 15,
 }
-    class Button:
 
+
+@singleton
+class Buttons:
+    class Button:
         class Callback:
             def __init__(self, callback, min=0, max=-1):
                 self.callback = callback
@@ -19,7 +23,7 @@ def __init__(self, callback, min=0, max=-1):
                 self.max = max
 
         def __init__(self, number):
-            self.pin = Pin(Buttons.PINS[number], Pin.IN, Pin.PULL_UP)
+            self.pin = Pin(PINS[number], Pin.IN, Pin.PULL_UP)
             self.number = number
             self.state = STATE_UNPRESSED
             self.callbacks = []
@@ -41,25 +45,25 @@ def clear_callbacks(self):
 
     def __init__(self, scheduler):
         self.buttons = [
-            Buttons.Button(number) for number in (1,2,3)
+            self.Button(number) for number in (1, 2, 3)
         ]
         scheduler.schedule("button-press", 1, self.millis_callback)
 
     def add_callback(self, number, callback, min=0, max=-1):
-        self.buttons[number-1].add_callback(callback, min, max)
+        self.buttons[number - 1].add_callback(callback, min, max)
 
     def remove_callback(self, number, callback, min=0, max=-1):
-        self.buttons[number-1].remove_callback(callback, min, max)
+        self.buttons[number - 1].remove_callback(callback, min, max)
 
     def clear_callbacks(self, number):
-        self.buttons[number-1].clear_callbacks()
+        self.buttons[number - 1].clear_callbacks()
 
     def get_button(self, number):
-        return self.buttons[number-1]
+        return self.buttons[number - 1]
 
     def millis_callback(self, t):
         for button in self.buttons:
-            if len(button.callbacks)>0:
+            if len(button.callbacks) > 0:
                 if button.state == STATE_UNPRESSED and button.pin.value() == 0:
                     button.state = STATE_PRESSED
                     button.pressed = time.ticks_ms()
@@ -67,9 +71,10 @@ def millis_callback(self, t):
                     button.state = STATE_UNPRESSED
                     tm = time.ticks_ms()
                     press_duration = time.ticks_diff(tm, button.pressed)
-                    print("Button %d pressed for %dms" %(button.number, press_duration))
+                    print("Button %d pressed for %dms" % (button.number, press_duration))
                     for callback in button.callbacks:
-                        if callback.min < press_duration and (callback.max==-1 or press_duration <= callback.max):
+                        if callback.min < press_duration and (
+                                callback.max == -1 or press_duration <= callback.max):
                             callback.callback(t)
                             break
                     button.pressed = None
diff --git a/clock.py b/clock.py
index 787aca3..b9e000d 100644
--- a/clock.py
+++ b/clock.py
@@ -1,13 +1,15 @@
 import time
 from apps import App
+from display import Display
+from rtc import RTC
+
 
 class Clock(App):
-    def __init__(self, scheduler, display, rtc):
+    def __init__(self, scheduler):
         App.__init__(self, "Clock", "clock")
-        self.display = display
-        self.rtc = rtc
+        self.display = Display(scheduler)
+        self.rtc = RTC()
         self.enabled = True
-        self.scheduler = scheduler
         scheduler.schedule("clock-second", 1000, self.secs_callback)
         scheduler.schedule("clock-minute", 60000, self.mins_callback)
 
@@ -21,7 +23,7 @@ def disable(self):
     def secs_callback(self, t):
         if self.enabled:
             t = time.time()
-            if t%2==0:
+            if t % 2 == 0:
                 self.display.show_char(":", pos=10)
             else:
                 self.display.show_char(" :", pos=10)
@@ -29,7 +31,7 @@ def secs_callback(self, t):
     def mins_callback(self, t):
         if self.enabled:
             self.update_time()
-    
+
     def update_time(self):
         t = self.rtc.get_time()
         now = "%02d:%02d" % (t[3], t[4])
diff --git a/display.py b/display.py
index bda0161..2b3c721 100644
--- a/display.py
+++ b/display.py
@@ -1,7 +1,9 @@
-import time
 from machine import Pin, Timer
-import random
 
+from util import singleton
+
+
+@singleton
 class Display:
     def __init__(self, scheduler):
         self.a0 = Pin(16, Pin.OUT)
@@ -14,16 +16,16 @@ def __init__(self, scheduler):
 
         self.row = 0
         self.count = 0
-        self.leds = [[0] * 32 for i in range(0,8)]
+        self.leds = [[0] * 32 for i in range(0, 8)]
         self.leds_changed = False
         self.disp_offset = 2
         self.initialise_fonts()
         self.initialise_icons()
         scheduler.schedule("enable-leds", 1, self.enable_leds)
-        
+
     def enable_leds(self, t):
-        self.count+=1
-        self.row = (self.row+1)%8
+        self.count += 1
+        self.row = (self.row + 1) % 8
         led_row = self.leds[self.row]
         if True:
             for col in range(32):
@@ -33,77 +35,77 @@ def enable_leds(self, t):
             self.le.value(1)
             self.le.value(0)
             self.leds_changed = False
-        
-        self.a0.value(1 if self.row&0x01 else 0)
-        self.a1.value(1 if self.row&0x02 else 0)
-        self.a2.value(1 if self.row&0x04 else 0)
+
+        self.a0.value(1 if self.row & 0x01 else 0)
+        self.a1.value(1 if self.row & 0x02 else 0)
+        self.a2.value(1 if self.row & 0x04 else 0)
 
     def clear(self, x=0, y=0, w=24, h=7):
-        for yy in range(y, y+h+1):
-            for xx in range(x, x+w+1):
-                self.leds[yy][xx]=0
+        for yy in range(y, y + h + 1):
+            for xx in range(x, x + w + 1):
+                self.leds[yy][xx] = 0
 
     def show_char(self, character, pos):
-        pos+=self.disp_offset # Plus the offset of the status indicator 
+        pos += self.disp_offset  # Plus the offset of the status indicator
         char = self.ziku[character]
-        for row in range(1,8):
-            byte = char.rows[row-1]
+        for row in range(1, 8):
+            byte = char.rows[row - 1]
             for col in range(0, char.width):
-                self.leds[row][pos+col] = (byte >> col) % 2
+                self.leds[row][pos + col] = (byte >> col) % 2
         self.leds_changed = True
 
     def show_text(self, text, pos=0):
-        i=0
-        while i<len(text):
-            if text[i:i+2] in self.ziku:
-                c=text[i:i+2]
-                i+=2
+        i = 0
+        while i < len(text):
+            if text[i:i + 2] in self.ziku:
+                c = text[i:i + 2]
+                i += 2
             else:
-                c=text[i]
-                i+=1
+                c = text[i]
+                i += 1
             char = self.ziku[c]
             self.show_char(c, pos)
             width = self.ziku[c].width
-            pos+=width+1
+            pos += width + 1
 
     def show_icon(self, name):
         icon = self.Icons[name]
         for w in range(icon.width):
-            self.leds[icon.y][icon.x+w]=1
+            self.leds[icon.y][icon.x + w] = 1
         self.leds_changed = True
 
     def hide_icon(self, name):
         icon = self.Icons[name]
         for w in range(icon.width):
-            self.leds[icon.y][icon.x+w]=0
+            self.leds[icon.y][icon.x + w] = 0
         self.leds_changed = True
 
     def backlight_on(self):
-        self.leds[0][2]=1
-        self.leds[0][5]=1
+        self.leds[0][2] = 1
+        self.leds[0][5] = 1
 
     def backlight_off(self):
-        self.leds[0][2]=0
-        self.leds[0][5]=0
+        self.leds[0][2] = 0
+        self.leds[0][5] = 0
 
     def print(self):
-        for row in range(0,8):
+        for row in range(0, 8):
             for pos in range(0, 24):
-                print("X" if self.leds[row][pos]==1 else " ", end="")
+                print("X" if self.leds[row][pos] == 1 else " ", end="")
             print("")
 
     def square(self):
         '''
         Prints a crossed square. For debugging purposes.
         '''
-        for row in range(1,8):
-            self.leds[row][2]=1
-            self.leds[row][23]=1
-        for col in range(2,23):
-            self.leds[1][col]=1
-            self.leds[7][col]=1
-            self.leds[int(col/24*7)+1][col]=1
-            self.leds[7-int(col/24*7)][col]=1
+        for row in range(1, 8):
+            self.leds[row][2] = 1
+            self.leds[row][23] = 1
+        for col in range(2, 23):
+            self.leds[1][col] = 1
+            self.leds[7][col] = 1
+            self.leds[int(col / 24 * 7) + 1][col] = 1
+            self.leds[7 - int(col / 24 * 7)][col] = 1
 
     class Character:
         def __init__(self, width, rows, offset=2):
@@ -115,30 +117,31 @@ class Icon:
         def __init__(self, x, y, width=1):
             self.x = x
             self.y = y
-            self.width=width
+            self.width = width
 
     def initialise_icons(self):
         self.Icons = {
-            "MoveOn": self.Icon(0,0, width=2),
-            "AlarmOn": self.Icon(0,1, width=2),
-            "CountDown": self.Icon(0,2, width=2),
-            "°F": self.Icon(0,3),
-            "°C": self.Icon(1,3),
-            "AM": self.Icon(0,4),
-            "PM": self.Icon(1,4),
-            "CountUp": self.Icon(0,5, width=2),
-            "Hourly": self.Icon(0,6, width=2),
-            "AutoLight": self.Icon(0,7, width=2),
-            "Mon": self.Icon(3,0, width=2),
-            "Tue": self.Icon(6,0, width=2),
-            "Wed": self.Icon(9,0, width=2),
-            "Thur": self.Icon(12,0, width=2),
-            "Fri": self.Icon(15,0, width=2),
-            "Sat": self.Icon(18,0, width=2),
-            "Sun": self.Icon(21,0, width=2),
+            "MoveOn": self.Icon(0, 0, width=2),
+            "AlarmOn": self.Icon(0, 1, width=2),
+            "CountDown": self.Icon(0, 2, width=2),
+            "°F": self.Icon(0, 3),
+            "°C": self.Icon(1, 3),
+            "AM": self.Icon(0, 4),
+            "PM": self.Icon(1, 4),
+            "CountUp": self.Icon(0, 5, width=2),
+            "Hourly": self.Icon(0, 6, width=2),
+            "AutoLight": self.Icon(0, 7, width=2),
+            "Mon": self.Icon(3, 0, width=2),
+            "Tue": self.Icon(6, 0, width=2),
+            "Wed": self.Icon(9, 0, width=2),
+            "Thur": self.Icon(12, 0, width=2),
+            "Fri": self.Icon(15, 0, width=2),
+            "Sat": self.Icon(18, 0, width=2),
+            "Sun": self.Icon(21, 0, width=2),
         }
-# Derived from c code created by yufu on 2021/1/23.
-# Modulus method: negative code, reverse, line by line, 4X7 font 
+
+    # Derived from c code created by yufu on 2021/1/23.
+    # Modulus method: negative code, reverse, line by line, 4X7 font
     def initialise_fonts(self):
         self.ziku = {
             "all": self.Character(width=3, rows=[0x05,0x05,0x03,0x03,0x03,0x03,0x03]),
@@ -179,38 +182,38 @@ def initialise_fonts(self):
             "W": self.Character(width=4, rows=[0x11,0x11,0x11,0x15,0x15,0x1B,0x11]),        # 5×7
         }
         self.digital_tube = {
-            "0": [0x0F,0x09,0x09,0x09,0x09,0x09,0x0F],
-            "1": [0x08,0x08,0x08,0x08,0x08,0x08,0x08],
-            "2": [0x0F,0x08,0x08,0x0F,0x01,0x01,0x0F],
-            "3": [0x0F,0x08,0x08,0x0F,0x08,0x08,0x0F],
-            "4": [0x09,0x09,0x09,0x0F,0x08,0x08,0x08],
-            "5": [0x0F,0x01,0x01,0x0F,0x08,0x08,0x0F],
-            "5": [0x0F,0x01,0x01,0x0F,0x09,0x09,0x0F],
-            "6": [0x0F,0x08,0x08,0x08,0x08,0x08,0x08],
-            "7": [0x0F,0x09,0x09,0x0F,0x09,0x09,0x0F],
-            "8": [0x0F,0x09,0x09,0x0F,0x08,0x08,0x0F],
-            "A": [0x0F,0x09,0x09,0x0F,0x09,0x09,0x09],
-            "B": [0x01,0x01,0x01,0x0F,0x09,0x09,0x0F],
-            "C": [0x0F,0x01,0x01,0x01,0x01,0x01,0x0F],
-            "D": [0x08,0x08,0x08,0x0F,0x09,0x09,0x0F],
-            "E": [0x0F,0x01,0x01,0x0F,0x01,0x01,0x0F],
-            "F": [0x0F,0x01,0x01,0x0F,0x01,0x01,0x01],
-            "H": [0x09,0x09,0x09,0x0F,0x09,0x09,0x09],
-            "L": [0x01,0x01,0x01,0x01,0x01,0x01,0x0F],
-            "N": [0x0F,0x09,0x09,0x09,0x09,0x09,0x09],
-            "P": [0x0F,0x09,0x09,0x0F,0x01,0x01,0x01],
-            "U": [0x09,0x09,0x09,0x09,0x09,0x09,0x0F],
-            ":": [0x00,0x03,0x03,0x00,0x03,0x03,0x00],       # 2×7
-            "°C": [0x01,0x1E,0x02,0x02,0x02,0x02,0x1E],      # celcius 5×7
-            "°F": [0x01,0x1E,0x02,0x1E,0x02,0x02,0x02],      # farenheit
-            " ": [0x00,0x00,0x00,0x00,0x00,0x00,0x00],
-            "T": [0x1F,0x04,0x04,0x04,0x04,0x04,0x04],       # 5*7
-            ".": [0x00,0x00,0x00,0x00,0x00,0x00,0x01],       # 2×7
-            "-": [0x00,0x00,0x00,0x03,0x00,0x00,0x00],       # 2×7
-            "M": [0x00,0x11,0x1B,0x15,0x11,0x11,0x11,0x11],  # 5×7
-            "/": [0x00,0x04,0x04,0x02,0x02,0x02,0x01,0x01],  # 3×7
-            "°C2": [0x00,0x01,0x0C,0x12,0x02,0x02,0x12,0x0C],# celcuis 5x7
-            "°F2": [0x00,0x01,0x1E,0x02,0x1E,0x02,0x02,0x02],# farenheit
-            "V": [0x11,0x11,0x11,0x11,0x11,0x11,0x1F],       # 5×7
-            "W": [0x11,0x11,0x11,0x15,0x15,0x1B,0x11],       # 5×7
+            "0": [0x0F, 0x09, 0x09, 0x09, 0x09, 0x09, 0x0F],
+            "1": [0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08],
+            "2": [0x0F, 0x08, 0x08, 0x0F, 0x01, 0x01, 0x0F],
+            "3": [0x0F, 0x08, 0x08, 0x0F, 0x08, 0x08, 0x0F],
+            "4": [0x09, 0x09, 0x09, 0x0F, 0x08, 0x08, 0x08],
+            "5": [0x0F, 0x01, 0x01, 0x0F, 0x08, 0x08, 0x0F],
+            "5": [0x0F, 0x01, 0x01, 0x0F, 0x09, 0x09, 0x0F],
+            "6": [0x0F, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08],
+            "7": [0x0F, 0x09, 0x09, 0x0F, 0x09, 0x09, 0x0F],
+            "8": [0x0F, 0x09, 0x09, 0x0F, 0x08, 0x08, 0x0F],
+            "A": [0x0F, 0x09, 0x09, 0x0F, 0x09, 0x09, 0x09],
+            "B": [0x01, 0x01, 0x01, 0x0F, 0x09, 0x09, 0x0F],
+            "C": [0x0F, 0x01, 0x01, 0x01, 0x01, 0x01, 0x0F],
+            "D": [0x08, 0x08, 0x08, 0x0F, 0x09, 0x09, 0x0F],
+            "E": [0x0F, 0x01, 0x01, 0x0F, 0x01, 0x01, 0x0F],
+            "F": [0x0F, 0x01, 0x01, 0x0F, 0x01, 0x01, 0x01],
+            "H": [0x09, 0x09, 0x09, 0x0F, 0x09, 0x09, 0x09],
+            "L": [0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x0F],
+            "N": [0x0F, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09],
+            "P": [0x0F, 0x09, 0x09, 0x0F, 0x01, 0x01, 0x01],
+            "U": [0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x0F],
+            ":": [0x00, 0x03, 0x03, 0x00, 0x03, 0x03, 0x00],  # 2×7
+            "°C": [0x01, 0x1E, 0x02, 0x02, 0x02, 0x02, 0x1E],  # celcius 5×7
+            "°F": [0x01, 0x1E, 0x02, 0x1E, 0x02, 0x02, 0x02],  # farenheit
+            " ": [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
+            "T": [0x1F, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04],  # 5*7
+            ".": [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01],  # 2×7
+            "-": [0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00],  # 2×7
+            "M": [0x00, 0x11, 0x1B, 0x15, 0x11, 0x11, 0x11, 0x11],  # 5×7
+            "/": [0x00, 0x04, 0x04, 0x02, 0x02, 0x02, 0x01, 0x01],  # 3×7
+            "°C2": [0x00, 0x01, 0x0C, 0x12, 0x02, 0x02, 0x12, 0x0C],  # celcuis 5x7
+            "°F2": [0x00, 0x01, 0x1E, 0x02, 0x1E, 0x02, 0x02, 0x02],  # farenheit
+            "V": [0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x1F],  # 5×7
+            "W": [0x11, 0x11, 0x11, 0x15, 0x15, 0x1B, 0x11],  # 5×7
         }
diff --git a/main.py b/main.py
index 5d1dc11..454b611 100644
--- a/main.py
+++ b/main.py
@@ -1,24 +1,20 @@
 import time
-from display import Display
-from speaker import Speaker
-from buttons import Buttons
 from scheduler import Scheduler
 from clock import Clock
-from rtc import RTC
 from apps import Apps
 from pomodoro import Pomodoro
 from time_set import TimeSet
 
-scheduler = Scheduler()
-display = Display(scheduler)
-speaker = Speaker(scheduler)
-buttons = Buttons(scheduler)
-rtc = RTC()
+APP_CLASSES = [
+    Clock,
+    Pomodoro,
+    TimeSet,
+]
 
-apps = Apps(display, buttons)
-apps.add(Clock(scheduler, display, rtc))
-apps.add(TimeSet(scheduler, display, buttons, rtc))
-apps.add(Pomodoro(scheduler, display, speaker, buttons))
+scheduler = Scheduler()
+apps = Apps(scheduler)
+for App in APP_CLASSES:
+    apps.add(App(scheduler))
 
 print("STARTING...")
 scheduler.start()
diff --git a/pomodoro.py b/pomodoro.py
index a705879..4ab3e2e 100644
--- a/pomodoro.py
+++ b/pomodoro.py
@@ -1,13 +1,17 @@
 import time
 from apps import App
+from buttons import Buttons
+from display import Display
+from speaker import Speaker
+
 
 class Pomodoro:
-    def __init__(self, scheduler, display, speaker, buttons):
+    def __init__(self, scheduler):
         App.__init__(self, "Pomodoro", "pomod")
-        self.display = display
-        self.speaker = speaker
+        self.display = Display(scheduler)
+        self.speaker = Speaker(scheduler)
         self.scheduler = scheduler
-        self.buttons = buttons
+        self.buttons = Buttons()
         self.enabled = False
         self.started = False
         self.start_time = None
diff --git a/rtc.py b/rtc.py
index e3468c4..572929f 100644
--- a/rtc.py
+++ b/rtc.py
@@ -1,7 +1,10 @@
 from machine import SoftI2C
 from machine import Pin
 from ds3231_port import DS3231
+from util import singleton
 
+
+@singleton
 class RTC:
     def __init__(self):
         rtc_i2c = SoftI2C(scl=Pin(7), sda=Pin(6), freq=100000)
diff --git a/scheduler.py b/scheduler.py
index 0a44013..6384b6a 100644
--- a/scheduler.py
+++ b/scheduler.py
@@ -1,9 +1,8 @@
 from machine import Timer
 import time
-import _thread
 
-class Scheduler:
 
+class Scheduler:
     class Schedule:
         def __init__(self, name, duration, callback):
             self.name = name
@@ -11,7 +10,8 @@ def __init__(self, name, duration, callback):
             self.callback = callback
             self.lastrun = time.ticks_ms()
 
-    count=0
+    count = 0
+
     def __init__(self):
         self.schedules = []
 
@@ -31,4 +31,3 @@ def event_callback(self, t):
                 if time.ticks_diff(tm, schedule.lastrun) > schedule.duration:
                     schedule.callback(t)
                     schedule.lastrun = tm
-
diff --git a/speaker.py b/speaker.py
index 9bc64de..dad373a 100644
--- a/speaker.py
+++ b/speaker.py
@@ -1,6 +1,10 @@
 from machine import Pin, Timer
 import time
 
+from util import singleton
+
+
+@singleton
 class Speaker:
     def __init__(self, scheduler):
         self.buzz = Pin(14, Pin.OUT)
diff --git a/time_set.py b/time_set.py
index f8d0424..5eb2621 100644
--- a/time_set.py
+++ b/time_set.py
@@ -1,6 +1,7 @@
-import time
-import machine
 from apps import App
+from buttons import Buttons
+from display import Display
+from rtc import RTC
 
 month_max = {
     1: 31, # January
@@ -28,13 +29,13 @@ def __init__(self, name, position, panel, index, max, length=2, offset=0):
             self.length = length
             self.offset = offset
 
-    def __init__(self, scheduler, display, buttons, rtc):
+    def __init__(self, scheduler):
         App.__init__(self, "Time Set", "timeset")
 
-        self.display = display
+        self.display = Display(scheduler)
         self.scheduler = scheduler
-        self.buttons = buttons
-        self.rtc = rtc
+        self.buttons = Buttons(scheduler)
+        self.rtc = RTC()
         self.grab_top_button = True
         self.enabled = False
         self.state = None
diff --git a/util.py b/util.py
new file mode 100644
index 0000000..856e3c9
--- /dev/null
+++ b/util.py
@@ -0,0 +1,7 @@
+def singleton(class_):
+    instances = {}
+    def getinstance(*args, **kwargs):
+        if class_ not in instances:
+            instances[class_] = class_(*args, **kwargs)
+        return instances[class_]
+    return getinstance
\ No newline at end of file

From e62df2e41b45df3a8209b7adaf108f5e9b049f73 Mon Sep 17 00:00:00 2001
From: Erik Sommer <ersotech@posteo.de>
Date: Tue, 5 Oct 2021 19:59:59 +0200
Subject: [PATCH 2/2] add changelog entry

---
 CHANGELOG.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index efcb9c4..9e230b8 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,6 @@
 # Change Log
 
+* **2021/10/05**: Unified interface for the app classes
 * **2021/10/02**: Add basic time-set app
 * **2021/10/01**: Improved 'app' functionality
   Top button switches between apps