tweak

python-test/copy.sh

 cp state_wait_temp.py /pyboard
 cp state_wait_time.py /pyboard
 cp state_pump.py /pyboard
+cp state_notify.py /pyboard
 cp $1 /pyboard/main.py
 EOF
 else
 cp state_wait_temp.py /pyboard
 cp state_wait_time.py /pyboard
 cp state_pump.py /pyboard
+cp state_notify.py /pyboard
 rm /pyboard/main.py
 EOF
 fi

python-test/lcd.py

 # https://www.waveshare.com/wiki/Pico-LCD-1.3
+# https://thepihut.com/blogs/raspberry-pi-tutorials/coding-graphics-with-micropython-on-raspberry-pi-pico-displays
+# https://api.arcade.academy/en/latest/_modules/arcade/draw_commands.html#draw_arc_filled
 
 from machine import Pin, SPI, PWM
+from array import array
 import framebuf
 import time
 import os
+import math
 
 class KeyCheck:
     def __init__(self, new, old):
         self.spi.write(self.buffer)
         self.cs(1)
 
+    def circle(self, x, y, r, c):
+        self.hline(x-r,y,r*2,c)
+        for i in range(1,r):
+            a = int(math.sqrt(r*r-i*i)) # Pythagoras!
+            self.hline(x-a,y+i,a*2,c) # Lower half
+            self.hline(x-a,y-i,a*2,c) # Upper half
+
+    def ring(self, x, y, r, c):
+        self.pixel(x-r,y,c)
+        self.pixel(x+r,y,c)
+        self.pixel(x,y-r,c)
+        self.pixel(x,y+r,c)
+        for i in range(1, r):
+            a = int(math.sqrt(r*r-i*i))
+            self.pixel(x-a,y-i,c)
+            self.pixel(x+a,y-i,c)
+            self.pixel(x-a,y+i,c)
+            self.pixel(x+a,y+i,c)
+            self.pixel(x-i,y-a,c)
+            self.pixel(x+i,y-a,c)
+            self.pixel(x-i,y+a,c)
+            self.pixel(x+i,y+a,c)
+
+    def arc(self, x_off, y_off, w, h, c,
+                   start_angle, end_angle,
+                   filled = True,
+                   num_segments = 128):
+        point_list = [0, 0]
+
+        start_segment = int(start_angle / 360 * num_segments)
+        end_segment = int(end_angle / 360 * num_segments)
+
+        for segment in range(start_segment, end_segment + 1):
+            theta = 2.0 * 3.1415926 * segment / num_segments
+            x = w * math.cos(theta) / 2
+            y = h * math.sin(theta) / 2
+            point_list.append(int(x))
+            point_list.append(int(y))
+
+        self.poly(int(x_off), int(y_off), array('h', point_list), c, True)
+
+    def pie(self, x0, y0, w, c_border, c_circle, v):
+        if v > 0.0:
+            lcd.arc(int(x0), int(y0), int(w), int(w), c_circle, -90, int(v * 360) - 90)
+        lcd.ring(int(x0), int(y0), int(w / 2), c_border)
+
 if __name__  == '__main__':
+    start = time.time()
+    def gfx_test(lcd):
+        v = (time.time() - start)
+        lcd.fill(lcd.black)
+        lcd.pie(lcd.width / 2, lcd.height / 2, lcd.width, lcd.red, lcd.green, (v % 11) / 10)
+
+    def key_test(lcd):
+        lcd.fill(lcd.white)
+
+        if lcd.keyA.value() == 0:
+            lcd.fill_rect(208,15,30,30,lcd.red)
+        else:
+            lcd.fill_rect(208,15,30,30,lcd.white)
+            lcd.rect(208,15,30,30,lcd.red)
+
+        if lcd.keyB.value() == 0:
+            lcd.fill_rect(208,75,30,30,lcd.red)
+        else:
+            lcd.fill_rect(208,75,30,30,lcd.white)
+            lcd.rect(208,75,30,30,lcd.red)
+
+        if lcd.keyX.value() == 0:
+            lcd.fill_rect(208,135,30,30,lcd.red)
+        else:
+            lcd.fill_rect(208,135,30,30,lcd.white)
+            lcd.rect(208,135,30,30,lcd.red)
+
+        if lcd.keyY.value() == 0:
+            lcd.fill_rect(208,195,30,30,lcd.red)
+        else:
+            lcd.fill_rect(208,195,30,30,lcd.white)
+            lcd.rect(208,195,30,30,lcd.red)
+
+        if lcd.up.value() == 0:
+            lcd.fill_rect(60,60,30,30,lcd.red)
+        else:
+            lcd.fill_rect(60,60,30,30,lcd.white)
+            lcd.rect(60,60,30,30,lcd.red)
+
+        if lcd.down.value() == 0:
+            lcd.fill_rect(60,150,30,30,lcd.red)
+        else:
+            lcd.fill_rect(60,150,30,30,lcd.white)
+            lcd.rect(60,150,30,30,lcd.red)
+
+        if lcd.left.value() == 0:
+            lcd.fill_rect(15,105,30,30,lcd.red)
+        else:
+            lcd.fill_rect(15,105,30,30,lcd.white)
+            lcd.rect(15,105,30,30,lcd.red)
+
+        if lcd.right.value() == 0:
+            lcd.fill_rect(105,105,30,30,lcd.red)
+        else:
+            lcd.fill_rect(105,105,30,30,lcd.white)
+            lcd.rect(105,105,30,30,lcd.red)
+
+        if lcd.ctrl.value() == 0:
+            lcd.fill_rect(60,105,30,30,lcd.red)
+        else:
+            lcd.fill_rect(60,105,30,30,lcd.white)
+            lcd.rect(60,105,30,30,lcd.red)
+
     lcd = LCD()
     lcd.brightness(1.0)
 
     try:
         while True:
