fix timing issues

python-test/poll.py

 serviceUuidVolcano3 = bluetooth.UUID("10100000-5354-4f52-5a26-4249434b454c")
 serviceUuidVolcano4 = bluetooth.UUID("10110000-5354-4f52-5a26-4249434b454c")
 
+service3 = None
+service4 = None
+characteristic1 = None
+characteristic3 = None
+characteristicd = None
+characteristicc = None
+characteristicf = None
+characteristic10 = None
+characteristic13 = None
+characteristic14 = None
+
 async def ble_conn(address):
     dev = await ble_scan(address)
 
         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):
+    global service3, service4
+    global characteristic1, characteristic3
+    global characteristicd, characteristicc
+    global characteristicf, characteristic10
+    global characteristic13, characteristic14
+
+    service3 = await device.service(serviceUuidVolcano3)
+    service4 = await device.service(serviceUuidVolcano4)
+
+    uuid1 = bluetooth.UUID("10110001-5354-4f52-5a26-4249434b454c")
+    characteristic1 = await service4.characteristic(uuid1)
+
+    uuid3 = bluetooth.UUID("10110003-5354-4f52-5a26-4249434b454c")
+    characteristic3 = await service4.characteristic(uuid3)
+
+    uuidd = bluetooth.UUID("1010000d-5354-4f52-5a26-4249434b454c")
+    characteristicd = await service3.characteristic(uuidd)
+
+    uuidc = bluetooth.UUID("1010000c-5354-4f52-5a26-4249434b454c")
+    characteristicc = await service3.characteristic(uuidc)
+
+    uuidf = bluetooth.UUID("1011000f-5354-4f52-5a26-4249434b454c")
+    characteristicf = await service4.characteristic(uuidf)
+
+    uuid10 = bluetooth.UUID("10110010-5354-4f52-5a26-4249434b454c")
+    characteristic10 = await service4.characteristic(uuid10)
+
+    uuid13 = bluetooth.UUID("10110013-5354-4f52-5a26-4249434b454c")
+    characteristic13 = await service4.characteristic(uuid13)
+
+    uuid14 = bluetooth.UUID("10110014-5354-4f52-5a26-4249434b454c")
+    characteristic14 = await service4.characteristic(uuid14)
+
 async def get_current_temp(device):
-    service = await device.service(serviceUuidVolcano4)
-    uuid = bluetooth.UUID("10110001-5354-4f52-5a26-4249434b454c")
-    characteristic = await service.characteristic(uuid)
-    val = await characteristic.read()
+    val = await characteristic1.read()
     num = int.from_bytes(val, "little")
     return num / 10.0
 
 async def get_target_temp(device):
-    service = await device.service(serviceUuidVolcano4)
-    uuid = bluetooth.UUID("10110003-5354-4f52-5a26-4249434b454c")
-    characteristic = await service.characteristic(uuid)
-    val = await characteristic.read()
+    val = await characteristic3.read()
     num = int.from_bytes(val, "little")
     return num / 10.0
 
     while attempts > 0:
         val = int(temp * 10.0)
         d = val.to_bytes(4, "little")
-        service = await device.service(serviceUuidVolcano4)
-        uuid = bluetooth.UUID("10110003-5354-4f52-5a26-4249434b454c")
-        characteristic = await service.characteristic(uuid)
-        await characteristic.write(d)
+        await characteristic3.write(d)
 
         attempts -= 1
 
     raise RuntimeError("Could not set target temperature")
 
 async def get_unit_is_fahrenheit(device):
-    service = await device.service(serviceUuidVolcano3)
-    uuid = bluetooth.UUID("1010000d-5354-4f52-5a26-4249434b454c")
-    characteristic = await service.characteristic(uuid)
-    val = await characteristic.read()
+    val = await characteristicd.read()
     num = int.from_bytes(val, "little")
     return (num & 0x200) != 0
 
 async def get_state(device):
-    service = await device.service(serviceUuidVolcano3)
-    uuid = bluetooth.UUID("1010000c-5354-4f52-5a26-4249434b454c")
-    characteristic = await service.characteristic(uuid)
-    val = await characteristic.read()
+    val = await characteristicc.read()
     num = int.from_bytes(val, "little")
     heater = (num & 0x0020) != 0
     pump = (num & 0x2000) != 0
 async def set_state(device, state):
     heater, pump = state
     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"))
+        await characteristicf.write(int(0).to_bytes(1, "little"))
     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"))
+        await characteristic10.write(int(0).to_bytes(1, "little"))
 
     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"))
