tinyjukebox 0.47.0__py3-none-any.whl

tinyjukebox/devices/drivers/rfid.py

@@ -0,0 +1,297 @@
+"""RFID reader RC522 - publishes the tag that the helper program ``rfid-reader`` reports."""
+
+import logging
+import os
+import re
+import selectors
+import subprocess
+import threading
+import time
+from collections.abc import Mapping
+from typing import Any
+
+from tinyjukebox.core.pubsub import PubSubClient
+from tinyjukebox.core.threads import LoggerThread
+from tinyjukebox.devices.baseclasses.adriver import ADriver
+from tinyjukebox.devices.schema.rfid import SPI_PINS, get_schema
+from tinyjukebox.messages import RFID_POLL, RFID_STATE, RfidState
+
+__all__ = ["RFID"]
+
+DEFAULT_COMMAND = ["sudo", "-n", "/usr/local/bin/rfid-reader"]
+"""``rfid-reader`` needs root (bcm2835 maps the SPI registers via /dev/mem) - tinyjukebox itself does not."""
+
+RESTART_INTERVAL = 5.0  # seconds until rfid-reader is started again after it has ended
+STOP_TIMEOUT = 2.0  # seconds rfid-reader gets to end after SIGTERM
+ALIVE_INTERVAL = 10.0  # seconds between two "alive" of rfid-reader - its default (option --alive)
+ALIVE_TIMEOUT = 3  # intervals without any line until rfid-reader counts as stuck
+READ_TIMEOUT = 0.1  # seconds the thread waits for output before it looks at the stop and the watchdog again
+MAX_SAID = 100  # messages of rfid-reader that are remembered as logged until it works
+
+_READY = "ready"
+_REMOVED = "removed"
+_ALIVE = "alive"
+_TAG = re.compile(r"tag ([0-9A-F]{2}(?::[0-9A-F]{2})*)")
+
+
+class RFID(ADriver):
+    """Driver for the RC522 RFID reader.
+
+    The reader is not read by this process: the driver starts the helper program ``rfid-reader`` (C++,
+    ``cpp/rfid-reader`` of the repository) and reads its output - one line per change::
+
+        ready                      the reader is initialized, no tag has been seen yet
+        tag 04:1A:2B:3C:4D:5E:6F   a tag has been placed (its complete uid, 4 or 7 bytes)
+        removed                    the tag has been removed
+        alive                      the program still runs (at its start, then every 10 s)
+
+    ``rfid-reader`` is the read loop of the old box (rfid-2-mqtt): only there the presence detection of the RC522
+    has proven itself. Every change of the tag is published as :class:`~tinyjukebox.messages.RfidState` to
+    :data:`~tinyjukebox.messages.RFID_STATE`; a message on :data:`~tinyjukebox.messages.RFID_POLL` publishes the current
+    state in any case.
+
+    If ``rfid-reader`` cannot be started or ends, the state is "no tag" (published if a tag was there) and it is
+    started again every :data:`RESTART_INTERVAL` seconds. A program that has written ``alive`` once and then nothing
+    for :data:`ALIVE_TIMEOUT` intervals is stuck: the driver ends it and starts it again the same way. A program that
+    never writes ``alive`` is never ended.
+
+    Example::
+
+        driver:
+            type: rfid
+            pins:               # BCM numbers
+                pin_rst: 26
+                pin_cs: 8       # SPI0 CE0
+            command: [sudo, -n, /usr/local/bin/rfid-reader]   # optional - this is the default
+    """
+
+    restart_interval = RESTART_INTERVAL
+    stop_timeout = STOP_TIMEOUT
+    alive_interval = ALIVE_INTERVAL
+
+    def __init__(
+        self,
+        config: Mapping[str, Any],
+        pubsub_client: PubSubClient,
+        logger: logging.Logger,
+    ) -> None:
+        ADriver.__init__(self, config, pubsub_client, logger)
+
+        pins = self._config["pins"]
+        _check_pins(pins["pin_rst"], pins["pin_cs"])
+        self._command = [
+            *self._config.get("command", DEFAULT_COMMAND),
+            "--pin-rst",
+            str(pins["pin_rst"]),
+            "--pin-cs",
+            str(pins["pin_cs"]),
+        ]
+        self._lock = threading.RLock()  # the reader thread and the handler of RFID_POLL publish the state
+        self._uid: str | None = None
+        self._error: str | None = "rfid-reader has not been started"
+        self._published = False
+        self._changed_at: float | None = None  # when the uid or the error changed last (time.time())
+        self._process: subprocess.Popen[bytes] | None = None
+        self._stop_reader = threading.Event()  # one per start: a thread of an earlier start sees its own
+        self._thread: LoggerThread | None = None
+        self._said: set[str] = set()  # messages logged as warning since rfid-reader worked last (only its thread)
+
+    # --- state ----------------------------------------------------------------------------------------------------
+
+    def _set_state(self, uid: str | None, error: str | None = None) -> None:
+        """Publish the state if the uid has changed (the first state is always published), with the error of that
+        moment. An error that comes or goes while the uid stays is in :meth:`state` only: ``STMOperation`` takes every
+        ``None`` for "no tag", and a tag placed on the web page must not end because rfid-reader starts again."""
+        with self._lock:
+            changed = uid != self._uid or not self._published
+            if changed or error != self._error:
+                self._changed_at = time.time()
+            self._uid, self._error = uid, error
+            if changed:
+                self._publish()
+
+    def _publish(self) -> None:
+        with self._lock:
+            self._published = True
+            self._publish_value(RFID_STATE, RfidState(self._uid, self._error))
+
+    def _poll_handler(self, message: object) -> None:
+        """Handler for :data:`~tinyjukebox.messages.RFID_POLL`: publish the current state in any case."""
+        self._publish()
+
+    def _process_line(self, line: str) -> None:
+        tag = _TAG.fullmatch(line)
+        if line in (_READY, _REMOVED) or tag is not None:
+            self._said.clear()  # rfid-reader works: a message is news again
+        if tag is not None:
+            self._set_state(tag.group(1))
+        elif line == _REMOVED:
+            self._set_state(None)
+        elif line == _READY:
+            self._logger.info("RFID - rfid-reader is ready")
+            self._set_state(None)
+        elif line and line != _ALIVE:
+            # everything else is a message of rfid-reader, of its launcher or of sudo (stderr is read as well). One that
+            # comes with every start - e.g. the launcher refuses the program of the slot - is a warning once
+            level = logging.DEBUG if line in self._said else logging.WARNING
+            if len(self._said) >= MAX_SAID:
+                self._said.clear()
+            self._said.add(line)
+            self._logger.log(level, "RFID - rfid-reader: %s", line)
+
+    def _reader_runs(self) -> bool:
+        with self._lock:
+            return self._process is not None and self._process.poll() is None
+
+    def _driver_state(self) -> dict[str, Any]:
+        """``reader``: rfid-reader runs; ``error``: why it does not (``None`` while it runs)."""
+        with self._lock:
+            return {
+                "pins": dict(self._config["pins"]),
+                "reader": self._reader_runs(),
+                "uid": self._uid,
+                "error": self._error,
+                "changed_at": self._changed_at,
+            }
+
+    # --- rfid-reader ----------------------------------------------------------------------------------------------
+
+    def _read(self, stop: threading.Event) -> str:
+        """Start rfid-reader and process its lines until it ends - returns the reason of the end. rfid-reader has
+        ended when this returns, also if processing a line fails."""
+        with self._lock:
+            if stop.is_set():
+                return "stopped"
+            try:
+                process = subprocess.Popen(
+                    self._command,
+                    stdin=subprocess.DEVNULL,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.STDOUT,
+                    bufsize=0,
+                )
+            except OSError as e:
+                return f"cannot start {self._command[0]}: {e}"
+            self._process = process
+        ended = False
+        reason = None
+        try:
+            reason = self._read_lines(process, stop)
+            ended = reason is None
+        finally:
+            returncode = self._end(process, ended)
+            with self._lock:
+                self._process = None
+        return reason or f"rfid-reader has ended (exit code {returncode})"
+
+    def _read_lines(self, process: subprocess.Popen[bytes], stop: threading.Event) -> str | None:
+        """Process the lines of rfid-reader until its output ends (``None``), the driver stops (``"stopped"``) or the
+        program is stuck (the reason). The pipe is read in pieces with a timeout, so the thread never blocks: a reader
+        that outlives its ``sudo`` keeps the pipe open."""
+        assert process.stdout is not None  # noqa: S101 - stdout=PIPE
+        fd = process.stdout.fileno()
+        rest = b""
+        heard: float | None = None  # when rfid-reader wrote last - from its first "alive" on: the watchdog is armed
+        timeout = ALIVE_TIMEOUT * self.alive_interval
+        with selectors.DefaultSelector() as selector:
+            selector.register(fd, selectors.EVENT_READ)
+            while not stop.is_set():
+                if not selector.select(READ_TIMEOUT):
+                    if heard is not None and time.monotonic() - heard > timeout:
+                        return f"rfid-reader is stuck: no output for {timeout:g} s"
+                    continue
+                data = os.read(fd, 4096)
+                if not data:
+                    if rest:
+                        self._process_line(rest.decode(errors="replace").strip())
+                    return None
+                *lines, rest = (rest + data).split(b"\n")
+                for raw in lines:
+                    line = raw.decode(errors="replace").strip()
+                    if heard is not None or line == _ALIVE:
+                        heard = time.monotonic()
+                    self._process_line(line)
+        return "stopped"
+
+    def _end(self, process: subprocess.Popen[bytes], ended: bool) -> int:
+        """Close the pipe and end rfid-reader - SIGTERM unless its output has ``ended`` already, SIGKILL if it has not
+        ended after :attr:`stop_timeout` - and return its exit code.
+
+        ``sudo`` passes SIGTERM on to rfid-reader, SIGKILL reaches only ``sudo``: a reader that is left behind then ends
+        by itself once nobody reads its output - the pipe is therefore closed first."""
+        assert process.stdout is not None  # noqa: S101 - stdout=PIPE
+        process.stdout.close()
+        steps = [process.terminate, process.kill]
+        if ended:
+            steps.insert(0, lambda: None)  # its output has ended: it is ending by itself - give it the time first
+        for step in steps:
+            step()
+            try:
+                return process.wait(self.stop_timeout)
+            except subprocess.TimeoutExpired:
+                pass
+        return process.wait()
+
+    def _run(self, stop: threading.Event, previous: threading.Thread | None) -> None:
+        if previous is not None:
+            previous.join()  # the thread of the last start ends its rfid-reader first - two would disturb each other
+        failure = None
+        while not stop.is_set():
+            reason = self._read(stop)
+            if stop.is_set():
+                break
+            with self._lock:
+                worked = self._error is None  # rfid-reader has reported in between: the same reason is news again
+            level = logging.DEBUG if reason == failure and not worked else logging.ERROR  # a repeated reason only once
+            failure = reason
+            self._logger.log(
+                level,
+                "RFID - %s (%s) - trying again every %s s",
+                reason,
+                " ".join(self._command),
+                self.restart_interval,
+            )
+            self._set_state(None, reason)
+            stop.wait(self.restart_interval)
+
+    # --- life cycle -----------------------------------------------------------------------------------------------
+
+    def healthy(self) -> bool:
+        """The driver runs, and so does rfid-reader, the program that reads the tags."""
+        return bool(self.is_started) and self._reader_runs()
+
+    def _driver_start(self) -> None:
+        previous = self._thread if self._thread is not None and self._thread.is_alive() else None
+        self._stop_reader = threading.Event()
+        self._published = False
+        self._thread = LoggerThread(
+            target=self._run, args=(self._stop_reader, previous), name="rfid", logger=self._logger, daemon=True
+        )
+        self._thread.start()
+        self._pubsub_client.subscribe(RFID_POLL, self._poll_handler)
+
+    def _driver_stop(self) -> None:
+        # (ignore_not_found: also after a start that failed)
+        self._pubsub_client.unsubscribe(RFID_POLL, self._poll_handler, ignore_not_found=True)
+        self._stop_reader.set()
+        thread = self._thread
+        if thread is not None:
+            # the thread ends rfid-reader (SIGTERM, SIGKILL after stop_timeout) and closes its end of the pipe. If it
+            # takes longer, it is kept: the next start waits for it before it starts another rfid-reader
+            thread.join(2 * self.stop_timeout + 2 * READ_TIMEOUT)
+            if not thread.is_alive():
+                self._thread = None
+
+    @classmethod
+    def _get_schema(cls) -> dict[str, Any]:
+        return get_schema()
+
+
+def _check_pins(pin_rst: int, pin_cs: int) -> None:
+    """The pins of rfid-reader: two different ones, none of the data and clock lines of SPI0 (the schema checks
+    those too). :raises ValueError: otherwise."""
+    if pin_rst == pin_cs:
+        raise ValueError(f"rfid: pin_rst and pin_cs must be two different pins (both are {pin_rst}).")
+    for name, pin in (("pin_rst", pin_rst), ("pin_cs", pin_cs)):
+        if pin in SPI_PINS:
+            raise ValueError(f"rfid: {name} must not be {pin} - GPIO 9, 10, 11 are MISO, MOSI and SCLK of SPI0.")

