lcd ui for whole workflow

python-test/copy.sh

@@ -6,8 +6,15 @@ cp flow.py /pyboard
 cp poll.py /pyboard
 cp scan.py /pyboard
 cp lcd.py /pyboard
+cp workflows.py /pyboard
 cp states.py /pyboard
 cp state_scan.py /pyboard
+cp state_connect.py /pyboard
+cp state_select.py /pyboard
+cp state_heat.py /pyboard
+cp state_wait_temp.py /pyboard
+cp state_wait_time.py /pyboard
+cp state_pump.py /pyboard
 cp $1 /pyboard/main.py
 EOF
 else
@@ -16,7 +23,15 @@ cp flow.py /pyboard
 cp poll.py /pyboard
 cp scan.py /pyboard
 cp lcd.py /pyboard
+cp workflows.py /pyboard
 cp states.py /pyboard
 cp state_scan.py /pyboard
+cp state_connect.py /pyboard
+cp state_select.py /pyboard
+cp state_heat.py /pyboard
+cp state_wait_temp.py /pyboard
+cp state_wait_time.py /pyboard
+cp state_pump.py /pyboard
+rm /pyboard/main.py
 EOF
 fi

python-test/poll.py

@@ -73,22 +73,23 @@ async def get_state(device):
 
 async def set_state(device, state):
     heater, pump = state
-    if heater:
+    if heater == True:
         service = await device.service(serviceUuidVolcano4)
         uuid = bluetooth.UUID("1011000f-5354-4f52-5a26-4249434b454c")
         characteristic = await service.characteristic(uuid)
         await characteristic.write(int(0).to_bytes(1, "little"))
-    else:
+    elif heater == False:
         service = await device.service(serviceUuidVolcano4)
         uuid = bluetooth.UUID("10110010-5354-4f52-5a26-4249434b454c")
         characteristic = await service.characteristic(uuid)
         await characteristic.write(int(0).to_bytes(1, "little"))
-    if pump:
+
+    if pump == True:
         service = await device.service(serviceUuidVolcano4)
         uuid = bluetooth.UUID("10110013-5354-4f52-5a26-4249434b454c")
         characteristic = await service.characteristic(uuid)
         await characteristic.write(int(0).to_bytes(1, "little"))
-    else:
+    elif pump == False:
         service = await device.service(serviceUuidVolcano4)
         uuid = bluetooth.UUID("10110014-5354-4f52-5a26-4249434b454c")
         characteristic = await service.characteristic(uuid)

python-test/state_connect.py

@@ -0,0 +1,67 @@
+#!/usr/bin/env python
+
+import uasyncio as asyncio
+
+class StateConnect:
+    def __init__(self, lcd, state):
+        self.lcd = lcd
+        self.state = state
+
+        self.lock = asyncio.Lock()
+
+    def enter(self, val = None):
+        self.done = False
+        self.client = None
+        self.connector = asyncio.create_task(self.connect(val))
+
+    def exit(self):
+        self.connector.cancel()
+
+        if self.lock.locked():
+            self.lock.release()
+
+        return self.client
+
+    async def connect(self, d):
+        async with self.lock:
+            self.done = False
+
+        if self.state:
+            client = await d.device.connect()
+        else:
+            await d[0].disconnect()
+            client = None
+
+        async with self.lock:
+            self.done = True
+            self.client = client
+
+    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)
+
+        if self.state:
+            self.lcd.text("Connecting...", 0, int(self.lcd.height / 2) - 5, self.lcd.white)
+        else:
+            self.lcd.text("Disconnecting...", 0, int(self.lcd.height / 2) - 5, self.lcd.white)
+
+        keys = self.lcd.buttons()
+
+        if keys.once("y"):
+            print("user abort")
+            if self.state:
+                return 5 # disconnect
+            else:
+                return 0 # scan
+
+        async with self.lock:
+            if self.done:
+                if self.state:
+                    return 2 # selection
+                else:
+                    return 0 # scan
+
+        self.lcd.show()
+        return -1 # stay in this state

python-test/state_heat.py

@@ -0,0 +1,61 @@
+#!/usr/bin/env python
+
+import uasyncio as asyncio
+from poll import set_state
+
+class StateHeat:
+    def __init__(self, lcd, state):
+        self.lcd = lcd
+        self.state = state
+
+        self.lock = asyncio.Lock()
+
+    def enter(self, val = None):
+        self.value = val
+        self.heater = asyncio.create_task(self.heat())
+        self.done = False
+
+    def exit(self):
+        self.heater.cancel()
+
+        if self.lock.locked():
+            self.lock.release()
+
+        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
+        await set_state(self.value[0], (self.state, pump))
+
+        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()
+
+        if keys.once("y"):
+            print("user abort")
+            if self.state:
+                async with self.lock:
+                    if self.done:
+                        return 4 # heat off
+            else:
+                return 5 # disconnect
+
+        async with self.lock:
+            if self.done:
+                if self.state == False:
+                    return 5 # disconnect
+                else:
+                    return 6 # wait for temperature
+
+        self.lcd.show()
+        return -1 # stay in this state

