show errors on lcd. update scan result list. notify graph. soft reset at end.

python-test/state_connect.py

 
 import uasyncio as asyncio
 from poll import cache_services_characteristics
+import machine
 
 class StateConnect:
     def __init__(self, lcd, state):
         if self.lock.locked():
             self.lock.release()
 
+        if self.state == False:
+            machine.soft_reset()
+
         return self.client
 
     async def progress(self, n):

python-test/state_notify.py

         count, duration = workflow["notify"]
 
         async with self.lock:
-            self.max = count * 2
+            self.max = count * 6
 
         for i in range(0, count):
-            await asyncio.sleep_ms(int(duration * 1000))
+            await asyncio.sleep_ms(int(duration * 500))
+            async with self.lock:
+                self.step += 1
+
+            await asyncio.sleep_ms(int(duration * 500))
+            async with self.lock:
+                self.step += 1
+
             await set_state(device, (None, True))
             async with self.lock:
                 self.step += 1
 
-            await asyncio.sleep_ms(int(duration * 1000))
+            await asyncio.sleep_ms(int(duration * 500))
+            async with self.lock:
+                self.step += 1
+
+            await asyncio.sleep_ms(int(duration * 500))
+            async with self.lock:
+                self.step += 1
+
             await set_state(device, (None, False))
             async with self.lock:
                 self.step += 1

python-test/state_scan.py

         while True:
             new = await ble_scan(None, None, 0.25)
 
-            async with self.lock:
-                for n in new:
+            for n in new:
+                name = n.name()
+                mac = n.device.addr_hex()
+                rssi = n.rssi
+                value = [name, mac, rssi]
+
+                async with self.lock:
                     found = False
-                    for r in self.results:
-                        if r.device.addr_hex() == n.device.addr_hex():
+                    for i in range(0, len(self.results)):
+                        if self.results[i][1] == mac:
                             found = True
-                            r = n
+                            self.results[i][0] = name
+                            self.results[i][2] = rssi
                             break
-                    if not found:
-                        self.results.append(n)
+
+                    if found == False:
+                        self.results.append(value)
 
     def draw_list(self):
         for i, d in enumerate(self.results):
-            s1 = "{}".format(d.name())
-            s2 = "{}: [{}] {}".format(i + 1, d.device.addr_hex(), d.rssi)
+            name, mac, rssi = self.results[i]
+            s1 = "{}: {}".format(i + 1, name)
+            s2 = "[{}] {}".format(mac, rssi)
 
             off = i * 25 + 30
             if off >= self.lcd.height:
                 break
 
             c1 = self.lcd.white
-            if s1 == "S&B VOLCANO H":
+            if name == "S&B VOLCANO H":
                 c1 = self.lcd.green
                 if self.current == None:
                     self.current = i

python-test/states.py

             self.current = next
             self.states[self.current].enter(val)
 
-from lcd import LCD
-lcd = LCD()
-lcd.brightness(1.0)
-
-try:
+def state_machine(lcd):
     states = States(lcd)
 
     # 0 - Scan
 
     while True:
         states.run()
+
+from lcd import LCD
+lcd = LCD()
+lcd.brightness(1.0)
+
+try:
+    state_machine(lcd)
 except Exception as e:
-    lcd.fill(self.lcd.black)
-    lcd.text(str(e), 0, int(lcd.height / 2) - 5, lcd.white)
+    lcd.fill(lcd.black)
+    lcd.textC(str(e), int(lcd.width / 2), int(lcd.height / 2), lcd.white)
     lcd.show()
+    raise e