tinyjukebox/devices/drivers/rgbled.py

@@ -0,0 +1,215 @@
+"""RGB LED with three GPIO outputs: static colors and blinking between two colors."""
+
+import logging
+import threading
+from collections.abc import Mapping
+from typing import Any
+
+from RPi import GPIO
+
+from tinyjukebox.core.pubsub import PubSubClient
+from tinyjukebox.core.threads import LoggerThread
+from tinyjukebox.core.ui.tools import parse
+from tinyjukebox.devices.baseclasses.adriver import ADriver
+from tinyjukebox.devices.baseclasses.gpiolevel import closed_level
+from tinyjukebox.devices.schema.rgbled import COLOR_NAMES, get_schema
+from tinyjukebox.messages import LED, RGB, Color, LedPattern
+
+__all__ = ["RGBLed"]
+
+
+class RGBLed(ADriver):
+    """RGB LED on three GPIO outputs, shows the :class:`~tinyjukebox.messages.LedPattern` of the messages on
+    :data:`~tinyjukebox.messages.LED`: one color or alternating colors.
+
+    Blinking starts with ``color_a`` and runs in a separate thread until the next command.
+
+    Example::
+
+        driver:
+            type: rgbled
+            pin-red: 21
+            pin-green: 22
+            pin-blue: 23
+            initial-color: GREEN
+            physical-closed-red: high     # level that switches the color on (low/high)
+            physical-closed-green: high
+            physical-closed-blue: high
+    """
+
+    def __init__(
+        self,
+        config: Mapping[str, Any],
+        pubsub_client: PubSubClient,
+        logger: logging.Logger,
+    ) -> None:
+        super().__init__(config, pubsub_client, logger)
+        self._pins = tuple(int(self._config[f"pin-{color}"]) for color in ("red", "green", "blue"))
+        self._closed_levels = tuple(
+            closed_level(self._config[f"physical-closed-{color}"], f"physical-closed-{color}")
+            for color in ("red", "green", "blue")
+        )
+        self._initial_color = Color[self._config["initial-color"]]
+
+        self._pattern_lock = threading.Lock()
+        self._shows = False  # patterns only between _driver_start and _driver_stop (guarded by _pattern_lock)
+        self._blink_stop = threading.Event()
+        self._blink_thread: LoggerThread | None = None
+        self._pattern = LedPattern.static(self._initial_color)
+
+        self._add_ui_command("gpio_color", self._cmd_gpio_color)
+        self._add_ui_command("gpio_rgb", self._cmd_gpio_rgb)
+        self._add_ui_command("gpio_blink", self._cmd_gpio_blink)
+        self._add_ui_command("gpio_state", self._cmd_gpio_state)
+
+    @property
+    def pattern(self) -> LedPattern:
+        """The pattern that is currently shown."""
+        return self._pattern
+
+    def _driver_state(self) -> dict[str, Any]:
+        """``colors``/``delays``: the pattern that is shown (a name of :class:`~tinyjukebox.messages.Color` each);
+        ``lit``: which of the three lights is on right now, read from the pins (``None``: they cannot be read)."""
+        pattern = self._pattern
+        names = ("red", "green", "blue")
+        lit: dict[str, bool] | None = None
+        if self.is_started:
+            try:
+                lit = {
+                    name: GPIO.input(pin) == closed
+                    for name, pin, closed in zip(names, self._pins, self._closed_levels, strict=True)
+                }
+            except Exception as e:  # the view must not fail with the pins
+                self._logger.debug("RGBLed._driver_state - gpios cannot be read: %s", e)
+        return {
+            "pins": dict(zip(names, self._pins, strict=True)),
+            "colors": [Color(tuple(rgb)).name for rgb in pattern.colors],
+            "delays": list(pattern.delays),
+            "lit": lit,
+        }
+
+    # --- output -------------------------------------------------------------------------------------------------
+
+    def _set_pins(self, rgb: RGB) -> None:
+        for pin, closed, on in zip(self._pins, self._closed_levels, rgb, strict=True):
+            GPIO.output(pin, closed if on else 1 - closed)
+
+    def _blink(self, pattern: LedPattern, stop: threading.Event) -> None:
+        index = 0
+        while True:
+            self._set_pins(pattern.colors[index])
+            if stop.wait(pattern.delays[index]):
+                return
+            index = (index + 1) % len(pattern.colors)
+
+    def _stop_blinking(self) -> None:
+        if self._blink_thread is not None:
+            self._blink_stop.set()
+            self._blink_thread.join()
+            self._blink_thread = None
+
+    def show(self, pattern: LedPattern) -> None:
+        """Show ``pattern`` - replaces the current pattern and returns immediately."""
+        self._logger.info("RGBLed.show - %s", pattern)
+        with self._pattern_lock:
+            if not self._shows:  # e.g. a message that is dispatched while the driver stops: its pins are released
+                self._logger.info("RGBLed.show - the driver is stopped")
+                return
+            self._stop_blinking()
+            self._pattern = pattern
+            if len(pattern.colors) == 1:
+                self._set_pins(pattern.colors[0])
+            else:
+                self._blink_stop = threading.Event()
+                self._blink_thread = LoggerThread(
+                    target=self._blink,
+                    args=(pattern, self._blink_stop),
+                    name=f"rgbled.{self._name}.blink",
+                    logger=self._logger,
+                    daemon=True,
+                )
+                self._blink_thread.start()
+
+    def _message_handler(self, message: object) -> None:
+        """Handler for :data:`~tinyjukebox.messages.LED`."""
+        self._logger.info("received message %r on topic '%s'.", message, LED)
+        if isinstance(message, LedPattern):
+            self.show(message)
+        else:
+            self._logger.warning("RGBLed._message_handler - expected a LedPattern, received %r.", message)
+
+    # --- console commands ---------------------------------------------------------------------------------------
+
+    @staticmethod
+    def _parse_color(name: str) -> Color | None:
+        return Color.__members__.get(name.upper())
+
+    def _cmd_gpio_color(self, args: str) -> None:
+        """gpio_color - sets a color (BLACK, WHITE, RED, GREEN, BLUE, YELLOW, AQUA, MAGENTA): GPIO_COLOR color"""
+        arguments = parse(args)
+        color = self._parse_color(arguments[0]) if len(arguments) == 1 else None
+        if color is None:
+            print(f"Wrong arguments: {arguments}. expected 'GPIO_COLOR [{'|'.join(COLOR_NAMES)}]'.")
+            return
+        print(f"Setting color to: {color.name}.")
+        self.show(LedPattern.static(color))
+
+    def _cmd_gpio_rgb(self, args: str) -> None:
+        """gpio_rgb - sets the rgb-led to the boolean values: GPIO_RGB Red Green Blue"""
+        arguments = [argument.lower() for argument in parse(args)]
+        if len(arguments) != 3 or any(argument not in ("true", "false") for argument in arguments):
+            print(f"Wrong arguments: {arguments}. expected 'GPIO_RGB Red Green Blue' with values True/False.")
+            return
+        red, green, blue = (argument == "true" for argument in arguments)
+        print(f"Setting rgb to: {red} {green} {blue}.")
+        self.show(LedPattern.static((red, green, blue)))
+
+    def _cmd_gpio_blink(self, args: str) -> None:
+        """gpio_blink - alternates between two colors: GPIO_BLINK color_a color_b delay [delay_b]"""
+        arguments = parse(args)
+        expected = f"GPIO_BLINK [{'|'.join(COLOR_NAMES)}] [{'|'.join(COLOR_NAMES)}] delay [delay_b]"
+        if len(arguments) not in (3, 4):
+            print(f"Wrong arguments: {arguments}. expected '{expected}'.")
+            return
+        color_a, color_b = self._parse_color(arguments[0]), self._parse_color(arguments[1])
+        try:
+            delays = [float(argument) for argument in arguments[2:]]
+        except ValueError:
+            delays = []
+        if color_a is None or color_b is None or not delays or min(delays) <= 0:
+            print(f"Wrong arguments: {arguments}. expected '{expected}' with delays > 0.")
+            return
+        pattern = LedPattern.blink(color_a, color_b, delays[0], delays[-1])
+        print(f"Setting blink to {pattern}.")
+        self.show(pattern)
+
+    def _cmd_gpio_state(self, args: str) -> None:
+        """gpio_state - reads the state of the gpios: GPIO_STATE"""
+        states = [
+            f"{name} {pin} is {'on' if GPIO.input(pin) == closed else 'off'}"
+            for name, pin, closed in zip(("red", "green", "blue"), self._pins, self._closed_levels, strict=True)
+        ]
+        print(f"[{self._name}] gpios: {', '.join(states)}.")
+
+    # --- life cycle ---------------------------------------------------------------------------------------------
+
+    def _driver_start(self) -> None:
+        GPIO.setmode(GPIO.BCM)
+        for pin in self._pins:
+            GPIO.setup(pin, GPIO.OUT)
+        with self._pattern_lock:
+            self._shows = True
+        self.show(LedPattern.static(self._initial_color))
+        self._pubsub_client.subscribe(LED, self._message_handler)
+
+    def _driver_stop(self) -> None:
+        self._pubsub_client.unsubscribe(LED, self._message_handler)
+        with self._pattern_lock:
+            self._shows = False
+            self._stop_blinking()
+        for pin in self._pins:
+            GPIO.cleanup(pin)
+
+    @classmethod
+    def _get_schema(cls) -> dict[str, Any]:
+        return get_schema()