python-test/state_pump.py

@@ -0,0 +1,72 @@
+#!/usr/bin/env python
+
+import time
+import uasyncio as asyncio
+from poll import set_state
+from state_wait_temp import draw_graph
+
+class StatePump:
+    def __init__(self, lcd):
+        self.lcd = lcd
+
+        self.lock = asyncio.Lock()
+
+    def enter(self, val = None):
+        self.value = val
+        self.pumper = asyncio.create_task(self.pump())
+        self.done = False
+
+        device, workflow, index = self.value
+        self.start = None
+        self.duration = workflow["steps"][index][2]
+
+    def exit(self):
+        self.pumper.cancel()
+
+        if self.lock.locked():
+            self.lock.release()
+
+        return (self.value[0], self.value[1], self.value[2] + 1)
+
+    async def pump(self):
+        device, workflow, index = self.value
+
+        print("Turning on pump")
+        await set_state(device, (None, True))
+        async with self.lock:
+            self.start = time.time()
+
+        await asyncio.sleep_ms(int(self.duration * 1000))
+
+        print("Turning off pump")
+        await set_state(device, (None, False))
+        async with self.lock:
+            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 keys.once("y"):
+            print("user abort")
+            return 4 # heat off
+
+        async with self.lock:
+            if self.start != None:
+                draw_graph(self.lcd, 0.0, time.time() - self.start, self.duration)
+            else:
+                self.lcd.text("Turning on pump...", 0, 100, self.lcd.white)
+            if self.done:
+                if self.value[2] >= (len(workflow["steps"]) - 1):
+                    # TODO notify
+                    return 4 # heater off
+                else:
+                    return 6 # wait for temperature
+
+        self.lcd.show()
+        return -1 # stay in this state

python-test/state_scan.py

@@ -2,7 +2,6 @@
 
 import uasyncio as asyncio
 from scan import ble_scan
-from flow import flow
 
 class StateScan:
     def __init__(self, lcd):
@@ -10,7 +9,7 @@ class StateScan:
 
         self.lock = asyncio.Lock()
 
-    def enter(self):
+    def enter(self, val = None):
         self.scanner = asyncio.create_task(self.scan())
         self.results = []
         self.current = None
@@ -21,6 +20,8 @@ class StateScan:
         if self.lock.locked():
             self.lock.release()
 
+        return self.results[self.current]
+
     async def scan(self):
         while True:
             new = await ble_scan(None, None, 0.25)
@@ -71,9 +72,7 @@ class StateScan:
         async with self.lock:
             if keys.once("enter"):
                 if self.current < len(self.results):
-                    #return 1 # connect
-                    client = await self.results[self.current].device.connect()
-                    await flow(client)
+                    return 1 # connect
             elif keys.once("up"):
                 if self.current == None:
                     self.current = len(self.results) - 1

python-test/state_select.py

@@ -0,0 +1,57 @@
+#!/usr/bin/env python
+
+import uasyncio as asyncio
+from workflows import workflows
+
+class StateSelect:
+    def __init__(self, lcd):
+        self.lcd = lcd
+
+    def enter(self, val = None):
+        self.client = val
+        self.current = 0
+
+    def exit(self):
+        return self.client, workflows[self.current]
+
+    def draw_list(self):
+        for i, wf in enumerate(workflows):
+            s1 = "{}".format(wf["name"])
+            s2 = "by: {}".format(wf["author"])
+
+            off = i * 25 + 30
+            if off >= self.lcd.height:
+                break
+
+            c = self.lcd.white
+            if self.current == i:
+                c = self.lcd.red
+
+            self.lcd.hline(0, off, self.lcd.width, self.lcd.blue)
+            self.lcd.text(s1, 0, off + 2, c)
+            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 keys.once("y"):
+            print("user abort")
+            return 5 # disconnect
+        elif keys.once("up"):
+            if self.current > 0:
+                self.current -= 1
+        elif keys.once("down"):
+            if self.current < (len(workflows) - 1):
+                self.current += 1
+        elif keys.once("enter"):
+            return 3 # heater on
+
+        self.draw_list()
+
+        self.lcd.show()
+        return -1 # stay in this state

python-test/state_wait_temp.py

