moat-link-gpio 0.1.0__tar.gz

moat_link_gpio-0.1.0/LICENSE.txt

@@ -0,0 +1,14 @@
+The code in this repository, and all MoaT submodules it refers to,
+is part of the MoaT project.
+
+Unless a submodule's LICENSE.txt states otherwise, all included files are
+licensed under the LGPL V3, as published by the FSF at
+https://www.gnu.org/licenses/lgpl-3.0.html .
+
+In addition to the LGPL's terms, the author(s) respectfully ask all users of
+this code to contribute any bug fixes or enhancements. Also, please link back to
+https://M-o-a-T.org.
+
+Thank you.
+
+Copyright © 2021 ff.: the MoaT contributor(s), as per the git changelog(s).

moat_link_gpio-0.1.0/PKG-INFO

@@ -0,0 +1,64 @@
+Metadata-Version: 2.4
+Name: moat-link-gpio
+Version: 0.1.0
+Summary: GPIO controller connector for MoaT-Link
+Author-email: Matthias Urlichs <matthias@urlichs.de>
+Project-URL: homepage, https://m-o-a-t.org
+Project-URL: repository, https://github.com/M-o-a-T/moat
+Keywords: MoaT
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Framework :: AsyncIO
+Classifier: Framework :: Trio
+Classifier: Framework :: AnyIO
+Classifier: Development Status :: 4 - Beta
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: anyio~=4.2
+Requires-Dist: asyncclick~=8.3
+Requires-Dist: attrs
+Requires-Dist: moat-util~=0.63.0
+Requires-Dist: moat-link~=0.10.0
+Requires-Dist: moat-lib-config~=0.2.0
+Requires-Dist: moat-lib-gpio~=0.9.4
+Dynamic: license-file
+
+# GPIO controller connector
+
+% start synopsis
+Connects MoaT-Link to GPIO lines via the moat-lib-gpio library.
+% end synopsis
+
+% start main
+
+This module bridges MoaT-Link values and GPIO controller lines, in both
+directions.  It replaces the legacy ``moat-kv-gpio`` package.
+
+## Quick start
+
+1. Configure an input line (reads GPIO and publishes to a link path):
+
+   ```shell
+   moat link gpio port myhost 0 5 -t input -m read -a dest .sensors.button
+   ```
+
+2. Configure an output line (watches a link path and drives GPIO):
+
+   ```shell
+   moat link gpio port myhost 0 3 -t output -m write -a src .controls.lamp
+   ```
+
+3. Run the connector for a chip:
+
+   ```shell
+   moat link gpio monitor myhost 0
+   ```
+
+## Deprecation
+
+This package supersedes ``moat-kv-gpio``.  The address tree now lives in
+MoaT-Link under the ``gpio`` prefix; lines are stored as integer line
+numbers below host and chip entries.
+
+% end main

moat_link_gpio-0.1.0/README.md

@@ -0,0 +1,38 @@
+# GPIO controller connector
+
+% start synopsis
+Connects MoaT-Link to GPIO lines via the moat-lib-gpio library.
+% end synopsis
+
+% start main
+
+This module bridges MoaT-Link values and GPIO controller lines, in both
+directions.  It replaces the legacy ``moat-kv-gpio`` package.
+
+## Quick start
+
+1. Configure an input line (reads GPIO and publishes to a link path):
+
+   ```shell
+   moat link gpio port myhost 0 5 -t input -m read -a dest .sensors.button
+   ```
+
+2. Configure an output line (watches a link path and drives GPIO):
+
+   ```shell
+   moat link gpio port myhost 0 3 -t output -m write -a src .controls.lamp
+   ```
+
+3. Run the connector for a chip:
+
+   ```shell
+   moat link gpio monitor myhost 0
+   ```
+
+## Deprecation
+
+This package supersedes ``moat-kv-gpio``.  The address tree now lives in
+MoaT-Link under the ``gpio`` prefix; lines are stored as integer line
+numbers below host and chip entries.
+
+% end main

moat_link_gpio-0.1.0/pyproject.toml

@@ -0,0 +1,43 @@
+[build-system]
+build-backend = "setuptools.build_meta"
+requires = [ "setuptools", "wheel",]
+
+[project]
+classifiers = [
+	"Intended Audience :: Developers",
+	"Programming Language :: Python :: 3",
+	"Framework :: AsyncIO",
+	"Framework :: Trio",
+	"Framework :: AnyIO",
+	"Development Status :: 4 - Beta",
+	]
+dependencies = [
+	"anyio ~= 4.2",
+	"asyncclick ~= 8.3",
+	"attrs",
+	"moat-util ~= 0.63.0",
+	"moat-link ~= 0.10.0",
+	"moat-lib-config ~= 0.2.0",
+	"moat-lib-gpio ~= 0.9.4",
+]
+version = "0.1.0"
+keywords = [ "MoaT",]
+requires-python = ">=3.13"
+name = "moat-link-gpio"
+description = "GPIO controller connector for MoaT-Link"
+readme = "README.md"
+
+[[project.authors]]
+name = "Matthias Urlichs"
+email = "matthias@urlichs.de"
+
+[project.urls]
+homepage = "https://m-o-a-t.org"
+repository = "https://github.com/M-o-a-T/moat"
+
+[tool.setuptools]
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+"*" = ["*.yaml"]