tinyjukebox/devices/schema/__init__.py

@@ -0,0 +1 @@
+"""JSON schemas of the driver config sections."""

tinyjukebox/devices/schema/adriver.py

@@ -0,0 +1,33 @@
+"""Schema builder for the config section ``driver`` - used by the schema modules of all drivers."""
+
+from collections.abc import Mapping
+from typing import Any
+
+__all__ = ["add_schema_part", "get_schema"]
+
+
+def get_schema(driver_type: str, driver_specific_properties: Mapping[str, Any]) -> dict[str, Any]:
+    """Schema ``{"driver": {...}}`` of a driver config section.
+
+    All driver specific properties are required. Unknown keys are rejected. Topics and payloads are no config
+    entries - they are defined in :mod:`tinyjukebox.messages`.
+    """
+    driver: dict[str, Any] = {
+        "description": f"Driver configuration '{driver_type}'.",
+        "type": "object",
+        "properties": {
+            "name": {"description": "name of driver", "type": "string"},
+            "type": {"description": "type of driver", "type": "string", "enum": [driver_type]},
+        },
+        "required": ["type"],
+        "additionalProperties": False,
+    }
+    schema = {"driver": driver}
+    add_schema_part(schema, {"properties": driver_specific_properties, "required": list(driver_specific_properties)})
+    return schema
+
+
+def add_schema_part(schema: dict[str, Any], schema_part: Mapping[str, Any]) -> None:
+    """Add the ``properties`` and ``required`` entries of ``schema_part`` to ``schema["driver"]``."""
+    schema["driver"]["properties"].update(schema_part["properties"])
+    schema["driver"]["required"].extend(schema_part["required"])