@@ -0,0 +1,73 @@
+#!/usr/bin/env python
+
+import uasyncio as asyncio
+from poll import set_target_temp, get_current_temp
+
+def draw_graph(lcd, min, val, max):
+    # TODO
+    lcd.text("{} -> {} -> {}".format(min, val, max), 0, 100, lcd.white)
+
+class StateWaitTemp:
+    def __init__(self, lcd):
+        self.lcd = lcd
+
+        self.lock = asyncio.Lock()
+
+    def enter(self, val = None):
+        self.value = val
+        self.poller = asyncio.create_task(self.poll())
+        self.temp = 0.0
+        self.min = 0.0
+        self.max = 100.0
+
+    def exit(self):
+        self.poller.cancel()
+
+        if self.lock.locked():
+            self.lock.release()
+
+        return (self.value[0], self.value[1], self.value[2])
+
+    async def poll(self):
+        device, workflow, index = self.value
+        async with self.lock:
+            self.temp = 0.0
+            self.min = 0.0
+            self.max = workflow["steps"][index][0]
+
+        temp = await get_current_temp(device)
+        print("initial temp: {}".format(temp))
+        async with self.lock:
+            self.temp = temp
+            self.min = temp
+
+        print("Setting temperature: {}".format(self.max))
+        await set_target_temp(device, self.max)
+
+        while temp < self.max:
+            temp = await get_current_temp(device)
+            print("now at {}".format(temp))
+            async with self.lock:
+                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()
+
+        if keys.once("y"):
+            print("user abort")
+            return 4 # heat off
+
+        async with self.lock:
+            draw_graph(self.lcd, self.min, self.temp, self.max)
+            if self.temp >= self.max:
+                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

@@ -0,0 +1,40 @@
+#!/usr/bin/env python
+
+import time
+from state_wait_temp import draw_graph
+
+class StateWaitTime:
+    def __init__(self, lcd):
+        self.lcd = lcd
+
+    def enter(self, val = None):
+        self.value = val
+
+        device, workflow, index = self.value
+        self.start = time.time()
+        self.end = self.start + workflow["steps"][index][1]
+
+    def exit(self):
+        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()
+
+        if keys.once("y"):
+            print("user abort")
+            return 4 # heat off
+
+        now = time.time()
+        draw_graph(self.lcd, 0.0, now - self.start, self.end - self.start)
+        if now >= self.end:
+            print("switch, {} >= {}".format(now, self.end))
+            return 8 # pump
+
+        self.lcd.show()
+        return -1 # stay in this state

python-test/states.py

@@ -3,6 +3,12 @@
 import uasyncio as asyncio
 from lcd import LCD
 from state_scan import StateScan
+from state_connect import StateConnect
+from state_select import StateSelect
+from state_heat import StateHeat
+from state_wait_temp import StateWaitTemp
+from state_wait_time import StateWaitTime
+from state_pump import StatePump
 
 class States:
     def __init__(self):
@@ -19,9 +25,10 @@ class States:
 
         next = asyncio.run(self.states[self.current].draw())
         if next >= 0:
-            self.states[self.current].exit()
+            print("switch to {}".format(next))
+            val = self.states[self.current].exit()
             self.current = next
-            self.states[self.current].enter()
+            self.states[self.current].enter(val)
 
 if True:#__name__ == "__main__":
     lcd = LCD()
@@ -33,5 +40,37 @@ if True:#__name__ == "__main__":
     scan = StateScan(lcd)
     states.add(scan)
 
+    # 1 - Connect
+    conn = StateConnect(lcd, True)
+    states.add(conn)
+
+    # 2 - Select
+    select = StateSelect(lcd)
+    states.add(select)
+
+    # 3 - Heater On
+    heatOn = StateHeat(lcd, True)
+    states.add(heatOn)
+
+    # 4 - Heater Off
+    heatOff = StateHeat(lcd, False)
+    states.add(heatOff)
+
+    # 5 - Disconnect
+    disconn = StateConnect(lcd, False)
+    states.add(disconn)
+
+    # 6 - Wait for temperature
+    waitTemp = StateWaitTemp(lcd)
+    states.add(waitTemp)
+
+    # 7 - Wait for time
+    waitTime = StateWaitTime(lcd)
+    states.add(waitTime)
+
+    # 8 - Pump
+    pump = StatePump(lcd)
+    states.add(pump)
+
     while True:
         states.run()

python-test/workflows.py

@@ -0,0 +1,23 @@
+#!/usr/bin/env python
+
+workflows = [
+    {
+        "name": "Hardcore",
+        "author": "xythobuz",
+        "steps": [
+            (190.0, 15.0, 5.0 - 4),
+            (205.0, 10.0, 20.0 - 4),
+            (220.0, 10.0, 20.0 - 4),
+        ],
+    },
+    {
+        "name": "Vorbi",
+        "author": "Rinor",
+        "steps": [
+            (176.0, 10.0, 6.0 - 4),
+            (187.0, 5.0, 10.0 -3),
+            (204.0, 3.0, 10.0 - 3),
+            (217.0, 5.0, 10.0 - 3),
+        ],
+    },
+]