Merge pull request 'feat/filesystem_viewer' (#70) from feat/filesystem_viewer into main

Reviewed-on: #70
Reviewed-by: Matthias Blankertz <matthias@blankertz.org>

.gitea/workflows/build.yaml

@@ -11,8 +11,10 @@ jobs:
         uses: actions/checkout@v4
       - name: Initialize submodules
         run: cd software && ./update-submodules.sh
+      - name: Prepare venv
+        run: python -m venv build-venv && source build-venv/bin/activate && pip install freezefs
       - name: Build
-        run: cd software && ./build.sh
+        run: source build-venv/bin/activate && cd software && ./build.sh
       - name: Upload firmware
         uses: actions/upload-artifact@v3
         with:

DEVELOP.md

@@ -52,3 +52,23 @@ would be stored in the following key/value pairs in the btree db:
  * 00aa11bb22/playlist/00000: a.mp3
  * 00aa11bb22/playlist/00001: b.mp3
  * 00aa11bb22/playlistpos: 00000
+
+## Notes for UI development with chromium
+
+Features for the web interface are best prototyped in a browser directly. By using the built-in developmer tools and
+and their "override" feature, the web contents are replaced by a locally stored copy, which can be used to directly
+test the modifications without going all the way through the build and flash process.
+
+However, modern browsers may restrict or even completely forbid the execution of dynamic content like JavaScript, if
+the content is stored on the local machine and/or the content is accessed using http. In such a case, chromium issues
+an error message similar to the following one:
+
+> Access to fetch at 'http://192.168.4.1/api/v1/audiofiles' from origin 'http://192.168.4.1' has been blocked by CORS
+> policy: The request client is not a secure context and the resource is in more-private address space `local`.
+
+To mitigate this, chromium offers two flags that need modification:
+- 'chrome://flags/#local-network-access-check' must be `Disabled`
+- 'chrome://flags/#unsafely-treat-insecure-origin-as-secure' must be `Enabled`
+
+Note that these settings leave the browser susceptible to security issues and should be returned to
+their default values as soon as possible.

software/boards/RPI_PICO_W/board.c

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2025 Matthias Blankertz <matthias@blankertz.org>
+
+#include "py/obj.h"
+#include "py/runtime.h"
+#include "py/objstr.h"
+
+#ifndef TONBERRY_GIT_REVISION
+#define TONBERRY_GIT_REVISION "unknown"
+#endif
+#ifndef TONBERRY_VERSION
+#define TONBERRY_VERSION "unknown"
+#endif
+
+static const MP_DEFINE_STR_OBJ(tonberry_git_revision_obj, TONBERRY_GIT_REVISION);
+static const MP_DEFINE_STR_OBJ(tonberry_version_obj, TONBERRY_VERSION);
+
+static const mp_rom_map_elem_t board_module_globals_table[] = {
+    {MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_board)},
+    {MP_ROM_QSTR(MP_QSTR_revision), MP_ROM_PTR(&tonberry_git_revision_obj)},
+    {MP_ROM_QSTR(MP_QSTR_version), MP_ROM_PTR(&tonberry_version_obj)},
+};
+static MP_DEFINE_CONST_DICT(board_module_globals, board_module_globals_table);
+
+const mp_obj_module_t board_cmodule = {
+    .base = {&mp_type_module},
+    .globals = (mp_obj_dict_t *)&board_module_globals,
+};
+MP_REGISTER_MODULE(MP_QSTR_board, board_cmodule);

software/boards/RPI_PICO_W/manifest.py

@@ -22,3 +22,5 @@ module("mp3player.py", "../../src")
 module("webserver.py", "../../src")
 package("utils", base_path="../../src")
 package("nfc", base_path="../../src")
+
+module("frozen_frontend.py", "../../build")

software/boards/RPI_PICO_W/mpconfigboard.cmake

@@ -20,3 +20,22 @@ set(GEN_PINS_CSV_ARG --board-csv "${GEN_PINS_BOARD_CSV}")
 
 add_link_options("-Wl,--print-memory-usage")
 set(PICO_USE_FASTEST_SUPPORTED_CLOCK 1)
+
+find_program(GIT git)
+
+execute_process(COMMAND ${GIT} rev-parse HEAD
+    WORKING_DIRECTORY "${CMAKE_CURRENT_LIST_DIR}"
+    OUTPUT_VARIABLE TONBERRY_GIT_REVISION
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+)
+
+execute_process(COMMAND ${GIT} describe --match 'v*' --always --dirty
+    WORKING_DIRECTORY "${CMAKE_CURRENT_LIST_DIR}"
+    OUTPUT_VARIABLE TONBERRY_VERSION
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+)
+
+set(MICROPY_SOURCE_BOARD "${CMAKE_CURRENT_LIST_DIR}/board.c")
+set(MICROPY_DEF_BOARD
+    TONBERRY_GIT_REVISION="${TONBERRY_GIT_REVISION}"
+    TONBERRY_VERSION="${TONBERRY_VERSION}")

software/build.sh

@@ -25,6 +25,11 @@ mkdir  "$FS_STAGE_DIR"/fs
 trap 'rm -rf $FS_STAGE_DIR' EXIT
 tools/mklittlefs/mklittlefs -p 256 -s 868352 -c "$FS_STAGE_DIR"/fs "$FS_STAGE_DIR"/filesystem.bin
 
