boneIO 1.4.2__tar.gz → 1.4.4__tar.gz

{boneio-1.4.2/boneio.egg-info → boneio-1.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boneio
-Version: 1.4.2
+Version: 1.4.4
 Summary: Python App for BoneIO
 Author-email: Paweł Szafer <pszafer@gmail.com>
 License: GNU General Public License v3.0

{boneio-1.4.2 → boneio-1.4.4}/boneio/components/input/detectors.py

@@ -467,7 +467,7 @@ class MultiClickDetector:
         if event.event_type is event.Type.FALLING_EDGE:
             # Button pressed (FALLING_EDGE on BeagleBone with pull-up)
             
-            # Software debounce
+            # Software debounce (press-vs-press)
             if self._state.last_press_ts and (timestamp_s - self._state.last_press_ts) < self._debounce_seconds:
                 delta_ms = (timestamp_s - self._state.last_press_ts) * 1000
                 _LOGGER.debug(
@@ -478,6 +478,19 @@ class MultiClickDetector:
                 )
                 return
 
+            # Cross-debounce: ignore press too close to release (bounce on falling edge
+            # after a real release). Without this, releasing a long-held button can
+            # generate a bounce FALLING that starts a new phantom press cycle.
+            if self._state.last_release_ts and (timestamp_s - self._state.last_release_ts) < self._debounce_seconds:
+                delta_ms = (timestamp_s - self._state.last_release_ts) * 1000
+                _LOGGER.debug(
+                    "Ignoring bounced press on %s (%.3f ms since release, debounce %.3f ms)",
+                    self._name,
+                    delta_ms,
+                    self._debounce_seconds * 1000,
+                )
+                return
+
             _LOGGER.debug("PRESSED: %s (%s)", self._name, self._pin)
             self._state.last_press_ts = timestamp_s
             self._state.last_press_loop_ts = self._loop.time()  # Store loop time for duration calc
@@ -618,13 +631,20 @@ class MultiClickDetector:
         timestamp_s = time.time()
 
         if is_pressed:
-            # Debounce
+            # Debounce (press-vs-press)
             if (
                 self._state.last_press_ts
                 and (timestamp_s - self._state.last_press_ts) < self._debounce_seconds
             ):
                 return
 
+            # Cross-debounce: ignore press too close to release (bounce)
+            if (
+                self._state.last_release_ts
+                and (timestamp_s - self._state.last_release_ts) < self._debounce_seconds
+            ):
+                return
+
             _LOGGER.debug("RAW PRESSED: %s (%s)", self._name, self._pin)
             self._state.last_press_ts = timestamp_s
             self._state.last_press_loop_ts = self._loop.time()

{boneio-1.4.2 → boneio-1.4.4}/boneio/core/cloud/data/docker-compose.yaml

@@ -9,17 +9,22 @@ services:
       - ./node-red/settings.js:/data/settings.js:ro
     extra_hosts:
       - "host.docker.internal:host-gateway"
+    logging:
+      driver: json-file
+      options:
+        max-size: "5m"
+        max-file: "2"
     networks:
       - edge
   caddy:
     image: caddy:2-alpine
     restart: unless-stopped
-    hostname: ${HOSTNAME}
+    hostname: ${HOSTNAME:-boneio}
     ports:
       - "${HTTP_PORT:-8091}:80"
       - "${HTTPS_PORT:-8443}:443"
     environment:
-      - HOST_HOSTNAME=${HOSTNAME}
+      - HOST_HOSTNAME=${HOSTNAME:-boneio}
     volumes:
       - ./caddy/502.html:/srv/502.html:ro
       - ./caddy/init-certs.sh:/init-certs.sh:ro
@@ -30,6 +35,11 @@ services:
     command: ["/init-certs.sh"]
     extra_hosts:
       - "host.docker.internal:host-gateway"
+    logging:
+      driver: json-file
+      options:
+        max-size: "5m"
+        max-file: "2"
     networks:
       - edge
 

{boneio-1.4.2 → boneio-1.4.4}/boneio/migrations/assets/MANIFEST.sha256

@@ -1,19 +1,19 @@
-# BoneIO migration asset manifest
-# Format: <sha256>  <relative-path>
-# Generated by scripts/generate_manifest.py — do not edit manually
-
+98b8ed657b4f7394521c3fe6b381a01ca7114e3f31495bab709707886559316a  MANIFEST.sha256
 f2ed05c6f5934a15f12571139bdc225804f67b8c83561cc39868f7b2296d2697  docker/daemon.json
-806f93c15b304153672ed2a1783716d5867b5b8045a0e0dff270e147f7792e02  docker/nodered/docker-compose.yaml
+22dfe7d55e5ed85ea0f4149b7776b7504a12b91905701657a88840ae1208087c  docker/nodered/caddy/502.html
+3e4a91a1737ce82c6bcdbbc31fce214790c0432a608ac34de7fc4e5c58cfd550  docker/nodered/caddy/init-certs.sh
+cd90e1bcb6488669179c8e7a40a6265923e0fea045cc79d5b7559ebb309131b6  docker/nodered/docker-compose.yaml
 30467786de3a35e02f9f5049b29ec1808056814e7c2fc5e507ff4b0991cde557  docker/nodered/nginx/default.conf
 66b00c1e480113a098b90d9948284781896c943006c1a3fe882d515f63b9d3e8  docker/nodered/node-red/settings.js
 67b4d45f890f073bee66dcf6d6026bd42515d938566b90d2b2a6f7ea016f3764  journald/journald.conf
 3db75f83033d82ca229e2d3bcb7daf4a5584f65b298d834bd0ee12527ae06e22  mosquitto/boneio.conf
 3fc86895f5fd3e59d2ee2d229ff7ff7c0030752f0c4eca0bb04314ea57ac0ede  sudoers/boneio
 80e528c3a0e03a4d269bcb46db4224c8e5b6c75553b266cfc4f301b515ddcd95  systemd/boneio-oled-boot.service
-9d4f46cfe6df36ee786b4b08fccc0a4dbe8161b82bdcb74f61cde45869e20ff9  systemd/boneio.service
+df6cbd8ff2361a815917c3a24ca11ebb817fc98c9790833cb2475e0b9f4e9923  systemd/boneio-oled-shutdown.service
+455fe344a251e0162cdf26beff2a041c55340119de917675faafa06d573663c6  systemd/boneio.service
 5abbd8e37720f31d44ad59814c7ebbcfb5ae09ef32d83682dee6479f34270a31  systemd/set-hostname-once.service
 8eaea86c51a17c1bc7b68e9ea65a20b428577a0bc16793768f8dba575532e8ed  usr-local-bin/set-hostname-once.sh
 3340abd637e15bb789e20f2e7de5d95dc45d8e427689e0c62312d044cd3ad86e  usr-sbin/oled_boot_splash.py
 0537e194700c50d91295517e23bcccce9b23be740b93381dff35b510d562c6fe  usr-sbin/oled_boot_splash.sh
-700c812bcf192f8be079ae58fce45543c8f60d9a9c25ab149f8dd68786c717d7  usr-sbin/oled_msg.py
-e07152aae00b0d020ae69a69bfe2738a5f4b8768b62639516d85bbd2d808ba0a  usr-sbin/oled_msg.sh
+a95d897f49e1af2468b18a721731a6c679b3a0c54af4bb8338a5906f98898bdd  usr-sbin/oled_msg.py
+b30a474473c96ab973a442ea01bd197735a3d75f12d88129895488335bf5401c  usr-sbin/oled_msg.sh

boneio-1.4.4/boneio/migrations/assets/docker/nodered/caddy/502.html

@@ -0,0 +1,43 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>boneIO — Service Unavailable</title>
+  <style>
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
+      background: #1a1a2e;
+      color: #e0e0e0;
+      display: flex;
+      justify-content: center;
+      align-items: center;
+      min-height: 100vh;
+      margin: 0;
+    }
+    .container {
+      text-align: center;
+      padding: 2rem;
+    }
+    h1 { color: #e94560; font-size: 2rem; margin-bottom: 0.5rem; }
+    p { color: #a0a0b0; font-size: 1.1rem; }
+    .retry { margin-top: 1.5rem; }
+    .retry a {
+      color: #0f3460;
+      background: #e94560;
+      padding: 0.6rem 1.5rem;
+      border-radius: 6px;
+      text-decoration: none;
+      font-weight: 600;
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <h1>Service Unavailable</h1>
+    <p>boneIO is starting up or temporarily unavailable.</p>
+    <p>Please wait a moment and try again.</p>
+    <div class="retry"><a href="/">Retry</a></div>
+  </div>
+</body>
+</html>

boneio-1.4.4/boneio/migrations/assets/docker/nodered/caddy/init-certs.sh

@@ -0,0 +1,107 @@
+#!/bin/sh
+# Caddy init script for non-cloud mode (self-signed HTTPS only).
+# Generates a Caddyfile with HTTP and self-signed HTTPS reverse proxy
+# for boneIO and Node-RED.
+
+HOSTNAME_FILE="/data/last_hostname"
+CURRENT_HOSTNAME="${HOST_HOSTNAME:-$(cat /etc/host_hostname 2>/dev/null || hostname)}"
+
+echo "Current hostname: $CURRENT_HOSTNAME"
+echo "Mode: local (self-signed HTTPS)"
+
+# Check if hostname changed (for self-signed cert regeneration)
+if [ -f "$HOSTNAME_FILE" ]; then
+    LAST_HOSTNAME=$(cat "$HOSTNAME_FILE")
+    if [ "$LAST_HOSTNAME" != "$CURRENT_HOSTNAME" ]; then
+        echo "Hostname changed from $LAST_HOSTNAME to $CURRENT_HOSTNAME"
+        echo "Removing old self-signed certificates..."
+        rm -rf /data/caddy/certificates/local/*
+        rm -rf /data/caddy/pki/*
+        rm -rf /config/caddy/*
+    fi
+else
+    echo "First run on this device, clearing any existing certificates..."
+    rm -rf /data/caddy/certificates/local/*
+    rm -rf /data/caddy/pki/*
+    rm -rf /config/caddy/*
+fi
+
+echo "$CURRENT_HOSTNAME" > "$HOSTNAME_FILE"
+
+# Generate Caddyfile
+cat > /tmp/Caddyfile << EOF
+{
+        # Global options - empty for internal issuer
+}
+
+# HTTP - serve directly
+:80 {
+        handle_errors {
+                @502-504 expression {err.status_code} >= 502 && {err.status_code} <= 504
+                handle @502-504 {
+                        root * /srv
+                        rewrite * /502.html
+                        file_server
+                }
+        }
+
+        handle /nodered-status {
+                header Content-Type application/json
+                header X-NodeRed-Available "true"
+                header Access-Control-Expose-Headers "X-NodeRed-Available"
+                respond \`{"available": true}\` 200
+        }
+
+        handle /nodered/* {
+                reverse_proxy node-red:1880 {
+                        header_up X-Forwarded-Proto {scheme}
+                        header_down X-NodeRed-Available "true"
+                }
+        }
+
+        handle {
+                reverse_proxy host.docker.internal:8090 {
+                        header_up X-Forwarded-Proto {scheme}
+                }
+        }
+}
+
+# HTTPS with self-signed certificate (catch-all for hostname and IP access)
+https:// {
+        tls internal {
+                on_demand
+        }
+
+        handle_errors {
+                @502-504 expression {err.status_code} >= 502 && {err.status_code} <= 504
+                handle @502-504 {
+                        root * /srv
+                        rewrite * /502.html
+                        file_server
+                }
+        }
+
+        handle /nodered-status {
+                header Content-Type application/json
+                header X-NodeRed-Available "true"
+                header Access-Control-Expose-Headers "X-NodeRed-Available"
+                respond \`{"available": true}\` 200
+        }
+
+        handle /nodered/* {
+                reverse_proxy node-red:1880 {
+                        header_up X-Forwarded-Proto {scheme}
+                        header_down X-NodeRed-Available "true"
+                }
+        }
+
+        handle {
+                reverse_proxy host.docker.internal:8090 {
+                        header_up X-Forwarded-Proto {scheme}
+                }
+        }
+}
+EOF
+
+# Start Caddy with generated config
+exec caddy run --config /tmp/Caddyfile --adapter caddyfile

boneio-1.4.4/boneio/migrations/assets/docker/nodered/docker-compose.yaml

@@ -0,0 +1,47 @@
+services:
+  node-red:
+    image: nodered/node-red:4.1.2-22-minimal
+    restart: unless-stopped
+    environment:
+      TZ: Europe/Warsaw
+    volumes:
+      - ./node-red/data:/data
+      - ./node-red/settings.js:/data/settings.js:ro
+    extra_hosts:
+      - "host.docker.internal:host-gateway"
+    logging:
+      driver: json-file
+      options:
+        max-size: "5m"
+        max-file: "2"
+    networks:
+      - edge
+  caddy:
+    image: caddy:2-alpine
+    restart: unless-stopped
+    hostname: ${HOSTNAME:-boneio}
+    ports:
+      - "${HTTP_PORT:-8091}:80"
+      - "${HTTPS_PORT:-8443}:443"
+    environment:
+      - HOST_HOSTNAME=${HOSTNAME:-boneio}
+    volumes:
+      - ./caddy/502.html:/srv/502.html:ro
+      - ./caddy/init-certs.sh:/init-certs.sh:ro
+      - ./caddy/data:/data
+      - ./caddy/config:/config
+      - /etc/hostname:/etc/host_hostname:ro
+    entrypoint: /bin/sh
+    command: ["/init-certs.sh"]
+    extra_hosts:
+      - "host.docker.internal:host-gateway"
+    logging:
+      driver: json-file
+      options:
+        max-size: "5m"
+        max-file: "2"
+    networks:
+      - edge
+
+networks:
+  edge:

boneio-1.4.4/boneio/migrations/assets/systemd/boneio-oled-shutdown.service

@@ -0,0 +1,12 @@
+[Unit]
+Description=OLED shutdown message (runs after network is down)
+DefaultDependencies=no
+Before=final.target
+After=network.target
+
+[Service]
+Type=oneshot
+ExecStart=/usr/sbin/oled_msg.sh "boneIO Black" "System stopped." "Safe to unplug."
+
+[Install]
+WantedBy=final.target

{boneio-1.4.2 → boneio-1.4.4}/boneio/migrations/assets/systemd/boneio.service

@@ -6,7 +6,7 @@ After=multi-user.target network.target boneio-oled-boot.service
 Type=simple
 ExecStartPre=-/usr/sbin/oled_msg.sh "boneIO Black" "is starting..." "Please wait..."
 ExecStart=${BONEIO_HOME}/boneio/venv/bin/boneio run -c ${BONEIO_HOME}/boneio/config.yaml
-ExecStopPost=/usr/sbin/oled_msg.sh "boneIO Black" "has stopped."
+ExecStopPost=-/bin/sh -c 'if ! systemctl is-system-running --quiet 2>/dev/null; then /usr/sbin/oled_msg.sh "boneIO Black" "Shutting down..."; fi'
 User=${BONEIO_USER}
 Restart=always
 RestartSec=3

boneio-1.4.4/boneio/migrations/assets/usr-sbin/oled_msg.py

@@ -0,0 +1,255 @@
+#!/usr/bin/env python3
+"""Display a centered message on optional SH1106 OLED.
+
+Supports two modes:
+  - Direct:  oled_msg.py "Line 1" "Line 2"   — one-shot render (slow, flickers)
+  - Daemon:  oled_msg.py --serve              — keeps luma in memory, reads
+             commands from /tmp/.oled_fifo (fast, no flicker)
+
+When the daemon is running, direct calls detect it and send messages
+through the FIFO instead of re-initializing luma.
+
+This script is safe to call when no OLED is connected or dependencies are
+missing: it exits quietly with code 0.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+
+_FIFO_PATH = "/tmp/.oled_fifo"
+_PID_PATH = "/tmp/.oled_serve.pid"
+
+
+def _fast_clear_oled() -> None:
+    """Clear OLED display via raw I2C before slow luma init.
+
+    On soft-reboot the SH1106 retains the previous image. Luma's sh1106()
+    constructor takes ~9 seconds (device enumeration, contrast setup, etc.).
+    This function clears the display in ~50ms using raw smbus2 writes,
+    so the stale image disappears almost instantly at boot.
+    """
+    try:
+        import smbus2
+
+        bus = smbus2.SMBus(2)
+        addr = 0x3C
+        # SH1106 init: display on, set page addressing
+        for cmd in [
+            0xAE,
+            0xD5,
+            0x80,
+            0xA8,
+            0x3F,
+            0xD3,
+            0x00,
+            0x40,
+            0xAD,
+            0x8B,
+            0xA1,
+            0xC8,
+            0xDA,
+            0x12,
+            0x81,
+            0xFF,
+            0xD9,
+            0x1F,
+            0xDB,
+            0x40,
+            0xA6,
+            0xAF,
+        ]:
+            bus.write_byte_data(addr, 0x00, cmd)
+        # Clear all 8 pages (128 columns each)
+        blank = [0x00] * 128
+        for page in range(8):
+            bus.write_byte_data(addr, 0x00, 0xB0 | page)  # set page
+            bus.write_byte_data(addr, 0x00, 0x02)  # low col (offset 2 for SH1106)
+            bus.write_byte_data(addr, 0x00, 0x10)  # high col
+            # Write in chunks of 32 (smbus limit)
+            for i in range(0, 128, 32):
+                bus.write_i2c_block_data(addr, 0x40, blank[i : i + 32])
+        bus.close()
+    except Exception:
+        pass  # No OLED or smbus2 not available — ignore
+
+
+def _is_daemon_running() -> bool:
+    """Check if the oled_msg daemon is running.
+
+    Returns:
+        True if daemon PID file exists and process is alive.
+    """
+    try:
+        with open(_PID_PATH) as f:
+            pid = int(f.read().strip())
+        os.kill(pid, 0)  # Check if process exists
+        return True
+    except (FileNotFoundError, ValueError, ProcessLookupError, PermissionError):
+        return False
+
+
+def _send_to_daemon(lines: list[str]) -> bool:
+    """Send a message to the running daemon via FIFO.
+
+    Args:
+        lines: List of text lines to display.
+
+    Returns:
+        True if message was sent successfully.
+    """
+    try:
+        # Open FIFO in non-blocking write to avoid hanging if daemon died
+        fd = os.open(_FIFO_PATH, os.O_WRONLY | os.O_NONBLOCK)
+        msg = "|".join(lines) + "\n"
+        os.write(fd, msg.encode())
+        os.close(fd)
+        return True
+    except (OSError, BrokenPipeError):
+        return False
+
+
+def _draw(device, font, lines: list[str]) -> None:
+    """Draw centered text lines on the OLED.
+
+    Args:
+        device: luma sh1106 device instance.
+        font: PIL ImageFont instance.
+        lines: List of 1-4 text strings to display.
+    """
+    from luma.core.render import canvas
+
+    with canvas(device) as draw:
+        if len(lines) == 1:
+            positions = [(20, 26)]
+        elif len(lines) == 2:
+            positions = [(12, 20), (12, 36)]
+        elif len(lines) == 3:
+            positions = [(8, 12), (8, 28), (8, 44)]
+        else:
+            positions = [(4, 4), (4, 18), (4, 32), (4, 46)]
+        for index, line in enumerate(lines):
+            draw.text(positions[index], line[:24], font=font, fill="white")
+
+
+def _serve() -> int:
+    """Run as a daemon: initialize luma once, then listen on FIFO for commands.
+
+    Message format on FIFO: "Line 1|Line 2|Line 3\\n"
+    Special messages: "clear\\n" to clear display, "quit\\n" to stop daemon.
+
+    Returns:
+        Exit code.
+    """
+    _fast_clear_oled()
+
+    try:
+        from luma.core.interface.serial import i2c
+        from luma.oled.device import sh1106
+        from PIL import ImageFont
+    except Exception:
+        return 0
+
+    try:
+        serial = i2c(port=2, address=0x3C)
+        device = sh1106(serial)
+        device.persist = True
+        font = ImageFont.load_default()
+    except Exception:
+        return 0
+
+    # Create FIFO
+    try:
+        os.unlink(_FIFO_PATH)
+    except FileNotFoundError:
+        pass
+    os.mkfifo(_FIFO_PATH)
+
+    # Write PID file
+    with open(_PID_PATH, "w") as f:
+        f.write(str(os.getpid()))
+
+    try:
+        while True:
+            # Open FIFO — blocks until a writer connects
+            with open(_FIFO_PATH) as fifo:
+                for raw_line in fifo:
+                    msg = raw_line.strip()
+                    if not msg:
+                        continue
+                    if msg == "quit":
+                        return 0
+                    if msg == "clear":
+                        _fast_clear_oled()
+                        continue
+                    lines = msg.split("|")
+                    _draw(device, font, lines)
+    except KeyboardInterrupt:
+        pass
+    finally:
+        try:
+            os.unlink(_FIFO_PATH)
+        except FileNotFoundError:
+            pass
+        try:
+            os.unlink(_PID_PATH)
+        except FileNotFoundError:
+            pass
+
+    return 0
+
+
+def main(argv: list[str]) -> int:
+    """Display a centered message on optional SH1106 OLED.
+
+    If --serve is passed, runs as a daemon listening on a FIFO.
+    Otherwise, sends message to daemon if running, or falls back
+    to direct luma rendering.
+
+    Args:
+        argv: Command-line arguments.
+
+    Returns:
+        Exit code (always 0).
+    """
+    if len(argv) > 1 and argv[1] == "--serve":
+        return _serve()
+
+    lines = [line[:24] for line in argv[1:5] if line]
+    if not lines:
+        return 0
+
+    # Try sending to daemon first (fast path — no Python init overhead)
+    if _is_daemon_running() and _send_to_daemon(lines):
+        return 0
+
+    # Fallback: direct rendering (slow but always works)
+    _fast_clear_oled()
+
+    try:
+        from luma.core.error import DeviceNotFoundError
+        from luma.core.interface.serial import i2c
+        from luma.oled.device import sh1106
+        from PIL import ImageFont
+    except Exception:
+        return 0
+
+    try:
+        serial = i2c(port=2, address=0x3C)
+        device = sh1106(serial)
+        device.persist = True
+    except (DeviceNotFoundError, OSError, Exception):
+        return 0
+
+    try:
+        _draw(device, ImageFont.load_default(), lines)
+    except Exception:
+        return 0
+
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(sys.argv))
+

boneio-1.4.4/boneio/migrations/assets/usr-sbin/oled_msg.sh

@@ -0,0 +1,55 @@
+#!/bin/bash
+# oled_msg.sh — wrapper for optional Python SH1106 renderer
+# Usage: oled_msg.sh "Line 1" ["Line 2"] ["Line 3"] ["Line 4"]
+#        oled_msg.sh --serve    # start daemon (keeps luma in memory)
+#        oled_msg.sh --stop     # stop daemon
+#        oled_msg.sh clear      # clear display
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PYTHON_RENDERER="${SCRIPT_DIR}/oled_msg.py"
+VENV_PYTHON="/home/boneio/boneio/venv/bin/python3"
+OLED_FIFO="/tmp/.oled_fifo"
+OLED_PID="/tmp/.oled_serve.pid"
+
+if [ ! -f "${PYTHON_RENDERER}" ]; then
+    exit 0
+fi
+
+# Pick the right Python
+PYTHON=""
+if [ -x "${VENV_PYTHON}" ]; then
+    PYTHON="${VENV_PYTHON}"
+elif command -v python3 >/dev/null 2>&1; then
+    PYTHON="python3"
+else
+    exit 0
+fi
+
+# Handle --serve: start daemon in background
+if [ "$1" = "--serve" ]; then
+    "${PYTHON}" "${PYTHON_RENDERER}" --serve 2>/dev/null &
+    # Wait briefly for FIFO to be created
+    for i in $(seq 1 20); do
+        [ -p "$OLED_FIFO" ] && break
+        sleep 0.1
+    done
+    exit 0
+fi
+
+# Handle --stop: send quit command to daemon
+if [ "$1" = "--stop" ]; then
+    if [ -p "$OLED_FIFO" ]; then
+        echo "quit" > "$OLED_FIFO" 2>/dev/null || true
+    fi
+    exit 0
+fi
+
+# Normal message: try FIFO (fast), fallback to direct call
+if [ -p "$OLED_FIFO" ] && [ -f "$OLED_PID" ]; then
+    # Daemon is running — send via FIFO (instant, no Python startup)
+    MSG=$(IFS='|'; echo "$*")
+    echo "$MSG" > "$OLED_FIFO" 2>/dev/null && exit 0
+fi
+
+# Fallback: direct Python call
+"${PYTHON}" "${PYTHON_RENDERER}" "$@" 2>/dev/null || true