scroll for workflow selection. color gradient for graph.

python-test/state_connect.py

 
 import uasyncio as asyncio
 from poll import cache_services_characteristics
+from state_wait_temp import draw_graph
 import machine
 
 class StateConnect:
                     if self.step == False:
                         self.lcd.textC("Connecting...", int(self.lcd.width / 2), int(self.lcd.height / 2), 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.textC("Fetching parameters...", int(self.lcd.width / 2), int(self.lcd.height / 2), self.lcd.white)
+                        draw_graph(self.lcd, 0, int(self.iteration * 10), 10)
+                        self.lcd.textC("Fetching parameters...", int(self.lcd.width / 2), int(self.lcd.height / 2) - 10, self.lcd.white)
 
         return -1

python-test/state_scan.py

                 continue
 
             off = (i - self.menuOff) * 25 + 30
-            if off >= self.lcd.height:
+            if off >= (self.lcd.height - 10):
                 break
 
             selection = "  "
                     self.current -= len(self.results)
                 while self.current < self.menuOff:
                     self.menuOff -= 1
-                while self.current >= (self.menuOff + int((self.lcd.height - 30) / 25)):
+                while self.current >= (self.menuOff + int((self.lcd.height - 30 - 10) / 25)):
                     self.menuOff += 1
 
             # remove entries after timeout

python-test/state_select.py

     def enter(self, val = None):
         self.client = val
         self.current = 0
+        self.menuOff = 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"])
+            if i < self.menuOff:
+                continue
 
-            off = i * 25 + 30
-            if off >= self.lcd.height:
+            off = (i - self.menuOff) * 25 + 30
+            if off >= (self.lcd.height - 10):
                 break
 
+            s1 = "{}".format(wf["name"])
+            s2 = "by: {}".format(wf["author"])
+
             c = self.lcd.white
             if self.current == i:
                 c = self.lcd.red
         if keys.once("y"):
             return 5
         elif keys.once("up"):
-            if self.current > 0:
-                self.current -= 1
+            self.current -= 1
         elif keys.once("down"):
-            if self.current < (len(workflows) - 1):
-                self.current += 1
+            self.current += 1
         elif keys.once("enter") or keys.once("a"):
             return 1
 
+        while self.current < 0:
+            self.current += len(workflows)
+        while self.current >= len(workflows):
+            self.current -= len(workflows)
+        while self.current < self.menuOff:
+            self.menuOff -= 1
+        while self.current >= (self.menuOff + int((self.lcd.height - 30 - 10) / 25)):
+            self.menuOff += 1
+
         self.draw_list()
 
         return -1

python-test/state_wait_temp.py

 
 import uasyncio as asyncio
 from poll import set_target_temp, get_current_temp
+import math
+
+# https://github.com/pimoroni/pimoroni-pico
+def from_hsv(h, s, v):
+    i = math.floor(h * 6.0)
+    f = h * 6.0 - i
+    v *= 255.0
+    p = v * (1.0 - s)
+    q = v * (1.0 - f * s)
+    t = v * (1.0 - (1.0 - f) * s)
+
+    i = int(i) % 6
+    if i == 0:
+        return int(v), int(t), int(p)
+    if i == 1:
+        return int(q), int(v), int(p)
+    if i == 2:
+        return int(p), int(v), int(t)
+    if i == 3:
+        return int(p), int(q), int(v)
+    if i == 4:
+        return int(t), int(p), int(v)
+    if i == 5:
+        return int(v), int(p), int(q)
+
+# https://stackoverflow.com/a/1969274
+def translate(value, leftMin, leftMax, rightMin, rightMax):
+    leftSpan = leftMax - leftMin
+    rightSpan = rightMax - rightMin
+    valueScaled = float(value - leftMin) / float(leftSpan)
+    return rightMin + (valueScaled * rightSpan)
 
 def draw_graph(lcd, min, val, max):
     if max == min:
         lcd.textC("{} -> {} -> {}".format(min, val, max), int(self.lcd.width / 2), int(lcd.height / 2), lcd.white)
         return
 
+    hue = translate(val, min, max, 0.0, 0.333)
+    r, g, b = from_hsv(hue, 1.0, 1.0)
+    c = lcd.color(r, g, b)
+
     ratio = (val - min) / (max - min)
-    lcd.pie(lcd.width / 2, lcd.height / 2, lcd.width - 30, lcd.red, lcd.green, ratio)
+    lcd.pie(lcd.width / 2, lcd.height / 2, lcd.width - 42, lcd.white, c, ratio)
 
     lcd.textC("{} / {}".format(val, max), int(lcd.width / 2), int(lcd.height / 2), lcd.white)