+FRONTEND_STAGE_DIR=$(mktemp -d)
+trap 'rm -rf $FRONTEND_STAGE_DIR' EXIT
+gzip -c frontend/index.html > "$FRONTEND_STAGE_DIR"/index.html.gz
+python -m freezefs "$FRONTEND_STAGE_DIR" build/frozen_frontend.py --target=/frontend
+
 for hwconfig in boards/RPI_PICO_W/manifest-*.py; do
     hwconfig_base=$(basename "$hwconfig")
     hwname=${hwconfig_base##manifest-}

software/requirements.txt

@@ -0,0 +1 @@
+freezefs

software/src/app.py

@@ -9,8 +9,8 @@ from utils import TimerManager
 Dependencies = namedtuple('Dependencies', ('mp3player', 'nfcreader', 'buttons', 'playlistdb', 'hwconfig', 'leds',
                                            'config'))
 
-# Should be ~ 6dB steps
-VOLUME_CURVE = [1, 2, 4, 8, 16, 32, 63, 126, 251]
+# Should be ~ 3dB steps
+VOLUME_CURVE = [1, 2, 3, 4, 6, 8, 11, 16, 23, 32, 45, 64, 91, 128, 181, 255]
 
 
 class PlayerApp:
@@ -51,12 +51,20 @@ class PlayerApp:
         self.playlist_db = deps.playlistdb(self)
         self.hwconfig = deps.hwconfig(self)
         self.leds = deps.leds(self)
-        self.tag_mode = self.playlist_db.getSetting('tagmode')
+        self.tag_mode = self.config.get_tagmode()
+        self.volume_max = self.config.get_volume_max()
+        self.volume_pos = 3  # fallback if config.get_volume_boot is nonsense
+        try:
+            for idx, val in enumerate(VOLUME_CURVE):
+                if val >= self.config.get_volume_boot():
+                    self.volume_pos = idx
+                    break
+        except (TypeError, ValueError):
+            pass
         self.playing_tag = None
         self.playlist = None
         self.buttons = deps.buttons(self) if deps.buttons is not None else None
         self.mp3file = None
-        self.volume_pos = 3
         self.paused = False
         self.playing = False
         self.player.set_volume(VOLUME_CURVE[self.volume_pos])
@@ -74,7 +82,7 @@ class PlayerApp:
         uid_str = b''.join('{:02x}'.format(x).encode() for x in new_tag)
         if self.tag_mode == 'tagremains' or (self.tag_mode == 'tagstartstop' and new_tag != self.playing_tag):
             self._set_playlist(uid_str)
-            self.playing_tag = new_tag
+            self.playing_tag = new_tag if self.playlist is not None else None
         elif self.tag_mode == 'tagstartstop':
             print('Tag presented again, stopping playback')
             self._unset_playlist()
@@ -91,8 +99,10 @@ class PlayerApp:
     def onButtonPressed(self, what):
         assert self.buttons is not None
         if what == self.buttons.VOLUP:
-            self.volume_pos = min(self.volume_pos + 1, len(VOLUME_CURVE) - 1)
-            self.player.set_volume(VOLUME_CURVE[self.volume_pos])
+            new_volume = min(self.volume_pos + 1, len(VOLUME_CURVE) - 1)
+            if VOLUME_CURVE[new_volume] <= self.volume_max:
+                self.volume_pos = new_volume
+                self.player.set_volume(VOLUME_CURVE[self.volume_pos])
         elif what == self.buttons.VOLDOWN:
             self.volume_pos = max(self.volume_pos - 1, 0)
             self.player.set_volume(VOLUME_CURVE[self.volume_pos])
@@ -104,9 +114,6 @@ class PlayerApp:
             self._pause_toggle()
 
     def onPlaybackDone(self):
-        assert self.mp3file is not None
-        self.mp3file.close()
-        self.mp3file = None
         self._play_next()
 
     def onIdleTimeout(self):
@@ -141,9 +148,7 @@ class PlayerApp:
             self.playlist = None
 
     def _play_next(self):
-        if self.playlist is None:
-            return
-        filename = self.playlist.getNextPath()
+        filename = self.playlist.getNextPath() if self.playlist is not None else None
         self._play(filename)
         if filename is None:
             self.playlist = None
@@ -166,7 +171,11 @@ class PlayerApp:
             self._onIdle()
         if filename is not None:
             print(f'Playing {filename!r}')
-            self.mp3file = open(filename, 'rb')
+            try:
+                self.mp3file = open(filename, 'rb')
+            except OSError as ex:
+                print(f"Could not play file {filename}: {ex}")
+                return
             self.player.play(self.mp3file, offset)
             self.paused = False
             self._onActive()
@@ -196,3 +205,6 @@ class PlayerApp:
 
     def get_playlist_db(self):
         return self.playlist_db
+
+    def get_leds(self):
+        return self.leds

software/src/main.py

@@ -3,17 +3,17 @@
 
 import aiorepl  # type: ignore
 import asyncio
-from errno import ENOENT
 import machine
 import micropython
 import network
-import os
 import time
 import ubinascii
+import sys
 
 # Own modules
 import app
 from audiocore import AudioContext
+import frozen_frontend  # noqa: F401
 from mfrc522 import MFRC522
 from mp3player import MP3Player
 from nfc import Nfc
@@ -36,14 +36,22 @@ hwconfig.board_init()
 machine.mem32[0x40030000 + 0x00] = 0x10
 
 
-def setup_wifi():
+def setup_wifi(ssid='', passphrase='', security=network.WLAN.SEC_WPA_WPA2):
     network.hostname("TonberryPico")
-    wlan = network.WLAN(network.WLAN.IF_AP)
-    wlan.config(ssid=f"TonberryPicoAP_{machine.unique_id().hex()}", security=wlan.SEC_OPEN)
-    wlan.active(True)
+    if ssid is None or ssid == '':
+        apname = f"TonberryPicoAP_{machine.unique_id().hex()}"
+        print(f"Create AP {apname}")
+        wlan = network.WLAN(network.WLAN.IF_AP)
+        wlan.config(ssid=apname, password=passphrase if passphrase is not None else '', security=security)
+        wlan.active(True)
+    else:
+        print(f"Connect to SSID {ssid} with passphrase {passphrase}...")
+        wlan = network.WLAN()
+        wlan.active(True)
+        wlan.connect(ssid, passphrase if passphrase is not None else '', security=security)
 
-    # disable power management
-    wlan.config(pm=network.WLAN.PM_NONE)
+    # configure power management
+    wlan.config(pm=network.WLAN.PM_PERFORMANCE)
 
     mac = ubinascii.hexlify(network.WLAN().config('mac'), ':').decode()
     print(f"     mac: {mac}")
@@ -57,34 +65,44 @@ async def wdt_task(wdt):
     # TODO: more checking of app health
     # Right now this only protects against the asyncio executor crashing completely
     while True:
-        await asyncio.sleep_ms(500)
+        await asyncio.sleep_ms(100)
         wdt.feed()
 
 DB_PATH = '/sd/tonberry.db'
 
 config = Configuration()
 
+# Setup LEDs
+np = NeoPixel(hwconfig.LED_DIN, config.get_led_count(), sm=1)
+led_max = config.get_led_max()
+np.fill((led_max, led_max, 0))
+np.write()
+
 
 def run():
     asyncio.new_event_loop()
-    # Setup LEDs
-    np = NeoPixel(hwconfig.LED_DIN, config.get_led_count(), sm=1)
 
-    # Wifi with default config
-    setup_wifi()
+    if machine.Pin(hwconfig.BUTTONS[1], machine.Pin.IN, machine.Pin.PULL_UP).value() == 0:
+        np.fill((0, 0, led_max))
+        np.write()
+        # Force default access point
+        setup_wifi('', '', network.WLAN.SEC_OPEN)
+    else:
+        secstring = config.get_wifi_security()
+        security = network.WLAN.SEC_WPA_WPA2
+        if secstring == 'open':
+            security = network.WLAN.SEC_OPEN
+        elif secstring == 'wpa_wpa2':
+            security = network.WLAN.SEC_WPA_WPA2
+        elif secstring == 'wpa3':
+            security = network.WLAN.SEC_WPA3
+        elif secstring == 'wpa2_wpa3':
+            security = network.WLAN.SEC_WPA2_WPA3
+        setup_wifi(config.get_wifi_ssid(), config.get_wifi_passphrase(), security)
 
     # Setup MP3 player
     with SDContext(mosi=hwconfig.SD_DI, miso=hwconfig.SD_DO, sck=hwconfig.SD_SCK, ss=hwconfig.SD_CS,
                    baudrate=hwconfig.SD_CLOCKRATE):
-        # Temporary hack: build database from folders if no database exists
-        # Can be removed once playlists can be created via API
-        try:
-            _ = os.stat(DB_PATH)
-        except OSError as ex:
-            if ex.errno == ENOENT:
-                print("No playlist DB found, trying to build DB from tag dirs")
-                builddb()
-
         with BTreeFileManager(DB_PATH) as playlistdb, \
              AudioContext(hwconfig.I2S_DIN, hwconfig.I2S_DCLK, hwconfig.I2S_LRCLK) as audioctx:
 
@@ -98,38 +116,39 @@ def run():
                                     buttons=lambda the_app: Buttons(the_app, config, hwconfig),
                                     playlistdb=lambda _: playlistdb,
                                     hwconfig=lambda _: hwconfig,
-                                    leds=lambda _: LedManager(np),
+                                    leds=lambda _: LedManager(np, config),
                                     config=lambda _: config)
             the_app = app.PlayerApp(deps)
 
             start_webserver(config, the_app)
             # Start
