support for lcd

python-test/copy.sh

@@ -5,6 +5,9 @@ cat << EOF | rshell
 cp flow.py /pyboard
 cp poll.py /pyboard
 cp scan.py /pyboard
+cp lcd.py /pyboard
+cp states.py /pyboard
+cp state_scan.py /pyboard
 cp $1 /pyboard/main.py
 EOF
 else
@@ -12,5 +15,8 @@ cat << EOF | rshell
 cp flow.py /pyboard
 cp poll.py /pyboard
 cp scan.py /pyboard
+cp lcd.py /pyboard
+cp states.py /pyboard
+cp state_scan.py /pyboard
 EOF
 fi

python-test/flow.py

@@ -12,14 +12,22 @@ from poll import (
     get_state, set_state
 )
 
+terminal_width = 100 #os.get_terminal_size().columns - 15
+
 def print_bar(value, start, end, unit):
-    print("{}{} -> {}{} -> {}{}".format(start, unit, value, unit, 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))
@@ -52,16 +60,16 @@ async def flow(client):
     print("Turning on heater")
     await set_state(client, (True, False))
 
-    await flow_step(client, 190.0, 20.0, 5.0 - 4.9)
-    await flow_step(client, 205.0, 10.0, 20.0 - 7)
-    await flow_step(client, 220.0, 10.0, 20.0 - 7)
+    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("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
@@ -69,7 +77,7 @@ async def flow(client):
     print("Setting temperature back to 190")
     await set_target_temp(client, 190.0)
 
-if True:#__name__ == "__main__":
+if __name__ == "__main__":
     async def main(address):
         client = await ble_conn(address)
 
@@ -84,4 +92,28 @@ if True:#__name__ == "__main__":
             await set_state(client, (False, False)) # turn off heater and pump
             raise
 
-    asyncio.run(main(None))
+    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

@@ -0,0 +1,278 @@
+# https://www.waveshare.com/wiki/Pico-LCD-1.3
+
+from machine import Pin, SPI, PWM
+import framebuf
+import time
+import os
+
+class KeyCheck:
+    def __init__(self, new, old):
+        self.new = new
+        self.old = old
+
+    def once(self, k):
+        return self.new[k] and not self.old[k]
+
+class LCD(framebuf.FrameBuffer):
+    def __init__(self):
+        self.width = 240
+        self.height = 240
+
+        self.cs = Pin(9, Pin.OUT)
+        self.rst = Pin(12, Pin.OUT)
+
+        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)
+        self.dc(1)
+
+        self.buffer = bytearray(self.height * self.width * 2)
+
+        super().__init__(self.buffer, self.width, self.height, framebuf.RGB565)
+        self.init_display()
+
+        self.red   = 0x07E0
+        self.green = 0x001f
+        self.blue  = 0xf800
+        self.white = 0xffff
+        self.black = 0x0000
+
+        self.fill(self.black)
+        self.show()
+
+        self.pwm = PWM(Pin(13))
+        self.pwm.freq(1000)
+        self.brightness(0.0)
+
+        self.keyA = Pin(15,Pin.IN,Pin.PULL_UP)
+        self.keyB = Pin(17,Pin.IN,Pin.PULL_UP)
+        self.keyX = Pin(19 ,Pin.IN,Pin.PULL_UP)
+        self.keyY= Pin(21 ,Pin.IN,Pin.PULL_UP)
+
+        self.up = Pin(2,Pin.IN,Pin.PULL_UP)
+        self.down = Pin(18,Pin.IN,Pin.PULL_UP)
+        self.left = Pin(16,Pin.IN,Pin.PULL_UP)
+        self.right = Pin(20,Pin.IN,Pin.PULL_UP)
+        self.ctrl = Pin(3,Pin.IN,Pin.PULL_UP)
+
+        self.keys_old = {
+            "a": False,
+            "b": False,
+            "x": False,
+            "y": False,
+            "up": False,
+            "down": False,
+            "left": False,
+            "right": False,
+            "enter": False,
+        }
+
+    def buttons(self):
+        keys = {
+            "a": self.keyA.value() == 0,
+            "b": self.keyB.value() == 0,
+            "x": self.keyX.value() == 0,
+            "y": self.keyY.value() == 0,
+            "up": self.up.value() == 0,
+            "down": self.down.value() == 0,
+            "left": self.left.value() == 0,
+            "right": self.right.value() == 0,
+            "enter": self.ctrl.value() == 0,
+        }
+        kc = KeyCheck(keys, self.keys_old)
+        self.keys_old = keys.copy()
+        return kc
+
+    def brightness(self, v):
+        self.pwm.duty_u16(int(v * 65535))
+
+    def write_cmd(self, cmd):
+        self.cs(1)
+        self.dc(0)
+        self.cs(0)
+        self.spi.write(bytearray([cmd]))
+        self.cs(1)
+
+    def write_data(self, buf):
+        self.cs(1)
+        self.dc(1)
+        self.cs(0)
+        self.spi.write(bytearray([buf]))
+        self.cs(1)
+
+    def init_display(self):
+        self.rst(1)
+        self.rst(0)
+        self.rst(1)
+
+        self.write_cmd(0x36)
+        self.write_data(0x70)
+
+        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_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_cmd(0xC4)
+        self.write_data(0x20)
+
+        self.write_cmd(0xC6)
+        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(0x0D)
+        self.write_data(0x11)
+        self.write_data(0x13)
+        self.write_data(0x2B)
+        self.write_data(0x3F)
+        self.write_data(0x54)
+        self.write_data(0x4C)
+        self.write_data(0x18)
+        self.write_data(0x0D)
+        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(0x0C)
+        self.write_data(0x11)
+        self.write_data(0x13)
+        self.write_data(0x2C)
+        self.write_data(0x3F)
+        self.write_data(0x44)
+        self.write_data(0x51)
+        self.write_data(0x2F)
+        self.write_data(0x1F)
+        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_cmd(0x2A)
+        self.write_data(0x00)
+        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)
+        self.spi.write(self.buffer)
+        self.cs(1)
+
+if __name__  == '__main__':
+    lcd = LCD()
+    lcd.brightness(1.0)
+
+    try:
+        while True:
+            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.show()
+            time.sleep(0.1)
+    except KeyboardInterrupt:
+        pass
+
+    lcd.fill(lcd.black)
+    lcd.show()
+    lcd.brightness(0.0)

