Initial GPIO implementation for ESP32

Author: GuLinux

upython/backend/.gitignore

@@ -1,3 +1,3 @@
-config.json
-pinout.json
 __pycache__
+config_files/
+board_vars.py

upython/backend/board.py

@@ -1,4 +1,3 @@
-import sys
 import json
 from config import Config
 import protocols.wifi_manager
@@ -20,8 +19,8 @@ def __init__(self):
         self.config = Config(self.config_storage)
         self.wifi_manager = WiFiManager(self.config)
         with open(pinout_config_path, 'r') as pinout_config_file:
+            print(f'Loading pinout file: {pinout_config_path}')
             self.pinout_config = json.load(pinout_config_file)
-        print(self.pinout_config)
         self.status_led = StatusLed(self.__load_output(self.pinout_config['status_led']), self.config)
         self.wifi_manager.on_connecting = lambda: self.status_led.wifi_connecting()
         self.wifi_manager.on_station_connected = lambda _: self.status_led.status_ok()

upython/backend/board_compat.py

@@ -5,7 +5,11 @@
         import uasyncio as asyncio
         from boards.esp32.wifi_manager import ESPWiFiManager as WiFiManager
         from boards.esp32.config_storage import ESPConfigStorage as ConfigStorage
-        pinout_config_path = '/pinout.json'
+        import boards.esp32.gpio as gpio
+        from board_vars import board_name
+        pinout_config_path = f'/pinout_{board_name}.json'
+        server_port = 80
+        server_debug = False
     else:
         raise RuntimeError('Unsupported micropython platform')
 elif sys.implementation.name == 'cpython':
@@ -15,7 +19,9 @@
     if os.environ.get('SIMULATOR', '0') == '1':
         from boards.simulator.wifi_manager import SimulatorWiFiManager as WiFiManager
         import boards.simulator.gpio as gpio
-    pinout_config_path = os.environ.get('PINOUT_CONFIG_PATH', 'pinout.json')
+    pinout_config_path = os.environ.get('PINOUT_CONFIG_PATH', 'config_files/pinout.json')
+    server_port = int(os.environ.get('PORT', '80'))
+    server_debug = os.environ.get('DEBUG', 0) in ['1', 'true']
 else:
     raise RuntimeError(f'Unsupported python platform: {sys.implementation.name}')
 

upython/backend/board_vars.py.envsubst

@@ -0,0 +1,2 @@
+board_name = '${BOARD_NAME}'
+

upython/backend/boards/cpython/json_config_storage.py

@@ -3,7 +3,7 @@
 from protocols.config_storage import ConfigStorage
 
 class JsonConfigStorage(ConfigStorage):
-    CONFIG_FILE_PATH = os.environ.get('CONFIG_FILE', 'config.json')
+    CONFIG_FILE_PATH = os.environ.get('CONFIG_FILE', 'config_files/config.json')
     def __init__(self):
         self.config_file = JsonConfigStorage.CONFIG_FILE_PATH
 
@@ -51,4 +51,4 @@ def __load_json_config(self) -> dict:
 
     def __save_json_config(self, config: dict):
         with open(self.config_file, 'w') as f:
-            json.dump(config, f, indent=4)
+            json.dump(config, f, indent=4)

upython/backend/boards/esp32/config_storage.py

@@ -44,6 +44,7 @@ def _save_blob(self, key: str, value: bytes):
     def _load_blob(self, key: str, buffer_size: int, default_value: bytes | None = None) -> bytes | None:
         buffer = bytearray(buffer_size)
         try:
-            return self.nvs.get_blob(key, buffer)
+            read = self.nvs.get_blob(key, buffer)
+            return buffer
         except OSError:
             return default_value

upython/backend/boards/esp32/gpio.py