-            wdt = machine.WDT(timeout=1000)
+            wdt = machine.WDT(timeout=2000)
             asyncio.create_task(aiorepl.task({'timer_manager': TimerManager(),
                                               'app': the_app}))
             asyncio.create_task(wdt_task(wdt))
             asyncio.get_event_loop().run_forever()
 
 
-def builddb():
-    """
-    For testing, build a playlist db based on the previous tag directory format.
-    Can be removed once uploading files / playlist via the web api is possible.
-    """
-    try:
-        os.unlink(DB_PATH)
-    except OSError:
-        pass
-    with BTreeFileManager(DB_PATH) as db:
-        for name, type_, _, _ in os.ilistdir(b'/sd'):
-            if type_ != 0x4000:
-                continue
-            fl = [b'/sd/' + name + b'/' + x for x in os.listdir(b'/sd/' + name) if x.endswith(b'.mp3')]
-            db.createPlaylistForTag(name, fl)
-    os.sync()
+def error_blink():
+    while True:
+        if machine.Pin(hwconfig.BUTTONS[0], machine.Pin.IN, machine.Pin.PULL_UP).value() == 0:
+            machine.reset()
+        np.fill((led_max, 0, 0))
+        np.write()
+        time.sleep_ms(500)
+        np.fill((0, 0, 0))
+        np.write()
+        time.sleep_ms(500)
 
 
 if __name__ == '__main__':
     time.sleep(1)
     if machine.Pin(hwconfig.BUTTONS[0], machine.Pin.IN, machine.Pin.PULL_UP).value() != 0:
