remove unneeded stuff

python-test/copy.sh

 
 if [ $# -ne 0 ] ; then
 cat << EOF | rshell
-cp flow.py /pyboard
 cp poll.py /pyboard
 cp scan.py /pyboard
 cp lcd.py /pyboard
 EOF
 else
 cat << EOF | rshell
-cp flow.py /pyboard
 cp poll.py /pyboard
 cp scan.py /pyboard
 cp lcd.py /pyboard

python-test/flow.py

-#!/usr/bin/env python
-
-import uasyncio as asyncio
-import sys
-import time
-
-from poll import (
-    ble_conn,
-    get_current_temp,
-    get_target_temp, set_target_temp,
-    get_unit_is_fahrenheit,
-    get_state, set_state
-)
-
-terminal_width = 100 #os.get_terminal_size().columns - 15
-
-def print_bar(value, start, end, unit):
-    width = terminal_width
-    s = "\r"
-    s += "#" * int((value - start) / (end - start) * width)
-    s += "-" * (width - int((value - start) / (end - start) * width))
-    s += " {}{}".format(value, unit)
-    print(s, end="")
-
-def sleep(t):
-    print_bar(0, 0, t, "s")
-    for i in range(0, t):
-        time.sleep(1.0)
-        print_bar(i + 1, 0, t, "s")
-    print()
-
-async def wait_for_temp(client, temp):
-    print("Setting temperature {}".format(temp))
-    await set_target_temp(client, temp)
-
-    print("Waiting for temperature to rise...")
-    start = await get_current_temp(client)
-    curr = start
-    print_bar(curr, start, temp, " degC")
-    while curr < temp:
-        time.sleep(1.0)
-        curr = await get_current_temp(client)
-        print_bar(curr, start, temp, " degC")
-    print()
-
-    print("Reached temperature {}".format(temp))
-
-async def flow_step(client, temp, t_wait, t_pump):
-    await wait_for_temp(client, temp)
-
-    print("Waiting {}s for heat to settle...".format(t_wait))
-    sleep(t_wait)
-
-    print("Pumping for {}s".format(t_pump))
-    await set_state(client, (True, True)) # turn on pump
-    sleep(t_pump)
-    await set_state(client, (True, False)) # turn off pump
-
-async def flow(client):
-    print("Turning on heater")
-    await set_state(client, (True, False))
-
-    await flow_step(client, 190.0, 15.0, 5.0 - 4)
-    await flow_step(client, 205.0, 10.0, 20.0 - 4)
-    await flow_step(client, 220.0, 10.0, 20.0 - 4)
-
-    print("Notification by pumping three times...")
-    for i in range(0, 3):
-        #time.sleep(1.0 / 3)
-        await set_state(client, (True, True)) # turn on pump
-        #time.sleep(1.0 / 3)
-        await set_state(client, (True, False)) # turn off pump
-
-    print("Turning heater off")
-    await set_state(client, (False, False)) # turn off heater and pump
-
-    print("Setting temperature back to 190")
-    await set_target_temp(client, 190.0)
-
-if __name__ == "__main__":
-    async def main(address):
-        client = await ble_conn(address)
-
-        try:
-            if await get_unit_is_fahrenheit(client):
-                raise RuntimeError("Imperial American scum is currently not supported :P")
-
-            print("Starting Workflow")
-            await flow(client)
-        except:
-            print("\nTurning heater off")
-            await set_state(client, (False, False)) # turn off heater and pump
-            raise
-
-    import machine
-    led_onboard = machine.Pin("LED", machine.Pin.OUT)
-
-    for i in range(0, 3):
-        led_onboard.on()
-        time.sleep(0.2)
-        led_onboard.off()
-        time.sleep(0.2)
-
-    print("ready")
-    while True:
-        if rp2.bootsel_button() == 1:
-            led_onboard.on()
-            print("run")
-
-            try:
-                asyncio.run(main(None))
-                print("done")
-            except Exception as e:
-                print(e)
-
-            led_onboard.off()
-            machine.reset()
-
-        time.sleep(0.2)

python-test/lcd.py

 import time
 import os
 import math
+import gc
 
 class KeyCheck:
     def __init__(self, new, old):
         self.dc = Pin(8, Pin.OUT)
         self.dc(1)
 
+        gc.collect()
         self.buffer = bytearray(self.height * self.width * 2)
 
         super().__init__(self.buffer, self.width, self.height, framebuf.RGB565)
         self.rst(1)
         self.rst(0)
         self.rst(1)
-
         self.write_cmd(0x36)
         self.write_data(0x70)
-
-        self.write_cmd(0x3A) 
+        self.write_cmd(0x3A)
         self.write_data(0x05)
-
         self.write_cmd(0xB2)
         self.write_data(0x0C)
         self.write_data(0x0C)
         self.write_data(0x00)
         self.write_data(0x33)
         self.write_data(0x33)
-
         self.write_cmd(0xB7)
-        self.write_data(0x35) 
-
+        self.write_data(0x35)
         self.write_cmd(0xBB)
         self.write_data(0x19)
-
         self.write_cmd(0xC0)
         self.write_data(0x2C)
-
         self.write_cmd(0xC2)
         self.write_data(0x01)
-
         self.write_cmd(0xC3)
-        self.write_data(0x12)   
-
+        self.write_data(0x12)
         self.write_cmd(0xC4)
         self.write_data(0x20)
-
         self.write_cmd(0xC6)
-        self.write_data(0x0F) 
-
+        self.write_data(0x0F)
         self.write_cmd(0xD0)
         self.write_data(0xA4)
         self.write_data(0xA1)
-
         self.write_cmd(0xE0)
         self.write_data(0xD0)
         self.write_data(0x04)
         self.write_data(0x0B)
         self.write_data(0x1F)
         self.write_data(0x23)
-
         self.write_cmd(0xE1)
         self.write_data(0xD0)
         self.write_data(0x04)
         self.write_data(0x1F)
         self.write_data(0x20)
         self.write_data(0x23)
-        
         self.write_cmd(0x21)
-
         self.write_cmd(0x11)
-
         self.write_cmd(0x29)
 
     def show(self):
         self.write_data(0x00)
         self.write_data(0x00)
         self.write_data(0xef)
-        
         self.write_cmd(0x2B)
         self.write_data(0x00)
         self.write_data(0x00)
         self.write_data(0x00)
         self.write_data(0xEF)
-
         self.write_cmd(0x2C)
-
         self.cs(1)
         self.dc(1)
         self.cs(0)
                    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)
 