python-test/poll.py

@@ -13,9 +13,9 @@ async def ble_conn(address):
     dev = await ble_scan(address)
 
     if dev:
-        address = dev.addr_hex()
+        address = dev.device.addr_hex()
         print("Connecting to '{}'...".format(address))
-        connection = await dev.connect()
+        connection = await dev.device.connect()
         return connection
 
     return None

python-test/scan.py

@@ -5,18 +5,22 @@ import aioble
 import bluetooth
 import sys
 
-async def ble_scan(addr = None, timeout = 0.1):
-    print("Scanning for '{}' for {}s...".format(addr, timeout))
+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()))
+            #print("Scan: '{}' [{}]".format(d.name(), d.device.addr_hex()))
             if addr != None:
                 if addr == d.device.addr_hex():
-                    return d.device
+                    return d
+            elif name != None:
+                if d.name() == name:
+                    return d
             else:
-                if d.name() == "S&B VOLCANO H":
-                    return d.device
+                results.append(d)
+        return results
 
     print("No device found")
     return None
@@ -24,4 +28,4 @@ async def ble_scan(addr = None, timeout = 0.1):
 if __name__ == "__main__":
     dev = asyncio.run(ble_scan())
     if dev != None:
-        print("{}".format(dev.addr_hex()))
+        print("{}".format(dev.device.addr_hex()))

python-test/state_scan.py

@@ -0,0 +1,91 @@
+#!/usr/bin/env python
+
+import uasyncio as asyncio
+from scan import ble_scan
+from flow import flow
+
+class StateScan:
+    def __init__(self, lcd):
+        self.lcd = lcd
+
+        self.lock = asyncio.Lock()
+
+    def enter(self):
+        self.scanner = asyncio.create_task(self.scan())
+        self.results = []
+        self.current = None
+
+    def exit(self):
+        self.scanner.cancel()
+
+        if self.lock.locked():
+            self.lock.release()
+
+    async def scan(self):
+        while True:
+            new = await ble_scan(None, None, 0.25)
+
+            async with self.lock:
+                for n in new:
+                    found = False
+                    for r in self.results:
+                        if r.device.addr_hex() == n.device.addr_hex():
+                            found = True
+                            r = n
+                            break
+                    if not found:
+                        self.results.append(n)
+
+    def draw_list(self):
+        for i, d in enumerate(self.results):
+            s1 = "{}".format(d.name())
+            s2 = "{} - {}".format(i + 1, d.device.addr_hex())
+
+            off = i * 25 + 30
+            if off >= self.lcd.height:
+                break
+
+            c1 = self.lcd.white
+            if s1 == "S&B VOLCANO H":
+                c1 = self.lcd.green
+                if self.current == None:
+                    self.current = i
+            elif self.current == i:
+                c1 = self.lcd.red
+            c2 = self.lcd.white
+            if self.current == i:
+                c2 = self.lcd.red
+
+            self.lcd.hline(0, off, self.lcd.width, self.lcd.blue)
+            self.lcd.text(s1, 0, off + 2, c1)
+            self.lcd.text(s2, 0, off + 12, c2)
+
+    async def draw(self):
+        self.lcd.fill(self.lcd.black)
+
+        self.lcd.text("Volcano Remote Control App", 0, 0, self.lcd.green)
+        self.lcd.text("Scanning for Bluetooth devices", 0, 10, self.lcd.red)
+
+        keys = self.lcd.buttons()
+
+        async with self.lock:
+            if keys.once("enter"):
+                if self.current < len(self.results):
+                    #return 1 # connect
+                    client = await self.results[self.current].device.connect()
+                    await flow(client)
+            elif keys.once("up"):
+                if self.current == None:
+                    self.current = len(self.results) - 1
+                elif self.current > 0:
+                    self.current -= 1
+            elif keys.once("down"):
+                if self.current == None:
+                    self.current = 0
+                elif self.current < (len(self.results) - 1):
+                    self.current += 1
+
+            self.draw_list()
+
+        self.lcd.show()
+        return -1 # stay in this state

python-test/states.py

@@ -0,0 +1,37 @@
+#!/usr/bin/env python
+
+import uasyncio as asyncio
+from lcd import LCD
+from state_scan import StateScan
+
+class States:
+    def __init__(self):
+        self.states = []
+        self.current = None
+
+    def add(self, s):
+        self.states.append(s)
+
+    def run(self):
+        if self.current == None:
+            self.current = 0
+            self.states[self.current].enter()
+
+        next = asyncio.run(self.states[self.current].draw())
+        if next >= 0:
+            self.states[self.current].exit()
+            self.current = next
+            self.states[self.current].enter()
+
+if True:#__name__ == "__main__":
+    lcd = LCD()
+    lcd.brightness(1.0)
+
+    states = States()
+
+    # 0 - Scan
+    scan = StateScan(lcd)
+    states.add(scan)
+
+    while True:
+        states.run()