-        run()
+        try:
+            run()
+        except Exception as ex:
+            sys.print_exception(ex)
+            error_blink()
+    else:
+        np.fill((led_max, 0, 0))
+        np.write()

software/src/utils/__init__.py

@@ -2,6 +2,7 @@
 # Copyright (c) 2025 Matthias Blankertz <matthias@blankertz.org>
 
 from utils.helpers import safe_callback
+from utils.timer import TimerManager
 from utils.buttons import Buttons
 from utils.config import Configuration
 from utils.leds import LedManager
@@ -9,7 +10,6 @@ from utils.mbrpartition import MBRPartition
 from utils.pinindex import get_pin_index
 from utils.playlistdb import BTreeDB, BTreeFileManager
 from utils.sdcontext import SDContext
-from utils.timer import TimerManager
 
 __all__ = ["BTreeDB", "BTreeFileManager", "Buttons", "Configuration", "get_pin_index", "LedManager", "MBRPartition",
            "safe_callback", "SDContext", "TimerManager"]

software/src/utils/buttons.py

@@ -5,7 +5,7 @@ import asyncio
 import machine
 import micropython
 import time
-from utils import safe_callback
+from utils import safe_callback, TimerManager
 try:
     from typing import TYPE_CHECKING  # type: ignore
 except ImportError:
@@ -32,6 +32,7 @@ class Buttons:
     def __init__(self, cb: "ButtonCallback", config, hwconfig):
         self.button_map = config.get_button_map()
         self.hw_buttons = hwconfig.BUTTONS
+        self.hwconfig = hwconfig
         self.cb = cb
         self.buttons = dict()
         for key_id, key_name in self.KEYMAP.items():
@@ -42,6 +43,7 @@ class Buttons:
         self.int_flag = asyncio.ThreadSafeFlag()
         self.pressed: list[int] = []
         self.last: dict[int, int] = {}
+        self.timer_manager = TimerManager()
         for button in self.buttons.keys():
             button.irq(handler=self._interrupt, trigger=machine.Pin.IRQ_FALLING | machine.Pin.IRQ_RISING)
         asyncio.create_task(self.task())
@@ -69,6 +71,10 @@ class Buttons:
             # print(f'B{keycode} {now}')
             self.pressed.append(keycode)
             self.int_flag.set()
+            if keycode == self.VOLDOWN:
+                self.timer_manager.schedule(time.ticks_ms() + 5000, self.long_press_shutdown)
+        if button.value() == 1 and keycode == self.VOLDOWN:
+            self.timer_manager.cancel(self.long_press_shutdown)
 
     async def task(self):
         while True:
@@ -76,3 +82,9 @@ class Buttons:
             while len(self.pressed) > 0:
                 what = self.pressed.pop()
                 safe_callback(lambda: self.cb.onButtonPressed(what), "button callback")
+
+    def long_press_shutdown(self):
+        if self.hwconfig.get_on_battery():
+            self.hwconfig.power_off()
+        else:
+            machine.reset()

software/src/utils/config.py

@@ -21,7 +21,16 @@ class Configuration:
             'VOLDOWN': 2,
             'PREV': None,
             'NEXT': 1,
-        }
+        },
+        'TAGMODE': 'tagremains',
+        'WIFI': {
+            'SSID': '',
+            'PASSPHRASE': '',
+            'SECURITY': 'wpa_wpa2',
+        },
+        'VOLUME_MAX': 255,
+        'VOLUME_BOOT': 16,
+        'LED_MAX': 255,
     }
 
     def __init__(self, config_path='/config.json'):
@@ -29,6 +38,7 @@ class Configuration:
         try:
             with open(self.config_path, 'r') as conf_file:
                 self.config = json.load(conf_file)
+            self._merge_configs(self.DEFAULT_CONFIG, self.config)
         except OSError as ex:
             if ex.errno == ENOENT:
                 self.config = Configuration.DEFAULT_CONFIG
@@ -50,6 +60,16 @@ class Configuration:
                 raise
         os.sync()
 
+    def _merge_configs(self, default, config):
+        for k in default.keys():
+            if k not in config:
+                if isinstance(default[k], dict):
+                    config[k] = default[k].copy()
+                else:
+                    config[k] = default[k]
+            elif isinstance(default[k], dict):
+                self._merge_configs(default[k], config[k])
+
     def _save(self):
         with open(self.config_path + '.new', 'w') as conf_file:
             json.dump(self.config, conf_file)