+        gc.collect()
+        point_list = array('h')
+        point_list.append(0)
+        point_list.append(0)
+
         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
+
+            i = (segment - start_segment + 1) * 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)
+        self.poly(int(x_off), int(y_off), 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:
-            #key_test(lcd)
-            gfx_test(lcd)
-
-            lcd.show()
-            time.sleep(0.1)
-    except KeyboardInterrupt:
-        pass
-
-    lcd.fill(lcd.black)
-    lcd.show()
-    lcd.brightness(0.0)
+            self.arc(int(x0), int(y0), int(w), int(w), c_circle, -90, int(v * 360) - 90)
+        self.ring(int(x0), int(y0), int(w / 2), c_border)

python-test/poll.py

 characteristic13 = None
 characteristic14 = None
 
-async def ble_conn(address):
-    dev = await ble_scan(address)
-
-    if dev:
-        address = dev.device.addr_hex()
-        print("Connecting to '{}'...".format(address))
-        connection = await dev.device.connect()
-        await cache_services_characteristics(connection)
-        return connection
-
-    return None
-
-async def cache_services_characteristics(device):
+async def cache_services_characteristics(device, cb = None):
     global service3, service4
     global characteristic1, characteristic3
     global characteristicd, characteristicc
     global characteristic13, characteristic14
 
     service3 = await device.service(serviceUuidVolcano3)
+    if cb != None:
+        await cb(0.1)
+
     service4 = await device.service(serviceUuidVolcano4)
+    if cb != None:
+        await cb(0.2)
 
     uuid1 = bluetooth.UUID("10110001-5354-4f52-5a26-4249434b454c")
     characteristic1 = await service4.characteristic(uuid1)
+    if cb != None:
+        await cb(0.3)
 
     uuid3 = bluetooth.UUID("10110003-5354-4f52-5a26-4249434b454c")
     characteristic3 = await service4.characteristic(uuid3)
+    if cb != None:
+        await cb(0.4)
 
     uuidd = bluetooth.UUID("1010000d-5354-4f52-5a26-4249434b454c")
     characteristicd = await service3.characteristic(uuidd)
+    if cb != None:
+        await cb(0.5)
 
     uuidc = bluetooth.UUID("1010000c-5354-4f52-5a26-4249434b454c")
     characteristicc = await service3.characteristic(uuidc)
+    if cb != None:
+        await cb(0.6)
 
     uuidf = bluetooth.UUID("1011000f-5354-4f52-5a26-4249434b454c")
     characteristicf = await service4.characteristic(uuidf)
+    if cb != None:
+        await cb(0.7)
 
     uuid10 = bluetooth.UUID("10110010-5354-4f52-5a26-4249434b454c")
     characteristic10 = await service4.characteristic(uuid10)
+    if cb != None:
+        await cb(0.8)
 
     uuid13 = bluetooth.UUID("10110013-5354-4f52-5a26-4249434b454c")
     characteristic13 = await service4.characteristic(uuid13)
+    if cb != None:
+        await cb(0.9)
 
     uuid14 = bluetooth.UUID("10110014-5354-4f52-5a26-4249434b454c")
     characteristic14 = await service4.characteristic(uuid14)
+    if cb != None:
+        await cb(1.0)
 
 async def get_current_temp(device):
     val = await characteristic1.read()
     return (heater, pump)
 
 async def set_state(device, state):
-    heater, pump = state
-    if heater == True:
-        await characteristicf.write(int(0).to_bytes(1, "little"))
-    elif heater == False:
-        await characteristic10.write(int(0).to_bytes(1, "little"))
-
-    if pump == True:
-        await characteristic13.write(int(0).to_bytes(1, "little"))
-    elif pump == False:
-        await characteristic14.write(int(0).to_bytes(1, "little"))
-
-if __name__ == "__main__":
-    async def test_poll(device):
-        temp = await get_current_temp(device)
-        print("Current Temperature: {}".format(temp))
-
-        target = await get_target_temp(device)
-        print("Target Temperature: {}".format(target))
-
-        fahrenheit = await get_unit_is_fahrenheit(device)
-        if fahrenheit:
-            print("Unit is Fahrenheit")
-        else:
-            print("Unit is Celsius")
-
-        heater, pump = await get_state(device)
-        if heater:
-            print("Heater is On")
-        else:
-            print("Heater is Off")
-        if pump:
-            print("Pump is On")
-        else:
-            print("Pump is Off")
-
-    async def test(address):
-        device = await ble_conn(address)
-        if device == None:
-            return
-
-        async with device:
-            print("Writing...")
-            await set_target_temp(device, 190.0)
-
-            print("Reading...")
-            for i in range(0, 5):
-                await test_poll(device)
-                print()
-                time.sleep(2.0)
-
-    asyncio.run(test(None))
+    attempts = 3
+    while attempts > 0:
+        attempts -= 1
+        try:
+            heater, pump = state
+            if heater == True:
+                await characteristicf.write(int(0).to_bytes(1, "little"))
+            elif heater == False:
+                await characteristic10.write(int(0).to_bytes(1, "little"))
+
+            if pump == True:
+                await characteristic13.write(int(0).to_bytes(1, "little"))
+            elif pump == False:
+                await characteristic14.write(int(0).to_bytes(1, "little"))
+        except:
+            time.sleep(0.05)
+            continue
+
+        break

python-test/scan.py

 import sys
 
 async def ble_scan(addr = None, name = "S&B VOLCANO H", timeout = 0.5):
-    #print("Scanning for '{}' for {}s...".format(addr, timeout))
     scanner = aioble.scan(int(timeout * 1000.0), interval_us=30000, window_us=30000, active=True)
     async with scanner as s:
         results = []
         async for d in s:
-            #print("Scan: '{}' [{}]".format(d.name(), d.device.addr_hex()))
             if addr != None:
                 if addr == d.device.addr_hex():
                     return d
                 results.append(d)
         return results
 
-    print("No device found")
     return None
-
-if __name__ == "__main__":
-    dev = asyncio.run(ble_scan())
-    if dev != None:
-        print("{}".format(dev.device.addr_hex()))

python-test/state_connect.py

 
     def enter(self, val = None):
         self.step = False
+        self.iteration = 0.0
         self.done = False
         self.client = None
         self.connector = asyncio.create_task(self.connect(val))
 
         return self.client
 
+    async def progress(self, n):
+        async with self.lock:
+            self.iteration = n
+
     async def connect(self, d):
         async with self.lock:
             self.done = False
             client = await d[0].device.connect()
             async with self.lock:
                 self.step = True
-            await cache_services_characteristics(client)
+
+            await cache_services_characteristics(client, self.progress)
         else:
             await d[0].disconnect()
             client = None
         keys = self.lcd.buttons()
 
         if keys.once("y"):
-            print("user abort")
             if self.state:
-                return 5 # disconnect
+                return 5
             else:
-                return 0 # scan
+                return 0
 
         async with self.lock:
             if self.done:
                 if self.state:
-                    return 3 # heater on
+                    return 3
                 else:
-                    return 0 # scan
+                    return 0
             else:
                 if self.state == False:
                     self.lcd.text("Disconnecting...", 0, int(self.lcd.height / 2) - 5, self.lcd.white)
                     if self.step == False:
                         self.lcd.text("Connecting...", 0, int(self.lcd.height / 2) - 5, self.lcd.white)
                     else:
+                        self.lcd.pie(self.lcd.width / 2, self.lcd.height / 2, self.lcd.width - 30, self.lcd.red, self.lcd.green, self.iteration)
                         self.lcd.text("Fetching parameters...", 0, int(self.lcd.height / 2) - 5, self.lcd.white)
 
-        return -1 # stay in this state
+        return -1

python-test/state_heat.py

 
     def enter(self, val = None):
         self.value = val
-        self.heater = asyncio.create_task(self.heat())
         self.done = False
         self.step = False
+        self.heater = asyncio.create_task(self.heat())
 
     def exit(self):
         self.heater.cancel()
         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:
 
             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:
         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
+                        return 4
                     else:
-                        return 5 # disconnect
+                        return 5
             else:
-                return 5 # disconnect
+                return 5
 
         async with self.lock:
             if self.done:
                 if self.state == False:
-                    return 5 # disconnect
+                    return 5
                 else:
-                    return 6 # wait for temperature
+                    return 6
             else:
                 if self.state == False:
                     if self.state == False:
                 else:
                     self.lcd.text("Turning heater on...", 0, int(self.lcd.height / 2) - 5, self.lcd.white)
 
-        return -1 # stay in this state
+        return -1

python-test/state_notify.py

 
     def enter(self, val = None):
         self.value = val
-        self.notifier = asyncio.create_task(self.notify())
         self.done = False
+        self.step = 0
+        self.max = 0
+        self.notifier = asyncio.create_task(self.notify())
 
     def exit(self):
         self.notifier.cancel()
         device, workflow, index = self.value
         count, duration = workflow["notify"]
 
+        async with self.lock:
+            self.max = count * 2
+
         for i in range(0, count):
-            print("Turning on pump")
-            await set_state(device, (None, True))
             await asyncio.sleep_ms(int(duration * 1000))
+            await set_state(device, (None, True))
+            async with self.lock:
+                self.step += 1
 
-            print("Turning off pump")
-            await set_state(device, (None, False))
             await asyncio.sleep_ms(int(duration * 1000))
+            await set_state(device, (None, False))
+            async with self.lock:
+                self.step += 1
 
         async with self.lock:
             self.done = True
         keys = self.lcd.buttons()
 
         if keys.once("y"):
-            print("user abort")
-            return 4 # heat off
+            return 4
 
         async with self.lock:
+            draw_graph(self.lcd, 0, self.step, self.max)
+
             if self.done:
-                return 4 # heater off
+                return 4
 
-        return -1 # stay in this state
+        return -1

python-test/state_pump.py

 
     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]
 
