modify brightness in menus. nicer battery display.

python-test/lcd.py

     def once(self, k):
         return self.new[k] and not self.old[k]
 
+    def held(self, k):
+        return self.new[k]
+
 class LCD(framebuf.FrameBuffer):
     def __init__(self):
         self.pwm = PWM(Pin(13))
 
         self.cs(1)
 
-        #self.spi = SPI(1)
-        #self.spi = SPI(1,   1_000_000)
         self.spi = SPI(1, 100_000_000, polarity=0, phase=0, sck=Pin(10), mosi=Pin(11), miso=None)
 
         self.dc = Pin(8, Pin.OUT)
             "enter": False,
         }
 
+        self.curr_brightness = 0.0
+        try:
+            with open("_cur_bright.txt", "r") as f:
+                s = next(f).split()[0]
+                self.curr_brightness = float(s)
+        except:
+            pass
+        self.brightness(self.curr_brightness)
+
     def buttons(self):
         keys = {
             "a": self.keyA.value() == 0,
     def color(self, R, G, B):
         return (((G & 0b00011100) << 3) + ((B & 0b11111000) >> 3) << 8) + (R & 0b11111000) + ((G & 0b11100000) >> 5)
 
+    def store_brightness(self):
+        old = -1.0
+        try:
+            with open("_cur_bright.txt", "r") as f:
+                s = next(f).split()[0]
+                old = float(s)
+        except:
+            pass
+        if self.curr_brightness != old:
+            with open("_cur_bright.txt", "w") as f:
+                s = "{}\n".format(self.curr_brightness)
+                f.write(s)
+
     def brightness(self, v):
+        if v < 0.0:
+            v = 0.0
+        if v > 1.0:
+            v = 1.0
+        self.curr_brightness = v
         self.pwm.duty_u16(int(v * 65535))
 
     def write_cmd(self, cmd):

python-test/state_scan.py

         if self.lock.locked():
             self.lock.release()
 
+        self.lcd.store_brightness()
+
         return self.results[self.current][4]
 
     async def scan(self):
             if self.current == i:
                 c2 = self.lcd.red
 
-            self.lcd.hline(0, off, self.lcd.width, self.lcd.blue)
+            self.lcd.hline(0, off - 3, self.lcd.width, self.lcd.blue)
             self.lcd.text(s1, 0, off + 2, c1)
             self.lcd.text(s2, 0, off + 12, c2)
 
                     self.current = 0
                 else:
                     self.current += 1
+            elif keys.held("left"):
+                v = self.lcd.curr_brightness - 0.05
+                if v < 0.05:
+                    v = 0.05
+                self.lcd.brightness(v)
+            elif keys.held("right"):
+                self.lcd.brightness(self.lcd.curr_brightness + 0.05)
             elif keys.once("y"):
                 return 0
 
 
             self.draw_list()
 
+        w = int(self.lcd.width * self.lcd.curr_brightness)
+        self.lcd.hline(0, 24, w, self.lcd.white)
+
         return -1

python-test/state_select.py

         self.menuOff = 0
 
     def exit(self):
+        self.lcd.store_brightness()
         return self.client, workflows[self.current]
 
     def draw_list(self):
             if self.current == i:
                 c = self.lcd.red
 
-            self.lcd.hline(0, off, self.lcd.width, self.lcd.blue)
+            self.lcd.hline(0, off - 3, self.lcd.width, self.lcd.blue)
             self.lcd.text(s1, 0, off + 2, c)
             self.lcd.text(s2, 0, off + 12, c)
 
             self.current += 1
         elif keys.once("enter") or keys.once("a"):
             return 1
+        elif keys.held("left"):
+            v = self.lcd.curr_brightness - 0.05
+            if v < 0.05:
+                v = 0.05
+            self.lcd.brightness(v)
+        elif keys.held("right"):
+            self.lcd.brightness(self.lcd.curr_brightness + 0.05)
 
         while self.current < 0:
             self.current += len(workflows)
 
         self.draw_list()
 
+        w = int(self.lcd.width * self.lcd.curr_brightness)
+        self.lcd.hline(0, 24, w, self.lcd.white)
+
         return -1

python-test/states.py

 # See <http://www.gnu.org/licenses/>.
 # ----------------------------------------------------------------------------
 
+from lcd import LCD
+lcd = LCD()
+
 import uasyncio as asyncio
 import io
 import sys
 import os
 import gc
 import time
+from state_wait_temp import from_hsv, translate
 
 # https://github.com/pimoroni/pimoroni-pico/blob/main/micropython/examples/pico_lipo_shim/battery_pico.py
 # https://github.com/pimoroni/enviro/pull/146
 # TODO https://github.com/micropython/micropython/issues/11185
 
-full_battery = 4.2
+full_battery = 4.1
 empty_battery = 3.2
+batt_warn_limit = 15
+batt_reread_limit = 2.7
 
 charging = machine.Pin("WL_GPIO2", machine.Pin.IN)
 conversion_factor = 3 * 3.3 / 65535
     old_pad = get_pad(29)
     set_pad(29, 128)  # no pulls, no output, no input
 
-    sample_count = 10
+    sample_count = 3
     voltage = 0
     for i in range(0, sample_count):
         voltage += batteryVoltageRead()
 def batteryVoltage():
     global cachedVoltage, lastCaching
 
-    if ((time.time() - lastCaching) >= 2) or (cachedVoltage == None):
+    if ((time.time() - lastCaching) > 0) or (cachedVoltage == None):
         lastCaching = time.time()
         cachedVoltage = batteryVoltageAverage()
+        if cachedVoltage <= batt_reread_limit:
+            cachedVoltage = batteryVoltageAverage()
 
     percentage = 100.0 * ((cachedVoltage - empty_battery) / (full_battery - empty_battery))
-    if percentage > 100.0:
-        percentage = 100.0
+    if percentage >= 100.0:
+        percentage = 99.0
+    elif percentage < 0.0:
+        percentage = 0.0
 
     return cachedVoltage, percentage
 
         self.lcd.fill(self.lcd.black)
         self.lcd.text("Volcano Remote Control App", 0, 0, self.lcd.green)
 
-        r = await self.states[self.current].draw()
+        ret = await self.states[self.current].draw()
 
         voltage, percentage = batteryVoltage()
-        s = "Charging ({:.2f}V)".format(voltage)
-        c = self.lcd.green
+        s = "Charging"
+        c = self.lcd.white
         if charging.value() != 1:
             s = "{:.0f}% ({:.2f}V)".format(percentage, voltage)
-            c = self.lcd.white
-            if percentage <= 20:
+            if percentage <= batt_warn_limit:
                 c = self.lcd.red
-        self.lcd.text("Battery: {}".format(s), 0, self.lcd.height - 10, c)
+            else:
+                hue = translate(percentage, batt_warn_limit, 100, 0.0, 0.333)
+                r, g, b = from_hsv(hue, 1.0, 1.0)
+                c = self.lcd.color(r, g, b)
+        whole = "Batt: {}".format(s)
+        self.lcd.text(whole, 0, self.lcd.height - 10, c)
+
+        off = (len(whole) + 1) * 8
+        if percentage <= batt_warn_limit:
+            self.lcd.text("CHARGE NOW!", off, self.lcd.height - 10, self.lcd.red)
+        elif charging.value() != 1:
+            self.lcd.rect(off, self.lcd.height - 10, self.lcd.width - off, 8, c, False)
+            max_w = self.lcd.width - off - 2
+            w = int(percentage / 100.0 * max_w)
+            self.lcd.rect(off + 1, self.lcd.height - 9, w, 6, c, True)
 
         self.lcd.show()
-        return r
+        return ret
 
     def run(self):
         if self.current == None:
     while True:
         states.run()
 
-from lcd import LCD
-lcd = LCD()
-
 def main():
     # splash screen
     from state_wait_temp import from_hsv
     lcd.textC(os.uname()[4][30 : 60], int(lcd.width / 2), lcd.height - 10, lcd.white, lcd.black)
 
     lcd.show()
-    lcd.brightness(1.0)
 
     # bootloader access with face buttons
     keys = lcd.buttons()