@@ -58,7 +78,7 @@ class Configuration:
         os.sync()
 
     def _get(self, key):
-        return self.config.get(key, self.DEFAULT_CONFIG[key])
+        return self.config[key]
 
     def get_led_count(self) -> int:
         return self._get('LED_COUNT')
@@ -72,6 +92,27 @@ class Configuration:
     def get_button_map(self) -> Mapping[str, int | None]:
         return self._get('BUTTON_MAP')
 
+    def get_tagmode(self) -> str:
+        return self._get('TAGMODE')
+
+    def get_wifi_ssid(self) -> str:
+        return self._get('WIFI')['SSID']
+
+    def get_wifi_passphrase(self) -> str:
+        return self._get('WIFI')['PASSPHRASE']
+
+    def get_wifi_security(self) -> str:
+        return self._get('WIFI')['SECURITY']
+
+    def get_volume_max(self) -> int:
+        return self._get('VOLUME_MAX')
+
+    def get_led_max(self) -> int:
+        return self._get('LED_MAX')
+
+    def get_volume_boot(self) -> int:
+        return self._get('VOLUME_BOOT')
+
     # For the web API
     def get_config(self) -> Mapping[str, Any]:
         return self.config
@@ -87,5 +128,11 @@ class Configuration:
 
     def set_config(self, config):
         self._validate(self.DEFAULT_CONFIG, config)
+        if 'TAGMODE' in config and config['TAGMODE'] not in ['tagremains', 'tagstartstop']:
+            raise ValueError("Invalid TAGMODE: Must be 'tagremains' or 'tagstartstop'")
+        if 'WLAN' in config and 'SECURITY' in config['WLAN'] and \
+           config['WLAN']['SECURITY'] not in ['open', 'wpa_wpa2', 'wpa3', 'wpa2_wpa3']:
+            raise ValueError("Invalid WLAN SECURITY: Must be 'open', 'wpa_wpa2', 'wpa3' or 'wpa2_wpa3'")
+        self._merge_configs(self.config, config)
         self.config = config
         self._save()

software/src/utils/leds.py

@@ -10,16 +10,17 @@ import time
 class LedManager:
     IDLE = const(0)
     PLAYING = const(1)
+    REBOOTING = const(2)
 
-    def __init__(self, np):
+    def __init__(self, np, config):
         self.led_state = LedManager.IDLE
+        self.brightness = config.get_led_max() / 255
         self.np = np
-        self.brightness = 0.1
         self.leds = len(self.np)
         asyncio.create_task(self.run())
 
     def set_state(self, state):
-        assert state in [LedManager.IDLE, LedManager.PLAYING]
+        assert state in [LedManager.IDLE, LedManager.PLAYING, LedManager.REBOOTING]
         self.led_state = state
 
     def _gamma(self, value, X=2.2):
@@ -50,6 +51,8 @@ class LedManager:
                 self._pulse(time_, (0, 1, 0), 3)
             elif self.led_state == LedManager.PLAYING:
                 self._rainbow(time_)
+            elif self.led_state == LedManager.REBOOTING:
+                self._pulse(time_, (1, 0, 1), 0.2)
             time_ += 0.02
             before = time.ticks_ms()
             await self.np.async_write()

software/src/utils/playlistdb.py

@@ -31,17 +31,15 @@ class BTreeDB(IPlaylistDB):
     PERSIST_NO = b'no'
     PERSIST_TRACK = b'track'
     PERSIST_OFFSET = b'offset'
-    DEFAULT_SETTINGS = {
-        b'tagmode': b'tagremains'
-    }
 
     class Playlist(IPlaylist):
-        def __init__(self, parent: "BTreeDB", tag: bytes, pos: int, persist, shuffle):
+        def __init__(self, parent: "BTreeDB", tag: bytes, pos: int, persist, shuffle, name):
             self.parent = parent
             self.tag = tag
             self.pos = pos
             self.persist = persist
             self.shuffle = shuffle
+            self.name = name
             self.length = self.parent._getPlaylistLength(self.tag)
             self._shuffle()
 
@@ -171,6 +169,10 @@ class BTreeDB(IPlaylistDB):
         return (b''.join([tag, b'/playlist/']),
                 b''.join([tag, b'/playlist0']))
 
+    @staticmethod
+    def _keyPlaylistName(tag):
+        return b''.join([tag, b'/playlistname'])
+
     def _flush(self):
         """
         Flush the database and call the flush_func if it was provided.
@@ -225,12 +227,13 @@ class BTreeDB(IPlaylistDB):
             raise RuntimeError("Malformed playlist key")
         return int(elements[2])+1
 
-    def _savePlaylist(self, tag, entries, persist, shuffle, flush=True):
+    def _savePlaylist(self, tag, entries, persist, shuffle, name, flush=True):
         self._deletePlaylist(tag, False)
         for idx, entry in enumerate(entries):
             self.db[self._keyPlaylistEntry(tag, idx)] = entry
         self.db[self._keyPlaylistPersist(tag)] = persist
         self.db[self._keyPlaylistShuffle(tag)] = shuffle
+        self.db[self._keyPlaylistName(tag)] = name.encode()
         if flush:
             self._flush()
 
@@ -243,7 +246,7 @@ class BTreeDB(IPlaylistDB):
                 pass
         for k in (self._keyPlaylistPos(tag), self._keyPlaylistPosOffset(tag),
                   self._keyPlaylistPersist(tag), self._keyPlaylistShuffle(tag),
-                  self._keyPlaylistShuffleSeed(tag)):
+                  self._keyPlaylistShuffleSeed(tag), self._keyPlaylistName(tag)):
             try:
                 del self.db[k]
             except KeyError:
@@ -251,15 +254,18 @@ class BTreeDB(IPlaylistDB):
         if flush:
             self._flush()
 
-    def getPlaylistTags(self):
+    def getPlaylists(self):
         """