+        self.pumper = asyncio.create_task(self.pump())
+
     def exit(self):
         self.pumper.cancel()
 
     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
         keys = self.lcd.buttons()
 
         if keys.once("y"):
-            print("user abort")
-            return 4 # heat off
+            return 4
 
         async with self.lock:
             if self.start != None:
             if self.done:
                 if self.value[2] >= (len(workflow["steps"]) - 1):
                     if workflow["notify"] != None:
-                        return 9 # notify
+                        return 9
                     else:
-                        return 4 # heater off
+                        return 4
                 else:
-                    return 6 # wait for temperature
+                    return 6
 
-        return -1 # stay in this state
+        return -1

python-test/state_scan.py

         self.lock = asyncio.Lock()
 
     def enter(self, val = None):
-        self.scanner = asyncio.create_task(self.scan())
         self.results = []
         self.current = None
+        self.scanner = asyncio.create_task(self.scan())
 
     def exit(self):
         self.scanner.cancel()
         async with self.lock:
             if keys.once("enter"):
                 if self.current < len(self.results):
-                    return 2 # select
+                    return 2
             elif keys.once("up"):
                 if self.current == None:
                     self.current = len(self.results) - 1
 
             self.draw_list()
 
-        return -1 # stay in this state
+        return -1

python-test/state_select.py

         keys = self.lcd.buttons()
 
         if keys.once("y"):