-            lcd.fill(lcd.white)
-
-            if lcd.keyA.value() == 0:
-                lcd.fill_rect(208,15,30,30,lcd.red)
-            else:
-                lcd.fill_rect(208,15,30,30,lcd.white)
-                lcd.rect(208,15,30,30,lcd.red)
-
-            if lcd.keyB.value() == 0:
-                lcd.fill_rect(208,75,30,30,lcd.red)
-            else:
-                lcd.fill_rect(208,75,30,30,lcd.white)
-                lcd.rect(208,75,30,30,lcd.red)
-
-            if lcd.keyX.value() == 0:
-                lcd.fill_rect(208,135,30,30,lcd.red)
-            else:
-                lcd.fill_rect(208,135,30,30,lcd.white)
-                lcd.rect(208,135,30,30,lcd.red)
-
-            if lcd.keyY.value() == 0:
-                lcd.fill_rect(208,195,30,30,lcd.red)
-            else:
-                lcd.fill_rect(208,195,30,30,lcd.white)
-                lcd.rect(208,195,30,30,lcd.red)
-
-            if lcd.up.value() == 0:
-                lcd.fill_rect(60,60,30,30,lcd.red)
-            else:
-                lcd.fill_rect(60,60,30,30,lcd.white)
-                lcd.rect(60,60,30,30,lcd.red)
-
-            if lcd.down.value() == 0:
-                lcd.fill_rect(60,150,30,30,lcd.red)
-            else:
-                lcd.fill_rect(60,150,30,30,lcd.white)
-                lcd.rect(60,150,30,30,lcd.red)
-
-            if lcd.left.value() == 0:
-                lcd.fill_rect(15,105,30,30,lcd.red)
-            else:
-                lcd.fill_rect(15,105,30,30,lcd.white)
-                lcd.rect(15,105,30,30,lcd.red)
-
-            if lcd.right.value() == 0:
-                lcd.fill_rect(105,105,30,30,lcd.red)
-            else:
-                lcd.fill_rect(105,105,30,30,lcd.white)
-                lcd.rect(105,105,30,30,lcd.red)
-
-            if lcd.ctrl.value() == 0:
-                lcd.fill_rect(60,105,30,30,lcd.red)
-            else:
-                lcd.fill_rect(60,105,30,30,lcd.white)
-                lcd.rect(60,105,30,30,lcd.red)
+            #key_test(lcd)
+            gfx_test(lcd)
 
             lcd.show()
             time.sleep(0.1)

python-test/state_connect.py

             self.done = False
 
         if self.state:
-            client = await d.device.connect()
+            client = await d[0].device.connect()
             async with self.lock:
                 self.step = True
             await cache_services_characteristics(client)
 
         async with self.lock:
             self.done = True
-            self.client = client
+            self.client = (client, d[1])
 
     async def draw(self):
-        self.lcd.fill(self.lcd.black)
-
-        self.lcd.text("Volcano Remote Control App", 0, 0, self.lcd.green)
         self.lcd.text("Connecting to Bluetooth device", 0, 10, self.lcd.red)
 
         keys = self.lcd.buttons()
         async with self.lock:
             if self.done:
                 if self.state:
-                    return 2 # selection
+                    return 3 # heater on
                 else:
                     return 0 # scan
             else:
                     else:
                         self.lcd.text("Fetching parameters...", 0, int(self.lcd.height / 2) - 5, self.lcd.white)
 
-        self.lcd.show()
         return -1 # stay in this state

python-test/state_heat.py

 #!/usr/bin/env python
 
 import uasyncio as asyncio
-from poll import set_state
+from poll import set_state, set_target_temp
 
 class StateHeat:
     def __init__(self, lcd, state):
         self.value = val
         self.heater = asyncio.create_task(self.heat())
         self.done = False