-        Get a keys-only dict of all defined playlists. Playlists currently do not have names, but are identified by
-        their tag.
+        Get a list of all defined playlists with their tag and names.
         """
         playlist_tags = set()
         for item in self.db:
             playlist_tags.add(item.split(b'/')[0])
-        return playlist_tags
+        playlists = []
+        for tag in playlist_tags:
+            name = self.db.get(self._keyPlaylistName(tag), b'').decode()
+            playlists.append({'tag': tag, 'name': name})
+        return playlists
 
     def getPlaylistForTag(self, tag: bytes):
         """
@@ -278,24 +284,23 @@ class BTreeDB(IPlaylistDB):
             return None
         if self._keyPlaylistEntry(tag, pos) not in self.db:
             pos = 0
+        name = self.db.get(self._keyPlaylistName(tag), b'').decode()
         shuffle = self.db.get(self._keyPlaylistShuffle(tag), self.SHUFFLE_NO)
-        return self.Playlist(self, tag, pos, persist, shuffle)
+        return self.Playlist(self, tag, pos, persist, shuffle, name)
 
     def createPlaylistForTag(self, tag: bytes, entries: typing.Iterable[bytes], persist=PERSIST_TRACK,
-                             shuffle=SHUFFLE_NO):
+                             shuffle=SHUFFLE_NO, name: str = ''):
         """
         Create and save a playlist for 'tag' and return the Playlist object. If a playlist already existed for 'tag' it
         is overwritten.
         """
         assert persist in (self.PERSIST_NO, self.PERSIST_TRACK, self.PERSIST_OFFSET)
         assert shuffle in (self.SHUFFLE_NO, self.SHUFFLE_YES)
-        self._savePlaylist(tag, entries, persist, shuffle)
+        self._savePlaylist(tag, entries, persist, shuffle, name)
         return self.getPlaylistForTag(tag)
 