+        await characteristic13.write(int(0).to_bytes(1, "little"))
     elif pump == False:
-        service = await device.service(serviceUuidVolcano4)
-        uuid = bluetooth.UUID("10110014-5354-4f52-5a26-4249434b454c")
-        characteristic = await service.characteristic(uuid)
-        await characteristic.write(int(0).to_bytes(1, "little"))
+        await characteristic14.write(int(0).to_bytes(1, "little"))
 
 if __name__ == "__main__":
     async def test_poll(device):

python-test/state_connect.py

 #!/usr/bin/env python
 
 import uasyncio as asyncio
+from poll import cache_services_characteristics
 
 class StateConnect:
     def __init__(self, lcd, state):
         self.lock = asyncio.Lock()
 
     def enter(self, val = None):
+        self.step = False
         self.done = False
         self.client = None
         self.connector = asyncio.create_task(self.connect(val))
 
         if self.state:
             client = await d.device.connect()
+            async with self.lock:
+                self.step = True
+            await cache_services_characteristics(client)
         else:
             await d[0].disconnect()
             client = None
         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"):
                     return 0 # scan
             else:
                 if self.state == False:
-                    self.lcd.text("Disconnecting...", 0, 100, self.lcd.white)
+                    self.lcd.text("Disconnecting...", 0, int(self.lcd.height / 2) - 5, self.lcd.white)
                 else:
-                    self.lcd.text("Connecting...", 0, 100, self.lcd.white)
+                    if self.step == False:
+                        self.lcd.text("Connecting...", 0, int(self.lcd.height / 2) - 5, self.lcd.white)
+                    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

                     return 6 # wait for temperature
             else:
                 if self.state == False:
-                    self.lcd.text("Turning heater off...", 0, 100, self.lcd.white)
+                    self.lcd.text("Turning heater off...", 0, int(self.lcd.height / 2) - 5, self.lcd.white)
                 else:
-                    self.lcd.text("Turning heater on...", 0, 100, self.lcd.white)
+                    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_pump.py

                 if now - self.start <= self.duration:
                     draw_graph(self.lcd, 0.0, now - self.start, self.duration)
                 else:
-                    self.lcd.text("Turning off pump...", 0, 100, self.lcd.white)
+                    self.lcd.text("Turning off pump...", 0, int(self.lcd.height / 2) - 5, self.lcd.white)
             else:
-                self.lcd.text("Turning on pump...", 0, 100, self.lcd.white)
+                self.lcd.text("Turning on pump...", 0, int(self.lcd.height / 2) - 5, self.lcd.white)
 
             if self.done:
                 if self.value[2] >= (len(workflow["steps"]) - 1):

python-test/state_wait_temp.py

 
 def draw_graph(lcd, min, val, max):
     if max == min:
-        lcd.text("{} -> {} -> {}".format(min, val, max), 0, 100, lcd.white)
+        lcd.text("{} -> {} -> {}".format(min, val, max), 0, int(lcd.height / 2) - 5, lcd.white)
         return
 
     w = lcd.width - 10
     ratio = (val - min) / (max - min)
     wfull = int(w * ratio)
     wempty = w - wfull
-    lcd.rect(4, 100, wfull + 1, 50, lcd.green, True)
-    lcd.rect(4 + wfull, 100, wempty + 2, 50, lcd.green, False)
+    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.text("{}".format(val), int(lcd.width / 2), 125, lcd.white)
 
 class StateWaitTemp:
 
         async with self.lock:
             if self.temp == 0.0:
-                self.lcd.text("Setting temperature...", 0, 100, self.lcd.white)
+                self.lcd.text("Setting temperature...", 0, int(self.lcd.height / 2) - 5, self.lcd.white)
             else:
                 draw_graph(self.lcd, self.min, self.temp, self.max)
 

python-test/state_wait_time.py

 
         device, workflow, index = self.value
         self.start = time.time()
-        self.end = self.start + workflow["steps"][index][1]
+        self.end = self.start + int(workflow["steps"][index][1])
 
     def exit(self):
         return (self.value[0], self.value[1], self.value[2])

python-test/workflows.py

         "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),
+            (190.0, 15.0, 5.0),
+            (205.0, 10.0, 20.0),
+            (220.0, 10.0, 20.0),
         ],
     },
     {
         "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),
+            (176.0, 10.0, 6.0),
+            (187.0, 5.0, 10.0),
+            (204.0, 3.0, 10.0),
+            (217.0, 5.0, 10.0),
         ],
     },
 ]