@@ -0,0 +1,58 @@
+import typing
+import protocols.gpio
+from machine import Pin, PWM
+
+class GPIO(protocols.gpio.GPIO):
+    def __init__(self, pin_name: str):
+        print(f'Initialising {type(self).__name__} with pin {pin_name}')
+        self.pin_name = pin_name
+
+
+class ButtonPin(GPIO, protocols.gpio.ButtonPin):
+    def __init__(self, pin_name: str):
+        super().__init__(pin_name)
+
+    @property
+    def value(self) -> bool:
+        raise NotImplementedError()
+    
+    def on_level_changed(self, callback: typing.Callable[[bool], None]) -> None:
+        raise NotImplementedError()
+
+class AnalogInputPin(GPIO, protocols.gpio.AnalogInputPin):
+    def __init__(self, pin_name: str):
+        super().__init__(pin_name)
+
+    @property
+    def value(self) -> float:
+        raise NotImplementedError()
+
+class DigitalOutputPin(GPIO, protocols.gpio.DigitalOutputPin):
+    def __init__(self, pin_name: str):
+        super().__init__(pin_name)
+        self.pin = Pin(int(pin_name), Pin.OUT)
+        self._value = False
+        self.on = False
+
+    @property
+    def on(self) -> bool:
+        return self._value
+
+    @on.setter
+    def on(self, on: bool) -> None:
+        self.pin.value(1 if on else 0)
+        self._value = on 
+
+class PWMOutputPin(GPIO, protocols.gpio.PWMOutputPin):
+    def __init__(self, pin_name: str):
+        super().__init__(pin_name)
+        self.pin = PWM(Pin(int(pin_name)), freq=1000)
+        self.duty = 0.0
+
+    @property
+    def duty(self) -> float:
+        return self.pin.duty_u16() / 65535.0
+
+    @duty.setter
+    def duty(self, duty: float) -> None:
+        self.pin.duty_u16(int(duty * 65535))

upython/backend/main.py

@@ -1,6 +1,6 @@
 from microdot import Microdot, send_file
 import os
-from board_compat import asyncio
+from board_compat import asyncio, server_port, server_debug
 from board import Board
 from config import WiFi
 
@@ -53,6 +53,6 @@ async def get_config(request):
 async def main():
     await board.start()
     await board.wifi_manager.connect_stations()
-    await app.start_server(port=int(os.environ.get('PORT', '80')), debug=os.environ.get('DEBUG', 0) in ['1', 'true'])
+    await app.start_server(port=server_port, debug=server_debug)
 
 asyncio.run(main())

upython/deploy

@@ -4,14 +4,28 @@ COPY_FRONTEND=false
 RESET=true
 COPY_APP=true
 REPL=true
+BOARD_NAME=''
 
 print_help() {
     cat >&2 <<EOF
-Usage: $(basename $0) [-na|--no-copy-app] [-f|--frontend] [-nr|--no-reset] [-np|--no-repl]
+Usage: $(basename $0) [-h|--help] [-na|--no-copy-app] [-f|--frontend] [-nr|--no-reset] [-np|--no-repl] <board_name>
 EOF
     exit "${1:-0}"
 }
 
+set_board_name() {
+    board_name="$1"
+    if ! [ -r "backend/config_files/pinout_$board_name.json" ]; then
+        echo "Invalid board name: $board_name" >&2
+        echo "Valid board names:" >&2
+        for file in backend/config_files/pinout_*.json; do
+            echo "  - $(basename "$file" .json | cut -d_ -f2-)"
+        done
+        exit 1
+    fi
+    export BOARD_NAME="$board_name"
+}
+
 while [ -n "$1" ]; do
     case "$1" in
         -na|--no-copy-app)
@@ -26,13 +40,21 @@ while [ -n "$1" ]; do
         -np|--no-repl)
             REPL=false
             ;;
-        *)
+        -h|--help)
             print_help 1
             ;;
+        *)
+            set_board_name "$1"
+            ;;
     esac
     shift
 done
 
+if [ -z "$BOARD_NAME" ]; then
+    echo "Error: you must set the board name" >&2
+    print_help 1
+fi
+
 mpremote_mkdir_recursive() {
     declare -a dirs
     index=0
@@ -51,15 +73,19 @@ mpremote_mkdir_recursive() {
 }
 
 if [ "$COPY_APP" = true ]; then
+    envsubst < backend/board_vars.py.envsubst > backend/board_vars.py
     find backend -type f -name *.py | while read python_file; do
         target_file="${python_file##backend}"
         target_dir="$(dirname "$target_file")"
         if [ "$target_dir" != "/" ]; then
             mpremote_mkdir_recursive "$target_dir"
         fi
         echo "$python_file -> $target_file (dir: $target_dir)"
-        echo mpremote fs cp "$python_file" ":$target_file"
+        mpremote fs cp "$python_file" ":$target_file"
     done
+    pinout_config_file="pinout_${BOARD_NAME}.json"
+    echo "backend/config_files/${pinout_config_file} -> :/${pinout_config_file}"
+    mpremote fs cp "backend/config_files/${pinout_config_file}" ":/${pinout_config_file}"
     #mpremote fs mkdir :"/boards"
     #mpremote fs mkdir :"/boards/esp32"
     #for file in main.py config.py utils.py board.py boards/esp32/*.py; do