+        self.step = False
 
     def exit(self):
         self.heater.cancel()
         return (self.value[0], self.value[1], 0)
 
     async def heat(self):
-        print("Setting heater: {}".format(self.state))
         pump = None
         if self.state == False:
             pump = False
+
+        print("Setting heater: {}".format(self.state))
         await set_state(self.value[0], (self.state, pump))
 
+        if self.state == False:
+            async with self.lock:
+                self.step = True
+
+            temp = self.value[1]["reset_temperature"]
+            if temp != None:
+                print("Reset temperature to default value")
+                await set_target_temp(self.value[0], temp)
+
         async with self.lock:
             self.done = True
 
     async def draw(self):
-        self.lcd.fill(self.lcd.black)
-
-        self.lcd.text("Volcano Remote Control App", 0, 0, self.lcd.green)
         self.lcd.text("Running Workflow - Heat {}".format(self.state), 0, 10, self.lcd.red)
 
         keys = self.lcd.buttons()
                 async with self.lock:
                     if self.done:
                         return 4 # heat off
+                    else:
+                        return 5 # disconnect
             else:
                 return 5 # disconnect
 
                     return 6 # wait for temperature
             else:
                 if self.state == False:
-                    self.lcd.text("Turning heater off...", 0, int(self.lcd.height / 2) - 5, self.lcd.white)
+                    if self.state == False:
+                        self.lcd.text("Turning heater off...", 0, int(self.lcd.height / 2) - 5, self.lcd.white)
+                    else:
+                        self.lcd.text("Resetting temperature...", 0, int(self.lcd.height / 2) - 5, self.lcd.white)
                 else:
                     self.lcd.text("Turning heater on...", 0, int(self.lcd.height / 2) - 5, self.lcd.white)
 
-        self.lcd.show()
         return -1 # stay in this state

python-test/state_notify.py

+#!/usr/bin/env python
+
+import time
+import uasyncio as asyncio
+from poll import set_state
+from state_wait_temp import draw_graph
+
+class StateNotify:
+    def __init__(self, lcd):
+        self.lcd = lcd
+
+        self.lock = asyncio.Lock()
+
+    def enter(self, val = None):
+        self.value = val
+        self.notifier = asyncio.create_task(self.notify())
+        self.done = False
+
+    def exit(self):
+        self.notifier.cancel()
+
+        if self.lock.locked():
+            self.lock.release()
+
+        return (self.value[0], self.value[1], self.value[2])
+
+    async def notify(self):
+        device, workflow, index = self.value
+        count, duration = workflow["notify"]
+
+        for i in range(0, count):
+            print("Turning on pump")
+            await set_state(device, (None, True))
+            await asyncio.sleep_ms(int(duration * 1000))
+
+            print("Turning off pump")
+            await set_state(device, (None, False))
+            await asyncio.sleep_ms(int(duration * 1000))
+
+        async with self.lock:
+            self.done = True
+
+    async def draw(self):
+        self.lcd.text("Running Workflow - Notify", 0, 10, self.lcd.red)
+
+        keys = self.lcd.buttons()
+
+        if keys.once("y"):
+            print("user abort")
+            return 4 # heat off
+
+        async with self.lock:
+            if self.done:
+                return 4 # heater off
+
+        return -1 # stay in this state

python-test/state_pump.py

             self.done = True
 
     async def draw(self):
-        self.lcd.fill(self.lcd.black)
-
         device, workflow, index = self.value
-        self.lcd.text("Volcano Remote Control App", 0, 0, self.lcd.green)
         self.lcd.text("Running Workflow - Pump {}".format(workflow["steps"][index][2]), 0, 10, self.lcd.red)
 
         keys = self.lcd.buttons()
 
             if self.done:
                 if self.value[2] >= (len(workflow["steps"]) - 1):
-                    # TODO notify
-                    return 4 # heater off
+                    if workflow["notify"] != None:
+                        return 9 # notify
+                    else:
+                        return 4 # heater off
                 else:
                     return 6 # wait for temperature
 
-        self.lcd.show()
         return -1 # stay in this state

python-test/state_scan.py

             self.lcd.text(s2, 0, off + 12, c2)
 
     async def draw(self):
-        self.lcd.fill(self.lcd.black)
-
-        self.lcd.text("Volcano Remote Control App", 0, 0, self.lcd.green)
         self.lcd.text("Scanning for Bluetooth devices", 0, 10, self.lcd.red)
 
         keys = self.lcd.buttons()
         async with self.lock:
             if keys.once("enter"):
                 if self.current < len(self.results):
-                    return 1 # connect
+                    return 2 # select
             elif keys.once("up"):
                 if self.current == None:
                     self.current = len(self.results) - 1
 
             self.draw_list()
 
-        self.lcd.show()
         return -1 # stay in this state