moat_link_gpio-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

moat_link_gpio-0.1.0/src/moat/link/gpio/__init__.py

@@ -0,0 +1,9 @@
+"""GPIO controller connector for MoaT-Link."""
+
+from __future__ import annotations
+
+from moat.lib.config import register as _register
+
+__all__: list[str] = []
+
+_register(__name__)

moat_link_gpio-0.1.0/src/moat/link/gpio/_cfg.yaml

@@ -0,0 +1,10 @@
+prefix: !P gpio
+interval: 1     # input/count: Pulse reporting frequency
+count: True     # input/count, input/button: Pulse direction
+# up down both: True False None
+low: False      # if True, the default is active-low
+flow: False     # if True, send intermediate results
+skip: True      # ignore signals < t_bounce
+t_idle: 1.5     # input/button: max pulse width
+t_clear: 30     # button: set to None after this
+t_bounce: 0.05  # input/button: min pulse width

moat_link_gpio-0.1.0/src/moat/link/gpio/_main.py

@@ -0,0 +1,188 @@
+"""
+Command-line interface for moat.link.gpio.
+
+Manages GPIO line configurations stored in the MoaT-Link data tree
+under the configured ``link.gpio.prefix``.  Each host contains chips;
+each chip contains integer-numbered lines.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import logging
+
+import asyncclick as click
+
+from moat.util import attrdict, yprint
+from moat.lib.path import P
+from moat.lib.run import AliasedGroup, attr_args
+from moat.link._data import data_get, node_attr
+from moat.link.announce import as_service
+from moat.link.client import Link
+
+logger = logging.getLogger(__name__)
+
+
+@click.group(cls=AliasedGroup, short_help="Manage GPIO controllers.")
+@click.pass_context
+async def cli(ctx):
+    """
+    Manage GPIO controllers and line configurations.
+    """
+    obj = ctx.obj
+    cfg = obj.cfg["link"]
+    obj.conn = await ctx.with_async_resource(
+        Link(cfg, common=True, only=getattr(obj, "link_name", None))
+    )
+    obj.gpio_cfg = obj.cfg.link.gpio
+    obj.gpio_prefix = obj.gpio_cfg.prefix
+
+
+@cli.command("dump")
+@click.argument("path", nargs=1, type=P)
+@click.pass_obj
+async def dump(obj, path):
+    """Emit the current state as a YAML file."""
+    if len(path) > 3:
+        raise click.UsageError("Only up to three path elements (host.chip:pin) allowed")
+
+    await data_get(obj.conn, obj.gpio_prefix + path, recursive=True, out=obj.stdout)
+
+
+@cli.command("list")
+@click.argument("path", nargs=1, type=P)
+@click.pass_obj
+async def list_(obj, path):
+    """List the next stage."""
+    if len(path) > 3:
+        raise click.UsageError("Only up to three path elements (host.chip:pin) allowed")
+
+    async with obj.conn.d_walk(obj.gpio_prefix + path, min_depth=1, max_depth=1) as mon:
+        async for p, _d in mon:
+            print(p[-1], file=obj.stdout)
+
+
+@cli.command("attr")
+@attr_args
+@click.argument("path", nargs=1, type=P)
+@click.pass_obj
+async def attr_(obj, path, **kw):
+    """Set/get/delete attributes of a given GPIO element.
+
+    `--eval` without a value deletes the attribute.
+    """
+    if len(path) != 3:
+        raise click.UsageError("Three path elements (host.chip:pin) required")
+    res, _meta = await node_attr(obj, obj.gpio_prefix + path, **kw)
+    if getattr(obj, "meta", False):
+        yprint(res, stream=obj.stdout)
+
+
+@cli.command("delete")
+@click.argument("path", nargs=1, type=P)
+@click.pass_obj
+async def delete(obj, path):
+    """Delete a port."""
+    if len(path) != 3:
+        raise click.UsageError("Three path elements (host.chip:pin) required")
+    res = await obj.conn.d.delete(obj.gpio_prefix + path)
+    if getattr(obj, "meta", False):
+        yprint(res[0], stream=obj.stdout)
+
+
+@cli.command("port")
+@click.option("-t", "--type", "typ", help="Port type. 'input' or 'output'.")
+@click.option("-m", "--mode", help="Port mode. Use '-' to disable.")
+@click.option(
+    "-a",
+    "--attr",
+    nargs=2,
+    multiple=True,
+    help="One attribute to set (NAME VALUE). May be used multiple times.",
+)
+@click.argument("path", nargs=1, type=P)
+@click.pass_obj
+async def port(obj, path, typ, mode, attr):
+    """Add/modify a port. This is a shortcut for the "attr" command.
+
+    \b
+    Known attributes for types+modes:
+      input:
+        read: dest (path)
+        count: read + interval (float), count (+-x for up/down/both)
+        button: read + t_bounce (float), t_idle (float), skip (+- ignore noise?),
+                       t_clear (float), flow (bool)
+      output:
+        write: src (path), state (path)
+        oneshot: write + t_on (float), state (path)
+        pulse:   oneshot + t_off (float)
+      *:
+        low: bool (signals are active-low if true)
+
+    \b
+    Paths elements are separated by spaces.
+    "low" is the state of the wire when the input is False.
+    Floats may be paths, in which case they're read from there when starting.
+    """
+    if len(path) != 3:
+        raise click.UsageError("Three path elements (host.chip:pin) required")
+    try:
+        res = await obj.conn.d_get(obj.gpio_prefix + path)
+    except KeyError:
+        res = {}
+    val = res if isinstance(res, dict) else attrdict()
+
+    if typ is None:
+        raise click.UsageError("Port type is mandatory.")
+    if mode is None:
+        raise click.UsageError("Port mode is mandatory.")
+    attr = (("type", typ), ("mode", mode)) + attr
+    for k, v in attr:
+        if k == "count":
+            if v == "+":
+                v = True  # noqa: PLW2901
+            elif v == "-":
+                v = False  # noqa: PLW2901
+            elif v in "xX*":
+                v = None  # noqa: PLW2901
+            else:
+                raise click.UsageError(f"'{k}' wants one of + - X")
+        elif k in ("low", "skip", "flow"):
+            if v == "+":
+                v = True  # noqa: PLW2901
+            elif v == "-":
+                v = False  # noqa: PLW2901
+            else:
+                raise click.UsageError(f"'{k}' wants one of + -")
+        elif k in {"src", "dest"}:
+            v = P(v)  # noqa: PLW2901
+        else:
+            try:
+                v = int(v)  # noqa: PLW2901
+            except ValueError:
+                with contextlib.suppress(ValueError):
+                    v = float(v)  # noqa: PLW2901
+        val[k] = v
+
+    await obj.conn.d_set(obj.gpio_prefix + path, val)
+
+
+@cli.command("monitor")
+@click.argument("name", nargs=1)
+@click.argument("chip", nargs=1)
+@click.pass_obj
+async def monitor(obj, name, chip):
+    """Stand-alone task to monitor a single GPIO chip.
+
+    The first argument is the host name, the second the chip name.
+    """
+    from .task import task  # noqa: PLC0415
+
+    async with as_service(obj, host=False) as srv:
+        await task(
+            obj.conn,
+            obj.gpio_cfg,
+            name,
+            chip,
+            task_status=srv,
+        )

moat_link_gpio-0.1.0/src/moat/link/gpio/model.py

@@ -0,0 +1,199 @@
+"""
+Node model for the GPIO controller connector.
+
+The tree mirrors the MoaT-Link subtree under the configured prefix.
+Each host entry is keyed by its name; below it the tree branches
+into integer line numbers, each holding a :class:`GpioLine` leaf.
+"""
+
+from __future__ import annotations
+
+import logging
+
+from attrs import define
+
+from moat.util import NotGiven
+from moat.lib.path import Path
+from moat.link.node import Node
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from moat.lib.rpc import Key
+
+
+logger = logging.getLogger(__name__)
+
+
+@define
+class GpioLine(Node):
+    """A single GPIO line.
+
+    The stored configuration is a dict with these keys:
+
+    * ``type``: ``"input"`` or ``"output"``.
+    * ``mode``: input mode (``"read"``, ``"count"``, ``"button"``) or
+      output mode (``"write"``, ``"oneshot"``, ``"pulse"``).
+    * ``dest``: destination path (for input modes).
+    * ``src``: source path (for output modes).
+    * ``state``: optional state path (for output modes).
+    * ``low``: active-low flag (default ``False``).
+    * ``interval``: polling interval (for ``mode=count``).
+    * ``count``: pulse direction (``True``/``False``/``None``).
+    * ``t_on``: on-time (for ``mode=oneshot|pulse``).
+    * ``t_off``: off-time (for ``mode=pulse``).
+    * ``t_bounce``: debounce time.
+    * ``t_idle``: max pulse width (for ``mode=button``).
+    * ``t_clear``: clear-after time (for ``mode=button``).
+    * ``skip``: ignore short bounces.
+    * ``flow``: send intermediate results.
+    """
+
+    @property
+    def type_(self) -> str | None:
+        """Line type, or ``None`` if unset."""
+        d = self.data_
+        return d.get("type") if isinstance(d, Mapping) else None
+
+    @property
+    def mode(self) -> str | None:
+        """Line mode, or ``None`` if unset."""
+        d = self.data_
+        return d.get("mode") if isinstance(d, Mapping) else None
+
+    @property
+    def dest(self) -> Path | None:
+        """Destination path (input modes), or ``None``."""
+        d = self.data_
+        s = d.get("dest") if isinstance(d, Mapping) else None
+        return s if s is None else Path.build(s)
+
+    @property
+    def src(self) -> Path | None:
+        """Source path (output modes), or ``None``."""
+        d = self.data_
+        s = d.get("src") if isinstance(d, Mapping) else None
+        return s if s is None else Path.build(s)
+
+    @property
+    def state(self) -> Path | None:
+        """Optional state path (output modes), or ``None``."""
+        d = self.data_
+        s = d.get("state") if isinstance(d, Mapping) else None
+        return s if s is None else Path.build(s)
+
+    @property
+    def low(self) -> bool:
+        """Active-low flag (default ``False``)."""
+        d = self.data_ if self.data_ is not NotGiven else {}
+        return bool(d.get("low", False)) if isinstance(d, Mapping) else False
+
+    @property
+    def interval(self) -> float | None:
+        """Polling interval (for ``mode=count``), or ``None``."""
+        d = self.data_
+        return d.get("interval") if isinstance(d, Mapping) else None
+
+    @property
+    def count(self) -> bool | None:
+        """Pulse direction (``True``/``False``/``None``)."""
+        d = self.data_
+        v = d.get("count") if isinstance(d, Mapping) else None
+        return v if v is None else bool(v)
+
+    @property
+    def t_on(self) -> float | None:
+        """On-time in seconds (for ``mode=oneshot|pulse``), or ``None``."""
+        d = self.data_
+        return d.get("t_on") if isinstance(d, Mapping) else None
+
+    @property
+    def t_off(self) -> float | None:
+        """Off-time in seconds (for ``mode=pulse``), or ``None``."""
+        d = self.data_
+        return d.get("t_off") if isinstance(d, Mapping) else None
+
+    @property
+    def t_bounce(self) -> float | None:
+        """Debounce time, or ``None``."""
+        d = self.data_
+        return d.get("t_bounce") if isinstance(d, Mapping) else None
+
+    @property
+    def t_idle(self) -> float | None:
+        """Max pulse width (for ``mode=button``), or ``None``."""
+        d = self.data_
+        return d.get("t_idle") if isinstance(d, Mapping) else None
+
+    @property
+    def t_clear(self) -> float | None:
+        """Clear-after time (for ``mode=button``), or ``None``."""
+        d = self.data_
+        return d.get("t_clear") if isinstance(d, Mapping) else None
+
+    @property
+    def skip(self) -> bool:
+        """Ignore short bounces (default ``True``)."""
+        d = self.data_ if self.data_ is not NotGiven else {}
+        return bool(d.get("skip", True)) if isinstance(d, Mapping) else True
+
+    @property
+    def flow(self) -> bool:
+        """Send intermediate results (default ``False``)."""
+        d = self.data_ if self.data_ is not NotGiven else {}
+        return bool(d.get("flow", False)) if isinstance(d, Mapping) else False
+
+    def is_complete(self) -> bool:
+        """Whether this entry has a complete configuration."""
+        t = self.type_
+        m = self.mode
+        if t == "input":
+            return m is not None and self.dest is not None
+        if t == "output":
+            return m is not None and self.src is not None
+        return False
+
+
+@define
+class GpioChip(Node):
+    """One GPIO chip (controller); children are :class:`GpioLine`."""
+
+    def add_child(self, item: Key) -> GpioLine:
+        """Create child entries as :class:`GpioLine`."""
+        if item in self._sub:
+            raise ValueError("exists")
+        self._sub[item] = s = GpioLine()
+        return s
+
+    @property
+    def name(self) -> str | None:
+        """Chip name (this node's key, if known from path context)."""
+        return None
+
+
+@define
+class GpioHost(Node):
+    """One host in the configuration tree; children are :class:`GpioChip`."""
+
+    def add_child(self, item: Key) -> GpioChip:
+        """Create child chips as :class:`GpioChip`."""
+        if item in self._sub:
+            raise ValueError("exists")
+        self._sub[item] = s = GpioChip()
+        return s
+
+
+@define
+class GpioRoot(Node):
+    """Root of the GPIO configuration tree.
+
+    Children are :class:`GpioHost` nodes.
+    """
+
+    def add_child(self, item: Key) -> GpioHost:
+        """Create child hosts as :class:`GpioHost`."""
+        s = self._sub.get(item)
+        if not isinstance(s, GpioHost):
+            self._sub[item] = s = GpioHost()
+        return s

moat_link_gpio-0.1.0/src/moat/link/gpio/task.py

@@ -0,0 +1,123 @@
+"""
+Main supervisor task for the GPIO connector.
+
+Opens a GPIO chip and monitors the MoaT-Link configuration subtree for
+one host/chip.  Spawns / cancels per-line workers as entries appear or
+change.
+"""
+
+from __future__ import annotations
+
+import anyio
+import logging
+
+import moat.lib.gpio as gpio
+from moat.util import combine_dict
+from moat.lib.path import Path
+
+from .model import GpioChip, GpioLine
+from .worker import run_in, run_out
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from anyio.abc import TaskStatus
+
+    from moat.link.client import LinkSender
+
+    from collections.abc import Mapping
+
+logger = logging.getLogger(__name__)
+
+
+async def task(
+    link: LinkSender,
+    cfg: Mapping,
+    host_name: str,
+    chip_name: str,
+    *,
+    task_status: TaskStatus[None] = anyio.TASK_STATUS_IGNORED,
+) -> None:
+    """Run the GPIO connector for one chip.
+
+    Args:
+        link: an active MoaT-Link sender.
+        cfg: the ``link.gpio`` configuration section.
+        host_name: the host entry name.
+        chip_name: the chip entry name inside the host subtree.
+        task_status: task-status for ``tg.start``.
+    """
+    prefix = Path.build(cfg["prefix"])
+    chip_path = prefix / host_name / chip_name
+
+    chip_data = await link.d_get(chip_path)
+    if not isinstance(chip_data, dict):
+        chip_data = {}
+
+    with gpio.open_chip(label=chip_name) as chip:
+        async with anyio.create_task_group() as tg:
+            workers: dict[Path, anyio.CancelScope] = {}
+
+            def _cancel(p: Path) -> None:
+                sc = workers.pop(p, None)
+                if sc is not None:
+                    sc.cancel()
+
+            async def _start(p: Path, entry: GpioLine) -> None:
+                _cancel(p)
+                if not entry.is_complete():
+                    logger.warning("Incomplete entry at %s, skipping", p)
+                    return
+                if len(p) != 1 or not isinstance(p[0], int):
+                    logger.warning("Entry %s is not a single integer line number", p)
+                    return
+                line_num = int(p[0])
+
+                runner = run_in if entry.type_ == "input" else run_out
+                line_cfg = combine_dict(
+                    entry.data_ if isinstance(entry.data_, dict) else {},
+                    dict(cfg),
+                )
+
+                async def _run(
+                    *,
+                    task_status: TaskStatus[None] = anyio.TASK_STATUS_IGNORED,
+                ) -> None:
+                    with anyio.CancelScope() as sc:
+                        workers[p] = sc
+                        task_status.started()
+                        try:
+                            await runner(link, chip, entry, line_num, p, line_cfg)
+                        except Exception:
+                            logger.exception("Worker for %s failed", p)
+                        finally:
+                            if workers.get(p) is sc:
+                                del workers[p]
+
+                await tg.start(_run)
+
+            async with link.d_watch(
+                chip_path,
+                subtree=True,
+                mark=True,
+                cls=GpioChip,
+            ) as mon:
+                task_status.started()
+
+                async for msg in mon:
+                    if msg is None:
+                        continue
+                    p, _data = msg
+                    if not p:
+                        continue
+
+                    node = mon.nodes.get(p)
+                    if isinstance(node, GpioLine):
+                        if node.is_complete():
+                            await _start(p, node)
+                        else:
+                            _cancel(p)
+                    else:
+                        _cancel(p)
+
+            tg.cancel_scope.cancel()

moat_link_gpio-0.1.0/src/moat/link/gpio/worker.py

@@ -0,0 +1,472 @@
+"""
+Per-line workers for the GPIO connector.
+
+Input workers (``type=input``) monitor a GPIO line and publish decoded
+values to a MoaT-Link destination.  Three input modes are supported:
+
+* ``read``: forward debounced line state changes.
+* ``count``: accumulate pulse counts and report periodically.
+* ``button``: decode button press sequences (short/long/multi-click).
+
+Output workers (``type=output``) watch a MoaT-Link source and drive
+the GPIO line accordingly.  Three output modes are supported:
+
+* ``write``: directly mirror the source value.
+* ``oneshot``: pulse high for ``t_on`` seconds, then revert.
+* ``pulse``: continuously pulse with duty cycle ``t_on``/``t_off``.
+"""
+
+from __future__ import annotations
+
+import anyio
+import logging
+
+import moat.lib.gpio as gpio
+from moat.util import NotGiven, combine_dict
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from moat.lib.path import Path
+    from moat.link.client import LinkSender
+
+    from .model import GpioLine
+
+    from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+def _DIR(d):
+    """Translate a direction flag to a :class:`gpio.Edge`."""
+    if d is None:
+        return gpio.Edge.BOTH
+    if d:
+        return gpio.Edge.RISING
+    return gpio.Edge.FALLING
+
+
+# ── Input workers ────────────────────────────────────────────────
+
+
+async def run_in(
+    link: LinkSender,
+    chip: Any,
+    entry: GpioLine,
+    line_num: int,
+    subpath: Path,
+    cfg: dict[str, Any],
+) -> None:
+    """Forward GPIO line state changes to a MoaT-Link destination.
+
+    Dispatches to :func:`_poll_task`, :func:`_count_task`, or
+    :func:`_button_task` depending on ``entry.mode``.
+
+    Args:
+        link: Active MoaT-Link sender.
+        chip: Open GPIO chip handle.
+        entry: Configuration entry for this line.
+        line_num: Line number on the chip.
+        subpath: Path of this entry (for logging).
+        cfg: Global ``link.gpio`` defaults, merged with per-line config.
+    """
+    mode = entry.mode
+    dest = entry.dest
+    if mode is None or dest is None:
+        return
+
+    lc = combine_dict(entry.data_ if isinstance(entry.data_, dict) else {}, cfg)
+
+    if mode == "read":
+        await _poll_task(link, chip, line_num, dest, lc, subpath)
+    elif mode == "count":
+        await _count_task(link, chip, line_num, dest, lc, subpath)
+    elif mode == "button":
+        await _button_task(link, chip, line_num, dest, lc, subpath)
+    else:
+        logger.warning("Unknown input mode %r at %s", mode, subpath)
+
+
+async def _poll_task(
+    link: LinkSender,
+    chip: Any,
+    line_num: int,
+    dest: Path,
+    lc: dict[str, Any],
+    subpath: Path,  # noqa: ARG001
+) -> None:
+    """Monitor a line and forward debounced state changes."""
+    negate = lc.get("low", False)
+    change = lc.get("change", None)
+    skip = lc.get("skip", True)
+    bounce = lc.get("t_bounce", 0.05)
+
+    wire = chip.line(line_num)
+    with wire.monitor(gpio.Edge.BOTH) as mon:
+        old_value = mon.value
+
+        async def set_value(value: bool) -> None:
+            if negate:
+                value = not value
+            if change is None or value == change:
+                await link.d_set(dest, value)
+
+        await set_value(old_value)
+        mon_iter = mon.__aiter__()
+        while True:
+            e = await mon_iter.__anext__()
+
+            if not skip:
+                await set_value(not old_value)
+
+            with anyio.move_on_after(bounce):
+                while True:
+                    e = await mon_iter.__anext__()
+
+            if old_value == e.value:
+                if not skip:
+                    await set_value(old_value)
+            else:
+                if skip:
+                    await set_value(e.value)
+                old_value = e.value
+
+
+async def _count_task(
+    link: LinkSender,
+    chip: Any,
+    line_num: int,
+    dest: Path,
+    lc: dict[str, Any],
+    subpath: Path,  # noqa: ARG001
+) -> None:
+    """Count pulses on a line and report periodically."""
+    intv = lc.get("interval", 1)
+    direc = lc.get("count", True)
+    bounce = lc.get("t_bounce", 0.05)
+
+    async def get_value() -> float:
+        try:
+            val = await link.d_get(dest)
+        except KeyError:
+            return 0.0
+        if not isinstance(val, (int, float)):
+            return 0.0
+        return float(val)
+
+    val = await get_value()
+
+    wire = chip.line(line_num)
+    with wire.monitor(_DIR(None)) as mon:
+        i = mon.__aiter__()
+        t = anyio.current_time()
+        d: int = 0
+        armed = False
+        value = mon.value
+        debounce = True
+
+        while True:
+            if not armed:
+                await i.__anext__()
+                debounce = True
+                t = anyio.current_time()
+                tm = intv
+            else:
+                tm = max(0, t + intv - anyio.current_time())
+            try:
+                with anyio.fail_after(bounce if debounce else tm):
+                    await i.__anext__()
+            except TimeoutError:
+                if debounce:
+                    debounce = False
+                    if mon.value != value:
+                        value = mon.value
+                        if direc is not (not value):
+                            if not armed:
+                                d = 1
+                                val += d
+                                await link.d_set(dest, val)
+                                d = 0
+                                armed = True
+                            else:
+                                d += 1
+                elif d == 0:
+                    armed = False
+                else:
+                    val += d
+                    await link.d_set(dest, val)
+                    d = 0
+                    armed = True
+            else:
+                debounce = True
+
+
+async def _button_task(
+    link: LinkSender,
+    chip: Any,
+    line_num: int,
+    dest: Path,
+    lc: dict[str, Any],
+    subpath: Path,  # noqa: ARG001
+) -> None:
+    """Decode button-press sequences and publish them."""
+    negate = lc.get("low", False)
+    skip = lc.get("skip", True)
+    bounce = lc.get("t_bounce", 0.05)
+    idle = lc.get("t_idle", 1.5)
+    idle_h = lc.get("t_idle_on", idle)
+    idle_clear = lc.get("t_clear", 30)
+    count = lc.get("count", True)
+    flow = lc.get("flow", False)
+
+    wire = chip.line(line_num)
+    with wire.monitor(gpio.Edge.BOTH) as mon:
+        ival = mon.value
+        mon_iter = mon.__aiter__()
+
+        def td(a, b):
+            a = a.timestamp
+            b = b.timestamp
+            return a[0] - b[0] + (a[1] - b[1]) / 1000000000
+
+        def inv(x):
+            if x is None:
+                return x
+            if negate:
+                return not x
+            return bool(x)
+
+        count = inv(count)
+
+        async def record(e1, ival):
+            res: list[int] = []
+            e1.value = None
+            e0 = e1
+            e2 = None
+            flow_bounce = flow
+            while True:
+                try:
+                    with anyio.fail_after(bounce):
+                        e2 = await mon_iter.__anext__()
+                except TimeoutError:
+                    pass
+                else:
+                    e1 = e2
+                    if flow_bounce and td(e1, e0) > bounce:
+                        flow_bounce = False
+                        await link.d_set(
+                            dest,
+                            {
+                                "start": inv(ival),
+                                "seq": res + [0],
+                                "end": inv(e1.value),
+                                "t": bounce,
+                                "flow": True,
+                            },
+                        )
+                    continue
+
+                if e2 is None:
+                    e2 = e1
+
+                if e0.value is None:
+                    e0.value = not ival
+
+                if e1.value != e0.value:
+                    if skip or td(e1, e0) < bounce:
+                        e1 = e0
+                    else:
+                        if count is not bool(e1.value):
+                            res.append(int(td(e1, e0) / bounce))
+                            if flow:
+                                await link.d_set(
+                                    dest,
+                                    {
+                                        "start": not ival,
+                                        "seq": res,
+                                        "end": inv(e1.value),
+                                        "t": bounce,
+                                        "flow": True,
+                                    },
+                                )
+                        e0 = e1
+
+                try:
+                    with anyio.fail_after((idle_h if inv(e1.value) else idle) - bounce):
+                        e2 = await mon_iter.__anext__()
+                except TimeoutError:
+                    if count is not bool(e1.value):
+                        res.append(0)
+                    return ival, inv(ival), res, inv(e1.value)
+
+                if count is not (not bool(e1.value)):
+                    res.append(int(td(e2, e0) / bounce))
+
+                e2.value = not e1.value
+                e0 = e1 = e2
+                if flow:
+                    await link.d_set(
+                        dest,
+                        {
+                            "start": not ival,
+                            "seq": res,
+                            "end": inv(e2.value),
+                            "t": bounce,
+                            "flow": True,
+                        },
+                    )
+                flow_bounce = flow
+
+        clear = True
+        while True:
+            if clear and idle_clear:
+                try:
+                    with anyio.fail_after(idle_clear):
+                        e = await mon.__anext__()
+                except TimeoutError:
+                    await link.d_set(dest, False)
+                    clear = False
+                    continue
+            else:
+                e = await mon.__anext__()
+            ival, start_val, res, end_val = await record(e, ival)
+            if not res:
+                continue
+            await link.d_set(
+                dest,
+                {
+                    "start": start_val,
+                    "seq": res,
+                    "end": end_val,
+                    "t": bounce,
+                },
+            )
+            clear = True
+
+
+# ── Output workers ───────────────────────────────────────────────
+
+
+async def run_out(
+    link: LinkSender,
+    chip: Any,
+    entry: GpioLine,
+    line_num: int,
+    subpath: Path,
+    cfg: dict[str, Any],
+) -> None:
+    """Forward MoaT-Link source updates onto a GPIO line.
+
+    Dispatches to :func:`_set_value`, :func:`_oneshot_value`, or
+    :func:`_pulse_value` depending on ``entry.mode``.
+
+    Args:
+        link: Active MoaT-Link sender.
+        chip: Open GPIO chip handle.
+        entry: Configuration entry for this line.
+        line_num: Line number on the chip.
+        subpath: Path of this entry (for logging).
+        cfg: Global ``link.gpio`` defaults, merged with per-line config.
+    """
+    mode = entry.mode
+    src = entry.src
+    if mode is None or src is None:
+        return
+
+    lc = combine_dict(entry.data_ if isinstance(entry.data_, dict) else {}, cfg)
+    negate = lc.get("low", False)
+    t_on = lc.get("t_on", None)
+    t_off = lc.get("t_off", None)
+    state = entry.state
+
+    with chip.line(line_num).open(direction=gpio.Direction.OUTPUT) as line:
+        if mode == "write":
+            await _with_output(link, line, src, _set_value, state, negate, subpath)
+        elif mode == "oneshot":
+            if t_on is None:
+                logger.warning("t_on not set at %s", subpath)
+                return
+            await _with_output(link, line, src, _oneshot_value, state, negate, subpath, t_on)
+        elif mode == "pulse":
+            if t_on is None or t_off is None:
+                logger.warning("t_on/t_off not set at %s", subpath)
+                return
+            await _with_output(link, line, src, _pulse_value, state, negate, subpath, t_on, t_off)
+        else:
+            logger.warning("Unknown output mode %r at %s", mode, subpath)
+
+
+async def _with_output(
+    link: LinkSender,
+    line: Any,
+    src: Path,
+    proc: Any,
+    *args: Any,
+) -> None:
+    """Watch a MoaT-Link source and call *proc* for each value change."""
+    async with link.d_watch(src, mark=False, state=False) as wp:
+        async for val in wp:
+            if val is NotGiven:
+                continue
+            if val in (False, True, 0, 1):
+                try:
+                    await proc(link, line, bool(val), *args)
+                except Exception as exc:
+                    logger.warning("Output error at %s: %r", src, exc)
+            else:
+                logger.warning("Bad value %r at %s", val, src)
+
+
+async def _set_value(
+    link: LinkSender,
+    line: Any,
+    value: bool,
+    state: Path | None,
+    negate: bool,
+) -> None:
+    """Directly mirror a value to the GPIO line."""
+    if negate:
+        value = not value
+    if line is not None:
+        line.value = value != negate
+    if state is not None:
+        await link.d_set(state, value)
+
+
+async def _oneshot_value(
+    link: LinkSender,
+    line: Any,
+    val: bool,
+    state: Path | None,
+    negate: bool,
+    t_on: float,
+) -> None:
+    """Pulse high for *t_on* seconds, then revert."""
+    if val:
+        await _set_value(link, line, True, state, negate)
+        await anyio.sleep(t_on)
+        await _set_value(link, line, False, state, negate)
+    else:
+        await _set_value(link, line, False, state, negate)
+
+
+async def _pulse_value(
+    link: LinkSender,
+    line: Any,
+    val: bool,
+    state: Path | None,
+    negate: bool,
+    t_on: float,
+    t_off: float,
+) -> None:
+    """Continuously pulse with duty cycle *t_on*/(*t_on*+*t_off*)."""
+    if not val:
+        await _set_value(link, line, False, state, negate)
+        return
+    if state is not None:
+        await link.d_set(state, t_on / (t_on + t_off))
+    while True:
+        line.value = not negate
+        await anyio.sleep(t_on)
+        line.value = negate
+        await anyio.sleep(t_off)

moat_link_gpio-0.1.0/src/moat_link_gpio.egg-info/PKG-INFO

@@ -0,0 +1,64 @@
+Metadata-Version: 2.4
+Name: moat-link-gpio
+Version: 0.1.0
+Summary: GPIO controller connector for MoaT-Link
+Author-email: Matthias Urlichs <matthias@urlichs.de>
+Project-URL: homepage, https://m-o-a-t.org
+Project-URL: repository, https://github.com/M-o-a-T/moat
+Keywords: MoaT
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Framework :: AsyncIO
+Classifier: Framework :: Trio
+Classifier: Framework :: AnyIO
+Classifier: Development Status :: 4 - Beta
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: anyio~=4.2
+Requires-Dist: asyncclick~=8.3
+Requires-Dist: attrs
+Requires-Dist: moat-util~=0.63.0
+Requires-Dist: moat-link~=0.10.0
+Requires-Dist: moat-lib-config~=0.2.0
+Requires-Dist: moat-lib-gpio~=0.9.4
+Dynamic: license-file
+
+# GPIO controller connector
+
+% start synopsis
+Connects MoaT-Link to GPIO lines via the moat-lib-gpio library.
+% end synopsis
+
+% start main
+
+This module bridges MoaT-Link values and GPIO controller lines, in both
+directions.  It replaces the legacy ``moat-kv-gpio`` package.
+
+## Quick start
+
+1. Configure an input line (reads GPIO and publishes to a link path):
+
+   ```shell
+   moat link gpio port myhost 0 5 -t input -m read -a dest .sensors.button
+   ```
+
+2. Configure an output line (watches a link path and drives GPIO):
+
+   ```shell
+   moat link gpio port myhost 0 3 -t output -m write -a src .controls.lamp
+   ```
+
+3. Run the connector for a chip:
+
+   ```shell
+   moat link gpio monitor myhost 0
+   ```
+
+## Deprecation
+
+This package supersedes ``moat-kv-gpio``.  The address tree now lives in
+MoaT-Link under the ``gpio`` prefix; lines are stored as integer line
+numbers below host and chip entries.
+
+% end main

moat_link_gpio-0.1.0/src/moat_link_gpio.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE.txt
+README.md
+pyproject.toml
+src/moat/link/gpio/__init__.py
+src/moat/link/gpio/_cfg.yaml
+src/moat/link/gpio/_main.py
+src/moat/link/gpio/model.py
+src/moat/link/gpio/task.py
+src/moat/link/gpio/worker.py
+src/moat_link_gpio.egg-info/PKG-INFO
+src/moat_link_gpio.egg-info/SOURCES.txt
+src/moat_link_gpio.egg-info/dependency_links.txt
+src/moat_link_gpio.egg-info/requires.txt
+src/moat_link_gpio.egg-info/top_level.txt

moat_link_gpio-0.1.0/src/moat_link_gpio.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

moat_link_gpio-0.1.0/src/moat_link_gpio.egg-info/requires.txt

@@ -0,0 +1,7 @@
+anyio~=4.2
+asyncclick~=8.3
+attrs
+moat-lib-config~=0.2.0
+moat-lib-gpio~=0.9.4
+moat-link~=0.10.0
+moat-util~=0.63.0

moat_link_gpio-0.1.0/src/moat_link_gpio.egg-info/top_level.txt

@@ -0,0 +1 @@
+moat