-    def getSetting(self, key: bytes | str) -> str:
-        if type(key) is str:
-            key = key.encode()
-        return self.db.get(b'settings/' + key, self.DEFAULT_SETTINGS[key]).decode()
+    def deletePlaylistForTag(self, tag: bytes):
+        self._deletePlaylist(tag)
 
     def validate(self, dump=False):
         """
@@ -316,8 +321,7 @@ class BTreeDB(IPlaylistDB):
                 fail(f'Malformed key {k!r}')
                 continue
             if fields[0] == b'settings':
-                val = self.db[k].decode()
-                print(f'Setting {fields[1].decode()} = {val}')
+                # Legacy, not used any more
                 continue
             if last_tag != fields[0]:
                 last_tag = fields[0]
@@ -376,6 +380,14 @@ class BTreeDB(IPlaylistDB):
                     _ = int(val)
                 except ValueError:
                     fail(f' Bad playlistposoffset value for {last_tag}: {val!r}')
+            elif fields[1] == b'playlistname':
+                val = self.db[k]
+                try:
+                    name = val.decode()
+                    if dump:
+                        print(f'\tName: {name}')
+                except UnicodeError:
+                    fail(f' Bad playlistname for {last_tag}: Not valid unicode')
             else:
                 fail(f'Unknown key {k!r}')
         return result

software/src/webserver.py

@@ -4,10 +4,19 @@ Copyright (c) 2024-2025 Stefan Kratochwil <Kratochwil-LA@gmx.de>
 '''
 
 import asyncio
+import board
+import errno
+import hwconfig
 import json
+import machine
+import network
 import os
+import time
+import ubinascii
 
-from microdot import Microdot
+from array import array
+from microdot import Microdot, redirect, send_file, Request
+from utils import TimerManager, LedManager
 
 webapp = Microdot()
 server = None
@@ -15,24 +24,31 @@ config = None
 app = None
 nfc = None
 playlist_db = None
+leds = None
+timer_manager = None
+
+Request.max_content_length = 128 * 1024 * 1024  # 128MB requests allowed
+
 
 def start_webserver(config_, app_):
-    global server, config, app, nfc, playlist_db
-    server = asyncio.create_task(webapp.start_server(port=80))
+    global server, config, app, nfc, playlist_db, leds, timer_manager
+    server = asyncio.create_task(webapp.start_server(host='::0', port=80))
     config = config_
     app = app_
     nfc = app.get_nfc()
     playlist_db = app.get_playlist_db()
+    leds = app.get_leds()
+    timer_manager = TimerManager()
 
 
 @webapp.before_request
 async def before_request_handler(request):
-    if request.method in ['PUT', 'POST'] and app.is_playing():
+    if request.method in ['PUT', 'POST', 'DELETE'] and app.is_playing():
         return "Cannot write to device while playback is active", 503
     app.reset_idle_timeout()
 
 
-@webapp.route('/')
+@webapp.route('/api/v1/hello')
 async def index(request):
     print("wohoo, a guest :)")
     print(f"  app: {request.app}")
@@ -77,9 +93,27 @@ async def last_tag_uid_get(request):
     return {'tag': tag}
 
 
+@webapp.route('/', methods=['GET'])
+async def root_get(request):
+    return redirect('/index.html')
+
+
+@webapp.route('/index.html', methods=['GET'])
+async def index_get(request):
+    return send_file('/frontend/index.html.gz', content_type='text/html', compressed='gzip')
+
+
+@webapp.route('/static/<path:path>', methods=['GET'])
+async def static(request, path):
+    if '..' in path:
+        # directory traversal is not allowed
+        return 'Not found', 404
+    return send_file('/frontend/static/' + path, max_age=86400)
+
+
 @webapp.route('/api/v1/playlists', methods=['GET'])
 async def playlists_get(request):
-    return sorted(playlist_db.getPlaylistTags())
+    return playlist_db.getPlaylists()
 
 
 def is_hex(s):
@@ -96,29 +130,170 @@ async def playlist_get(request, tag):
         return 'invalid tag', 400
 
     playlist = playlist_db.getPlaylistForTag(tag.encode())
+    if playlist is None:
+        return None, 404
 
     return {
-            'shuffle': playlist.__dict__.get('shuffle'),
-            'persist': playlist.__dict__.get('persist'),
+            'shuffle': playlist.shuffle,
+            'persist': playlist.persist,
             'paths': [(p[len(fsroot):] if p.startswith(fsroot) else p).decode()
                       for p in playlist.getPaths()],
+            'name': playlist.name
     }
 
+
+@webapp.route('/api/v1/playlist/<tag>', methods=['PUT'])
+async def playlist_put(request, tag):
+    if not is_hex(tag):
+        return 'invalid tag', 400
+
+    playlist = request.json
+    if 'persist' in playlist and \
+       playlist['persist'] not in ['no', 'track', 'offset']:
+        return "Invalid 'persist' setting", 400
+    if 'shuffle' in playlist and \
+       playlist['shuffle'] not in ['no', 'yes']:
+        return "Invalid 'shuffle' setting", 400
+
+    playlist_db.createPlaylistForTag(tag.encode(),
+                                     (fsroot + path.encode() for path in playlist.get('paths', [])),
+                                     playlist.get('persist', 'track').encode(),
+                                     playlist.get('shuffle', 'no').encode(),
+                                     playlist.get('name', ''))
+    return '', 204
+
+
+@webapp.route('/api/v1/playlist/<tag>', methods=['DELETE'])
+async def playlist_delete(request, tag):
+    if not is_hex(tag):
+        return 'invalid tag', 400
+    playlist_db.deletePlaylistForTag(tag.encode())
+    return '', 204
+
+
 @webapp.route('/api/v1/audiofiles', methods=['GET'])
 async def audiofiles_get(request):
-    audiofiles = set()
-    dirstack = [fsroot]
+    def directory_iterator():
+        yield '['
+        first = True
 
-    while dirstack:
-        current_dir = dirstack.pop()
-        for entry in os.ilistdir(current_dir):
-            name = entry[0]
-            type_ = entry[1]
-            current_path = current_dir + '/' + name
-            if type_ == 0x4000:
-                dirstack.append(current_path)
-            elif type_ == 0x8000:
-                if name.lower().endswith('.mp3'):
-                    audiofiles.add(current_path[len(fsroot):])
+        def make_json_str(obj):
+            nonlocal first
+            jsonpath = json.dumps(obj)
+            if not first:
+                jsonpath = ',' + jsonpath
+            first = False
+            return jsonpath
 
-    return sorted(audiofiles)
+        dirstack = [fsroot]
+        while dirstack:
+            current_dir = dirstack.pop()
+            for entry in os.ilistdir(current_dir):
+                name = entry[0]
+                type_ = entry[1]
+                current_path = current_dir + b'/' + name
+                if type_ == 0x4000:
+                    yield make_json_str({'name': current_path[len(fsroot):], 'type': 'directory'})
+                    dirstack.append(current_path)
+                elif type_ == 0x8000:
+                    if name.lower().endswith('.mp3'):
+                        yield make_json_str({'name': current_path[len(fsroot):], 'type': 'file'})
+        yield ']'
+
+    return directory_iterator(), {'Content-Type': 'application/json; charset=UTF-8'}
+
+
+async def stream_to_file(stream, file_, length):
+    data = array('b', range(4096))
+    bytes_copied = 0
+    while True:
+        bytes_read = await stream.readinto(data)
+        if bytes_read == 0:
+            # End of body
+            break
+        bytes_written = file_.write(data[:bytes_read])
+        if bytes_written != bytes_read:
+            # short writes shouldn't happen
+            raise OSError(errno.EIO, 'unexpected short write')
+        bytes_copied += bytes_written
+        if bytes_copied == length:
+            break
+        app.reset_idle_timeout()
+    return bytes_copied
+
+
+@webapp.route('/api/v1/audiofiles', methods=['POST'])
+async def audiofile_upload(request):
+    if 'type' not in request.args or request.args['type'] not in ['file', 'directory']:
+        return 'invalid or missing type', 400
+    if 'location' not in request.args:
+        return 'missing location', 400
+    path = fsroot + '/' + request.args['location']
+    type_ = request.args['type']
+    length = request.content_length
+    print(f'Got upload request of type {type_} to {path} with length {length}')
+    if type_ == 'directory':
+        if length != 0:
+            return 'directory request may not have content', 400
+        try:
+            os.mkdir(path)
+        except OSError as ex:
+            return f'error creating directory: {ex}', 500
+        return '', 204
+    try:
+        with open(path, 'wb') as newfile:
+            if length > Request.max_body_length:
+                bytes_copied = await stream_to_file(request.stream, newfile, length)
+            else:
+                bytes_copied = newfile.write(request.body)
+    except OSError as ex:
+        return f'error writing data to file: {ex}', 500
+    if bytes_copied == length:
+        return '', 204
+    else:
+        return 'size mismatch', 500
+
+
+def recursive_delete(path):
+    stat = os.stat(path)
+    if stat[0] == 0x8000:
+        os.remove(path)
+    elif stat[0] == 0x4000:
+        for entry in os.ilistdir(path):
+            entry_path = path + '/' + entry[0]
+            recursive_delete(entry_path)
+        os.rmdir(path)
+
+
+@webapp.route('/api/v1/audiofiles', methods=['DELETE'])
+async def audiofile_delete(request):
+    if 'location' not in request.args:
+        return 'missing location', 400
+    location = request.args['location']
+    if '..' in location or len(location) == 0:
+        return 'bad location', 400
+    path = fsroot + '/' + request.args['location']
+    recursive_delete(path)
+    return '', 204
+
+
+@webapp.route('/api/v1/reboot/<method>', methods=['POST'])
+async def reboot(request, method):
+    if method == 'bootloader':
+        if hwconfig.get_on_battery():
+            return 'not possible: connect USB first', 403
+        leds.set_state(LedManager.REBOOTING)
+        timer_manager.schedule(time.ticks_ms() + 1500, machine.bootloader)
+    elif method == 'application':
+        leds.set_state(LedManager.REBOOTING)
+        timer_manager.schedule(time.ticks_ms() + 1500, machine.reset)
+    else:
+        return 'method not supported', 400
+    return '', 204
+
+
+@webapp.route('/api/v1/info', methods=['GET'])
+async def get_info(request):
+    mac = ubinascii.hexlify(network.WLAN().config('mac'), ':').decode()
+    return {'version': board.version,
+            'mac': mac}

software/tests/test_playerapp.py

@@ -136,6 +136,15 @@ class FakeConfig:
     def get_tag_timeout(self):
         return 5
 
+    def get_tagmode(self):
+        return 'tagremains'
+
+    def get_volume_max(self):
+        return 255
+
+    def get_volume_boot(self):
+        return 16
+
 
 def fake_open(filename, mode):
     return FakeFile(filename, mode)
@@ -164,7 +173,7 @@ def test_construct_app(micropythonify, faketimermanager):
     deps = _makedeps(mp3player=fake_mp3)
     dut = app.PlayerApp(deps)
     fake_mp3 = dut.player
-    assert fake_mp3.volume is not None
+    assert fake_mp3.volume is not None and fake_mp3.volume >= 16
 
 
 def test_load_playlist_on_tag(micropythonify, faketimermanager, monkeypatch):
@@ -226,18 +235,16 @@ def test_playlist_unknown_tag(micropythonify, faketimermanager, monkeypatch):
 
 
 def test_tagmode_startstop(micropythonify, faketimermanager, monkeypatch):
-    class MyFakePlaylistDb(FakePlaylistDb):
-        def __init__(self, tracklist=[b'test/path.mp3']):
-            super().__init__(tracklist)
+    class FakeStartStopConfig(FakeConfig):
+        def __init__(self):
+            super().__init__()
 
-        def getSetting(self, key: bytes | str):
-            if key == 'tagmode':
-                return 'tagstartstop'
-            return None
+        def get_tagmode(self):
+            return 'tagstartstop'
 
-    fake_db = MyFakePlaylistDb()
+    fake_db = FakePlaylistDb([b'test/path.mp3'])
     fake_mp3 = FakeMp3Player()
-    deps = _makedeps(mp3player=fake_mp3, playlistdb=fake_db)
+    deps = _makedeps(mp3player=fake_mp3, playlistdb=fake_db, config=FakeStartStopConfig)
     app.PlayerApp(deps)
     with monkeypatch.context() as m:
         m.setattr(builtins, 'open', fake_open)
@@ -264,16 +271,7 @@ def test_tagmode_startstop(micropythonify, faketimermanager, monkeypatch):
 
 
 def test_tagmode_remains(micropythonify, faketimermanager, monkeypatch):
-    class MyFakePlaylistDb(FakePlaylistDb):
-        def __init__(self, tracklist=[b'test/path.mp3']):
-            super().__init__(tracklist)
-
-        def getSetting(self, key: bytes | str):
-            if key == 'tagmode':
-                return 'tagremains'
-            return None
-
-    fake_db = MyFakePlaylistDb()
+    fake_db = FakePlaylistDb([b'test/path.mp3'])
     fake_mp3 = FakeMp3Player()
     deps = _makedeps(mp3player=fake_mp3, playlistdb=fake_db)
     app.PlayerApp(deps)