python-test/state_select.py

             self.lcd.text(s2, 0, off + 12, c)
 
     async def draw(self):
-        self.lcd.fill(self.lcd.black)
-
-        self.lcd.text("Volcano Remote Control App", 0, 0, self.lcd.green)
         self.lcd.text("Please select your Workflow", 0, 10, self.lcd.red)
 
         keys = self.lcd.buttons()
             if self.current < (len(workflows) - 1):
                 self.current += 1
         elif keys.once("enter"):
-            return 3 # heater on
+            return 1 # connect
 
         self.draw_list()
 
-        self.lcd.show()
         return -1 # stay in this state

python-test/state_wait_temp.py

 
     w = lcd.width - 10
     ratio = (val - min) / (max - min)
-    wfull = int(w * ratio)
-    wempty = w - wfull
-    lcd.rect(4, int(lcd.height / 2) - 5, wfull + 1, 50, lcd.green, True)
-    lcd.rect(4 + wfull, int(lcd.height / 2) - 5, wempty + 2, 50, lcd.green, False)
+
+    #wfull = int(w * ratio)
+    #wempty = w - wfull
+    #lcd.rect(4, int(lcd.height / 2) - 5, wfull + 1, 50, lcd.green, True)
+    #lcd.rect(4 + wfull, int(lcd.height / 2) - 5, wempty + 2, 50, lcd.green, False)
+
+    lcd.pie(lcd.width / 2, lcd.height / 2, w, lcd.red, lcd.green, ratio)
+
     lcd.text("{}".format(val), int(lcd.width / 2), 125, lcd.white)
 
 class StateWaitTemp:
                 self.temp = temp
 
     async def draw(self):
-        self.lcd.fill(self.lcd.black)
-
         device, workflow, index = self.value
-        self.lcd.text("Volcano Remote Control App", 0, 0, self.lcd.green)
         self.lcd.text("Running Workflow - Heat {}".format(workflow["steps"][index][0]), 0, 10, self.lcd.red)
 
         keys = self.lcd.buttons()
                 print("switch, {} >= {}".format(self.temp, self.max))
                 return 7 # wait for time
 
-        self.lcd.show()
         return -1 # stay in this state

python-test/state_wait_time.py

         return (self.value[0], self.value[1], self.value[2])
 
     async def draw(self):
-        self.lcd.fill(self.lcd.black)
-
         device, workflow, index = self.value
-        self.lcd.text("Volcano Remote Control App", 0, 0, self.lcd.green)
         self.lcd.text("Running Workflow - Wait {}".format(workflow["steps"][index][1]), 0, 10, self.lcd.red)
 
         keys = self.lcd.buttons()
             print("switch, {} >= {}".format(now, self.end))
             return 8 # pump
 
-        self.lcd.show()
         return -1 # stay in this state

python-test/states.py

 from state_wait_temp import StateWaitTemp
 from state_wait_time import StateWaitTime
 from state_pump import StatePump
+from state_notify import StateNotify
 
 class States:
-    def __init__(self):
+    def __init__(self, lcd):
+        self.lcd = lcd
         self.states = []
         self.current = None
 
     def add(self, s):
         self.states.append(s)
 
+    async def draw(self):
+        self.lcd.fill(self.lcd.black)
+        self.lcd.text("Volcano Remote Control App", 0, 0, self.lcd.green)
+        r = await self.states[self.current].draw()
+        self.lcd.show()
+        return r
+
     def run(self):
         if self.current == None:
             self.current = 0
             self.states[self.current].enter()
 
-        next = asyncio.run(self.states[self.current].draw())
+        next = asyncio.run(self.draw())
         if next >= 0:
             print("switch to {}".format(next))
             val = self.states[self.current].exit()
     lcd = LCD()
     lcd.brightness(1.0)
 
-    states = States()
+    states = States(lcd)
 
     # 0 - Scan
+    # passes ScanResult to 2, select
     scan = StateScan(lcd)
     states.add(scan)
 
     # 1 - Connect
+    # passes device and selected workflow to 3, heater on
     conn = StateConnect(lcd, True)
     states.add(conn)
 
     # 2 - Select
+    # passes ScanResult and selected workflow to 1, connect
     select = StateSelect(lcd)
     states.add(select)
 
     pump = StatePump(lcd)
     states.add(pump)
 
+    # 9 - Notify
+    notify = StateNotify(lcd)
+    states.add(notify)
+
     while True:
         states.run()

python-test/workflows.py

             (205.0, 10.0, 20.0),
             (220.0, 10.0, 20.0),
         ],
+        "notify": (3, 1.0),
+        "reset_temperature": 190.0,
     },
     {
         "name": "Vorbi",
             (204.0, 3.0, 10.0),
             (217.0, 5.0, 10.0),
         ],
+        "notify": None,
+        "reset_temperature": None,
     },
 ]