demos/epaper.py: Log power on hours.

gui/demos/epaper.py

@@ -5,6 +5,12 @@
 # Released under the MIT License (MIT). See LICENSE.
 # Copyright (c) 2023-2024 Peter Hinch
 
+# Colors:
+# The driver is designed so that code written for color displays produces an acceptable
+# result. Unlike other displays an EPD has a white background, with the highest luminance
+# colors displaying as black. When writing code for an EPD, use WHITE for foreground color
+# and BLACK for background. i.e. treat as if it were an emissive screen.
+
 # Initialise hardware and framebuf before importing modules.
 # Create SSD instance. Must be done first because of RAM use.
 import hardware_setup
@@ -61,33 +67,26 @@ class FooScreen(Screen):
 
         # A ButtonList with two entries
         table_buttonset = (
-            {"fgcolor": RED, "text": "Disable", "args": (buttons, True)},
+            {"fgcolor": WHITE, "text": "Disable", "args": (buttons, True)},
-            {"fgcolor": GREEN, "text": "Enable", "args": (buttons, False)},
+            {"fgcolor": WHITE, "text": "Enable", "args": (buttons, False)},
         )
 
-        def tickcb(f, c):
-            if f > 0.8:
-                return RED
-            if f < -0.8:
-                return BLUE
-            return c
-
         def bcb(b):
             print("Button pressed", b)
 
         super().__init__()
         self.rb0 = None
         self.bs0 = None
-        wri = CWriter(ssd, arial10, GREEN, BLACK, verbose=False)
+        wri = CWriter(ssd, arial10, WHITE, BLACK, verbose=False)
-        wri_large = CWriter(ssd, large, GREEN, BLACK, verbose=False)
+        wri_large = CWriter(ssd, large, WHITE, BLACK, verbose=False)
-        lbltim = Label(wri, 65, 100, "this is a test", bdcolor=RED)
+        lbltim = Label(wri, 65, 100, "00:00:00 ", bdcolor=WHITE)
 
         m0 = Meter(
             wri,
             10,
             240,
             divisions=4,
-            ptcolor=YELLOW,
+            ptcolor=WHITE,
             height=80,
             width=15,
             label="Meter",
@@ -95,12 +94,8 @@ class FooScreen(Screen):
             legends=("0.0", "0.5", "1.0"),
         )
         # Instantiate displayable objects. bgcolor forces complete redraw.
-        dial = Dial(
+        dial = Dial(wri, 2, 2, height=75, ticks=12, bdcolor=None, label=120)
-            wri, 2, 2, height=75, ticks=12, bgcolor=BLACK, bdcolor=None, label=120
+        scale = Scale(wri, 2, 100, width=124)
-        )  # Border in fg color
-        scale = Scale(
-            wri, 2, 100, width=124, tickcb=tickcb, pointercolor=RED, fontcolor=YELLOW, bdcolor=CYAN
-        )
 
         row = 105
         col = 2
@@ -118,9 +113,8 @@ class FooScreen(Screen):
                     height=ht,
                     callback=bcb,
                     text=s,
-                    litcolor=RED,
+                    litcolor=WHITE,
                     shape=CIRCLE,
-                    bgcolor=DARKGREEN,
                 )
             )
 
@@ -130,32 +124,20 @@ class FooScreen(Screen):
         col += 50
         Label(wri, row - 15, col, "ButtonList")
         for t in table_buttonset:  # Buttons overlay each other at same location
-            button = self.bs.add_button(
+            button = self.bs.add_button(wri, row, col, shape=RECTANGLE, height=30, **t)
-                wri, row, col, shape=RECTANGLE, textcolor=BLUE, height=30, **t
-            )
             if self.bs0 is None:  # Save for reset button callback
                 self.bs0 = button
 
         # Reset button
         col += 60