tinyjukebox/devices/schema/bluetooth.py

@@ -0,0 +1,31 @@
+"""Schema of the driver ``bluetooth``."""
+
+from typing import Any
+
+from tinyjukebox.devices.schema import adriver
+
+__all__ = ["AVRCP_MODES", "get_schema"]
+
+AVRCP_MODES = ["player", "input"]
+
+
+def get_schema() -> dict[str, Any]:
+    schema = adriver.get_schema("bluetooth", {})
+    schema["driver"]["properties"].update(
+        {
+            "adapter": {"description": "bluetooth adapter (optional, default: hci0)", "type": "string"},
+            "avrcp": {
+                "description": "how the buttons of the headset arrive (optional, default: player) - player: BlueZ "
+                "calls the media player the box registers; input: BlueZ passes them to the linux input device "
+                "'<headset> (AVRCP)' (the user needs the group input)",
+                "type": "string",
+                "enum": AVRCP_MODES,
+            },
+            "play-pause-toggle": {
+                "description": "play and pause of the headset both switch between play and pause (optional, default: "
+                "false) - for headsets that send the same button for both",
+                "type": "boolean",
+            },
+        }
+    )
+    return schema

tinyjukebox/devices/schema/drivermanager.py

@@ -0,0 +1,41 @@
+"""Schema of the config section ``drivers`` (DriverManager)."""
+
+import importlib
+from typing import Any
+
+from tinyjukebox.devices.drivers import DRIVERS
+
+__all__ = ["get_driver_schema", "get_schema"]
+
+
+def get_driver_schema(driver_type: str) -> dict[str, Any]:
+    """Schema ``{"driver": {...}}`` of a single driver (from module ``tinyjukebox.devices.schema.<driver_type>``)."""
+    module = importlib.import_module(f"tinyjukebox.devices.schema.{driver_type}")
+    schema: dict[str, Any] = module.get_schema()
+    return schema
+
+
+def get_schema() -> dict[str, Any]:
+    """Schema of the list ``drivers``: each entry is a driver section plus ``name`` (required) and ``active``.
+
+    The entries are validated with ``if type == ... then ...`` instead of ``oneOf``; errors thus name the actual
+    wrong key instead of "not valid under any of the given schemas".
+    """
+    conditions = []
+    for driver_type in DRIVERS:
+        driver = get_driver_schema(driver_type)["driver"]
+        driver["properties"]["active"] = {"description": "if set to false, the driver is not loaded", "type": "boolean"}
+        driver["required"].extend(["name", "active"])
+        conditions.append({"if": {"properties": {"type": {"const": driver_type}}}, "then": driver})
+    return {
+        "drivers": {
+            "description": "Drivermanager configuration.",
+            "type": "array",
+            "items": {
+                "type": "object",
+                "properties": {"type": {"description": "type of driver", "enum": list(DRIVERS)}},
+                "required": ["type"],
+                "allOf": conditions,
+            },
+        }
+    }

tinyjukebox/devices/schema/input.py

@@ -0,0 +1,23 @@
+"""Schema of the driver ``input``."""
+
+from typing import Any
+
+from tinyjukebox.devices.schema import adriver
+from tinyjukebox.messages import Button
+
+__all__ = ["get_schema"]
+
+
+def get_schema() -> dict[str, Any]:
+    driver_specific_properties = {
+        "pin": {"description": "gpio pin", "type": "integer"},
+        "hold_timeout": {"description": "hold time in seconds until the hold event is triggered", "type": "number"},
+        "button": {"description": "which button of the box", "type": "string", "enum": [b.value for b in Button]},
+    }
+    schema = adriver.get_schema("input", driver_specific_properties)
+    schema["driver"]["properties"]["hold_repeat"] = {
+        "description": "repeat the hold event every hold_timeout seconds while the button stays pressed (optional, "
+        "default: false)",
+        "type": "boolean",
+    }
+    return schema