-            print("user abort")
-            return 5 # disconnect
+            return 5
         elif keys.once("up"):
             if self.current > 0:
                 self.current -= 1
             if self.current < (len(workflows) - 1):
                 self.current += 1
         elif keys.once("enter"):
-            return 1 # connect
+            return 1
 
         self.draw_list()
 
-        return -1 # stay in this state
+        return -1

python-test/state_wait_temp.py

         lcd.text("{} -> {} -> {}".format(min, val, max), 0, int(lcd.height / 2) - 5, lcd.white)
         return
 
-    w = lcd.width - 10
     ratio = (val - min) / (max - min)
+    lcd.pie(lcd.width / 2, lcd.height / 2, lcd.width - 30, lcd.red, lcd.green, ratio)
 
-    #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)
+    lcd.text("{} / {}".format(val, max), int(lcd.width / 2), int(lcd.height / 2) - 5, lcd.white)
 
 class StateWaitTemp:
     def __init__(self, lcd):
 
     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
+        self.poller = asyncio.create_task(self.poll())
 
     def exit(self):
         self.poller.cancel()
             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
 
         keys = self.lcd.buttons()
 
         if keys.once("y"):
-            print("user abort")
-            return 4 # heat off
+            return 4
 
         async with self.lock:
             if self.temp == 0.0:
                 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
+                return 7
 
-        return -1 # stay in this state
+        return -1

python-test/state_wait_time.py

         keys = self.lcd.buttons()
 
         if keys.once("y"):
-            print("user abort")
-            return 4 # heat off
+            return 4
 
         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
+            return 8
 
-        return -1 # stay in this state
+        return -1

python-test/states.py

 
         next = asyncio.run(self.draw())
         if next >= 0:
-            print("switch to {}".format(next))
             val = self.states[self.current].exit()
             self.current = next
             self.states[self.current].enter(val)
     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)