-        btn = Button(
+        btn = Button(wri, row, col, height=30, callback=self.rstcb, text="reset", litcolor=WHITE)
-            wri,
-            row,
-            col,
-            height=30,
-            callback=self.rstcb,
-            text="reset",
-            litcolor=RED,
-            fgcolor=GREEN,
-            bgcolor=DARKGREEN,
-        )
 
         col = btn.mcol + 15
         # Checkbox
         Label(wri, row - 15, col, "Checkbox and LED")
         Checkbox(wri, row, col, callback=self.cbcb)
         col += 40
-        self.led = LED(wri, row, col, color=YELLOW, bdcolor=GREEN)
+        self.led = LED(wri, row, col, bdcolor=WHITE)
 
         row = self.bs0.mrow + 5
         col = 20
@@ -166,10 +148,41 @@ class FooScreen(Screen):
         Label(wri, row + ht + 5, col - 8 + int(wd // 2), "0.0")
         lbl = Label(wri, row + ht + 5, col - 10 + wd, "2.0")
         Label(wri_large, lbl.mrow + 5, col, "y = sinc(x)")
+        # Power on hours
+        col = 240
+        l = Label(wri, row, col, "Running hours")
+        row = l.mrow + 2
+        Label(wri, row, col, "Power")
+        self.lpon = Label(wri, row, col + 40, "0000", bdcolor=WHITE)
+        row = self.lpon.mrow + 4
+        Label(wri, row, col, "Reset")
+        self.lrst = Label(wri, row, col + 40, "0000", bdcolor=WHITE)
+        row = self.lrst.mrow + 4
+        Label(wri, row, col, "Total")
+        self.ltot = Label(wri, row, col + 40, "0000", bdcolor=WHITE)
+        self.hrs = [0, 0, 0]  # pon, reset, total
+        self.fn = "hours"
+        try:
+            with open(self.fn, "r") as f:
+                self.hrs[2] = int(f.read())
+        except OSError:
+            self.hrs[2] = 0
 
         CloseButton(wri, bgcolor=BLACK)
         asyncio.create_task(set_partial())  # After 1st full refresh
         asyncio.create_task(run(dial, lbltim, m0, scale))
+        asyncio.create_task(self.runtime())
+
+    async def runtime(self):
+        while True:
+            self.lpon.value(f"{self.hrs[0]:04d}")
+            self.lrst.value(f"{self.hrs[1]:04d}")
+            self.ltot.value(f"{self.hrs[2]:04d}")
+            for n, v in enumerate(self.hrs):
+                self.hrs[n] = v + 1
+            with open(self.fn, "w") as f:
+                f.write(f"{self.hrs[2]:d}")
+            await asyncio.sleep(3600)
 
     def callback(self, button, buttons, val):
         buttons[2].greyed_out(val)
@@ -178,6 +191,8 @@ class FooScreen(Screen):
         print("Reset button: init ButtonList, do full refresh.")
         self.bs.value(self.bs0)
         asyncio.create_task(full_refresh())
+        self.hrs[1] = 0  # Reset time since reset
+        self.lrst.value(f"{self.hrs[1]:04d}")
 
     def cbcb(self, cb):
         self.led.value(cb.value())
@@ -226,9 +241,9 @@ async def run(dial, lbltim, m0, scale):
     dv = 0.005
     while True:
         t = utime.localtime()
-        hrs.value(hstart * uv(-t[3] * pi / 6 - t[4] * pi / 360), YELLOW)
+        hrs.value(hstart * uv(-t[3] * pi / 6 - t[4] * pi / 360))  # , YELLOW)
-        mins.value(mstart * uv(-t[4] * pi / 30), YELLOW)
+        mins.value(mstart * uv(-t[4] * pi / 30))  # , YELLOW)
-        secs.value(sstart * uv(-t[5] * pi / 30), RED)
+        secs.value(sstart * uv(-t[5] * pi / 30))  # , RED)
         lbltim.value("{:02d}.{:02d}.{:02d}".format(t[3], t[4], t[5]))
         dial.text("{} {} {} {}".format(days[t[6]], t[2], months[t[1] - 1], t[0]))
         m0.value(t[5] / 60)