dalicontrol-e64 0.2.0__py3-none-any.whl

dalicontrol_e64/__init__.py

@@ -0,0 +1,7 @@
+"""Unofficial tools for the IPAS DaliControl e64 KNX/DALI gateway."""
+from . import commands
+from .http import CommandRejected, HttpClient
+from .writer import Macro, Writer
+
+__all__ = ["commands", "CommandRejected", "HttpClient", "Macro", "Writer"]
+__version__ = "0.2.0"

dalicontrol_e64/commands.py

@@ -0,0 +1,114 @@
+"""Three-byte command encoding for the IPAS DaliControl e64 (firmware 1.3_06).
+
+Every command is three bytes, written as six hex characters. The same bytes
+travel over both transports (HTTP CGI and KNX property write).
+
+Encoders here cover only *operational* commands: things a resident could also
+trigger from a wall switch. Programming commands are listed in ``DANGEROUS``
+so callers can refuse them; nothing in this package sends them by accident.
+"""
+from __future__ import annotations
+
+MAX_CHANNELS = 64
+MAX_GROUPS = 16
+MAX_SCENES = 16
+
+ALL_OFF = "0A0000"
+ALL_ON = "0BFFFF"  # level broadcast at 100 %. "0B0000" is acknowledged but does nothing.
+
+# First command byte -> (name, effect). Never send these to "test the connection".
+DANGEROUS = {
+    0x01: ("NEWINST", "DALI new installation: re-addresses every ballast, wipes groups"),
+    0x02: ("CONFIG", "post-installation: assigns addresses to unaddressed ballasts"),
+    0x05: ("SETGROUP", "writes a group assignment into the device"),
+    0x06: ("PSCENE", "stores the current live levels as a scene"),
+    0x0D: ("TUNNEL", "raw DALI passthrough, behaviour unknown"),
+    0x0E: ("SWAP", "swaps the short addresses of two ballasts"),
+    0x10: ("RHRESET", "resets operating-hours counters"),
+    0x11: ("BURNIN", "burn-in mode, lamps at full load"),
+    0x12: ("FXUPDATE", "writes effect configuration"),
+    0x13: ("REPLACE", "single ballast replacement, touches the address table"),
+    0x14: ("CFT", "converter function test"),
+    0x15: ("SDT", "converter duration test"),
+    0x16: ("LDT", "converter long duration test"),
+    0x17: ("BRT", "converter battery test"),
+    0x1B: ("TPLSYNC", "template sync"),
+    0x20: ("ECGMODE", "changes ballast mode flags"),
+    0x80: ("TPLRUN", "runs a configured template"),
+}
+
+
+def _check(name: str, value: int, low: int, high: int) -> int:
+    if type(value) is not int or not low <= value <= high:
+        raise ValueError(f"{name} must be an integer {low}..{high}, got {value!r}")
+    return value
+
+
+def level(channel: int, value: int) -> str:
+    """Set one channel (1..64) to a level 0..255. 0 is off, 255 is 100 %."""
+    _check("channel", channel, 1, MAX_CHANNELS)
+    _check("value", value, 0, 255)
+    return f"0B{channel - 1:02X}{value:02X}"
+
+
+def level_all(value: int) -> str:
+    """Set every ballast on the bus to one level with a single broadcast."""
+    return f"0BFF{_check('value', value, 0, 255):02X}"
+
+
+def group_level(group: int, value: int) -> str:
+    """Set one DALI group (1..16) to a level. Derived from the web UI, not field-tested."""
+    _check("group", group, 1, MAX_GROUPS)
+    _check("value", value, 0, 255)
+    return f"08{group - 1:02X}{value:02X}"
+
+
+def scene_recall(scene: int) -> str:
+    """Recall scene slot 0..15. A bus broadcast: every member ballast moves."""
+    return f"07{_check('scene', scene, 0, MAX_SCENES - 1):02X}00"
+
+
+def blink(channel: int) -> str:
+    """Blink one channel (1..64) a few times, to find out which lamp it is."""
+    return f"04{0x40 + _check('channel', channel, 1, MAX_CHANNELS) - 1:02X}00"
+
+
+def parse(command: str) -> bytes:
+    """Return the three command bytes or raise ValueError."""
+    if not isinstance(command, str) or len(command) != 6:
+        raise ValueError("a command is exactly six hex characters")
+    try:
+        return bytes.fromhex(command)
+    except ValueError:
+        raise ValueError("a command is exactly six hex characters") from None
+
+
+def is_operational(command: str) -> bool:
+    """True for level writes, scene recalls and all-off; nothing else.
+
+    This is an allowlist on purpose. The encoding gives no hint which values
+    are harmless: ``010000`` looks like a no-op and starts a new installation.
+    """
+    try:
+        b = parse(command)
+    except ValueError:
+        return False
+    return (
+        b == b"\x0a\x00\x00"
+        or (b[0] == 0x0B and (b[1] < MAX_CHANNELS or b[1] == 0xFF))
+        or (b[0] == 0x07 and b[1] < MAX_SCENES and b[2] == 0)
+    )
+
+
+def require_operational(command: str) -> bytes:
+    if not is_operational(command):
+        b = None
+        try:
+            b = parse(command)
+        except ValueError:
+            pass
+        if b is not None and b[0] in DANGEROUS:
+            name, effect = DANGEROUS[b[0]]
+            raise ValueError(f"{command} is {name}: {effect}")
+        raise ValueError(f"{command!r} is not a level, scene-recall or all-off command")
+    return parse(command)

dalicontrol_e64/http.py

@@ -0,0 +1,78 @@
+"""HTTP transport: the CGI endpoint behind the device's own web page.
+
+Standard library only. Blocking; run it in a thread if you need async.
+See docs/http-api.md for the wire format and docs/lessons-learned.md for why
+a timeout must never be answered with a blind retry of a write.
+"""
+from __future__ import annotations
+
+import time
+import urllib.request
+
+from .commands import require_operational
+
+WRITE_COMMAND = "F6C35101DA00010001"  # write, DALI object, property DA, count 1, start 1
+READ = "FCC35101"
+
+
+class CommandRejected(RuntimeError):
+    """The device answered, but not with ``00``."""
+
+
+class HttpClient:
+    def __init__(self, host: str, *, timeout: float = 20, opener=urllib.request.urlopen):
+        self._base = f"http://{host}/?x="
+        self._timeout = timeout
+        self._open = opener
+
+    def _get(self, payload: str) -> str:
+        # z is only a cache buster, exactly as the device's own page sends it.
+        url = f"{self._base}{payload}&z={int(time.time())}"
+        request = urllib.request.Request(url, headers={"Connection": "close"})
+        with self._open(request, timeout=self._timeout) as response:
+            if response.status != 200:
+                raise CommandRejected(f"HTTP {response.status}")
+            return response.read().decode("ascii", "replace")
+
+    def send(self, command: str) -> None:
+        """Send one operational command. HTTP 200 alone is not success: the body must be ``00``."""
+        require_operational(command)
+        body = self._get(WRITE_COMMAND + command.upper()).strip()
+        if body != "00":
+            raise CommandRejected(f"device answered {body[:80]!r} to {command}")
+
+    def read_property(self, pid: str, count: int, start: int = 1) -> list[str]:
+        """Read ``count`` items of a property; one hex string per item."""
+        if len(pid) != 2:
+            raise ValueError("property id is two hex characters, e.g. 'CD'")
+        int(pid, 16)
+        body = self._get(f"{READ}{pid.upper()}{count:04X}{start:04X}")
+        return [line.strip() for line in body.split("\n") if line.strip()]
+
+    def reachable(self) -> bool:
+        """Cheap read-only liveness check (general failure flags, served from cache).
+
+        Use this, never a write, when you only want to know whether the device answers.
+        """
+        try:
+            return bool(self.read_property("D2", 1))
+        except (OSError, CommandRejected):
+            return False
+
+    def cached_levels(self) -> list[int | None]:
+        """Per-channel level from the device's cache; ``None`` where the cache is empty.
+
+        The cache is not the lamp. After programming writes it reads all-zero for
+        lamps that are visibly on. Do not use it to skip "unchanged" commands.
+        """
+        levels: list[int | None] = []
+        for line in self.read_property("CD", 64):
+            levels.append(None if line[:6] == "000000" else int(line[6:8], 16))
+        return levels
+
+    def scene_levels(self, scene: int) -> list[int]:
+        """Stored levels of one scene slot (0..15) for channels 1..64. Reliable right after programming."""
+        if not 0 <= scene <= 15:
+            raise ValueError("scene slot is 0..15")
+        lines = self.read_property("D7", 8, scene * 8 + 1)
+        return [int(line[i:i + 2], 16) for line in lines for i in range(0, 16, 2)]

dalicontrol_e64/knx.py

@@ -0,0 +1,98 @@
+"""KNX transport: the same three-byte commands, without the device's Ethernet port.
+
+The gateway exposes a manufacturer-specific interface object (index 6, object
+type 0xC352). Writing three bytes to its property 218 (0xDA) executes them
+exactly like the HTTP CGI does. The telegrams are individually addressed
+management telegrams, so no group address and no ETS change is needed.
+
+Requires ``xknx`` and an already connected ``XKNX`` instance (for example the
+one Home Assistant's KNX integration owns). No second tunnel is opened.
+"""
+from __future__ import annotations
+
+import asyncio
+import time
+from typing import Callable
+
+from xknx import XKNX
+from xknx.telegram import IndividualAddress
+from xknx.telegram.apci import PropertyValueRead, PropertyValueResponse, PropertyValueWrite
+
+from .commands import require_operational
+
+OBJECT_INDEX = 6
+OBJECT_TYPE = bytes.fromhex("c352")
+PID_OBJECT_TYPE = 1
+PID_COMMAND = 218
+
+
+class KnxTransport:
+    """One short management connection per command, nothing while idle.
+
+    - The interface object type is verified once per bus connection before the
+      first write, so a wrong individual address fails instead of writing
+      property 218 on some other device.
+    - The response must echo object, property, index, count and the bytes.
+    - ``interval`` spaces transactions: one command is several telegrams on a
+      9600 baud bus. Two commands per second proved reliable.
+    - A failed command is never retried here. The caller decides.
+    """
+
+    def __init__(self, provider: Callable[[], XKNX], address: str, *,
+                 interval: float = 0.5, timeout: float = 8, cleanup_timeout: float = 2):
+        self._provider = provider
+        self._address = IndividualAddress(address)
+        self._interval = interval
+        self._timeout = timeout
+        self._cleanup_timeout = cleanup_timeout
+        self._next_send = 0.0
+        self._lock = asyncio.Lock()
+        self._verified: tuple[XKNX, object] | None = None
+
+    @staticmethod
+    def _check(response, pid: int, expected: bytes) -> None:
+        value = response.payload
+        if (value.object_index, value.property_id, value.start_index,
+                value.count, value.data) != (OBJECT_INDEX, pid, 1, 1, expected):
+            raise RuntimeError(f"device rejected or mismatched KNX property {pid}")
+
+    async def send(self, command: str) -> None:
+        payload = require_operational(command)
+        async with self._lock:
+            await asyncio.sleep(max(0, self._next_send - time.monotonic()))
+            xknx = self._provider()  # resolve each time: the owner may have reconnected
+            if not xknx.connection_manager.connected.is_set():
+                raise RuntimeError("KNX connection is unavailable")
+            generation = (xknx, xknx.connection_manager.connected_since)
+            connection = None
+            failure = None
+            try:
+                async with asyncio.timeout(self._timeout):
+                    connection = await xknx.management.connect(self._address, rate_limit=2)
+                    if self._verified != generation:
+                        response = await connection.request(PropertyValueRead(
+                            object_index=OBJECT_INDEX, property_id=PID_OBJECT_TYPE,
+                            count=1, start_index=1), PropertyValueResponse)
+                        self._check(response, PID_OBJECT_TYPE, OBJECT_TYPE)
+                        self._verified = generation
+                    response = await connection.request(PropertyValueWrite(
+                        object_index=OBJECT_INDEX, property_id=PID_COMMAND,
+                        count=1, start_index=1, data=payload), PropertyValueResponse)
+                    self._check(response, PID_COMMAND, payload)
+            except BaseException as exc:
+                self._verified = None
+                failure = exc
+                raise
+            finally:
+                try:
+                    if connection is not None:
+                        try:
+                            await asyncio.wait_for(
+                                xknx.management.disconnect(self._address),
+                                self._cleanup_timeout)
+                        except Exception:
+                            self._verified = None
+                            if failure is None:
+                                raise
+                finally:
+                    self._next_send = time.monotonic() + self._interval

dalicontrol_e64/writer.py

@@ -0,0 +1,172 @@
+"""Single writer with last-request-wins per channel.
+
+Tracks pending intentions, never physical lamp state. Transport-agnostic:
+``send`` is any coroutine taking a six-character command (HTTP or KNX).
+See docs/lessons-learned.md for why a plain FIFO was not good enough.
+"""
+from __future__ import annotations
+
+import asyncio
+from collections import deque
+from dataclasses import dataclass, field
+import time
+from typing import Awaitable, Callable
+
+
+@dataclass(frozen=True)
+class Macro:
+    command: str
+    targets: dict[int, int]
+
+
+@dataclass
+class Job:
+    number: int
+    label: str
+    targets: dict[int, int]
+    remaining: dict[int, int]
+    macro: Macro | None
+    resets: list[Macro]
+    future: asyncio.Future
+    started: float = field(default_factory=time.monotonic)
+    sent: list[str] = field(default_factory=list)
+
+
+class Writer:
+    """All methods run on one event loop; admission has no await/race window.
+
+    A cancelled caller cannot cancel the worker. A one-command native request
+    runs at its original FIFO position, before any newer overlapping request.
+    Optional resets inside multi-command jobs require full footprint ownership.
+    """
+
+    def __init__(self, send: Callable[[str], Awaitable[None]], completed=None):
+        self.send = send
+        self.completed = completed
+        self.owners: dict[int, int] = {}
+        self.pending: deque[Job] = deque()
+        self.sequence = 0
+        self.task: asyncio.Task | None = None
+        self.active: Job | None = None
+        self.closed = False
+        self.history = deque(maxlen=80)
+        self.error: str | None = None
+
+    def owns(self, job, channels):
+        return all(self.owners.get(c) == job.number for c in channels)
+
+    def submit(self, targets, *, label='', macro=None, resets=()):
+        if self.closed:
+            raise RuntimeError('writer is shutting down')
+        targets = dict(targets)
+        if not targets or any(type(c) is not int or not 1 <= c <= 64 or
+                              type(v) is not int or not 0 <= v <= 255
+                              for c, v in targets.items()):
+            raise ValueError('Expected channel 1..64 and value 0..255')
+        if macro and macro.targets != targets:
+            raise ValueError('Native command footprint must equal its target map')
+        for reset in resets:
+            if not reset.targets or not set(reset.targets) <= targets.keys() or any(reset.targets.values()):
+                raise ValueError('Reset must be a zero-valued subset of request')
+        self.sequence += 1
+        job = Job(self.sequence, label, targets, dict(targets), macro,
+                  list(resets), asyncio.get_running_loop().create_future())
+        self.owners.update(dict.fromkeys(targets, job.number))
+        # Remove superseded queued work now, not after draining a long FIFO.
+        for old in list(self.pending):
+            old.remaining = {c:v for c,v in old.remaining.items() if self.owns(old, [c])}
+            if not old.remaining:
+                self.pending.remove(old)
+                self._finish(old, 'superseded')
+        self.pending.append(job)
+        self.error = None  # a fresh explicit request is allowed after a failure
+        if self.task is None or self.task.done():
+            self.task = asyncio.create_task(self._run(), name='dalicontrol-writer')
+        return job
+
+    def _finish(self, job, status, error=None):
+        result = {'request':job.number, 'label':job.label, 'status':status,
+                  'seconds':round(time.monotonic()-job.started, 3),
+                  'commands':list(job.sent), 'target_count':len(job.targets)}
+        if error:
+            result['error'] = error
+        self.history.append(result)
+        if not job.future.done():
+            job.future.set_result(result)
+
+    def _command(self, job):
+        job.remaining = {c:v for c,v in job.remaining.items() if self.owns(job, [c])}
+        if not job.remaining:
+            return None
+        macro, job.macro = job.macro, None
+        if macro:
+            # A macro is the FIRST and ONLY command of its job. Its FIFO
+            # position precedes all newer jobs, so their overrides follow it.
+            # Never expand native scene read-back into individual writes:
+            # those values are not independently verified ECG memory.
+            return macro.command, dict(job.remaining)
+        # A reset is optional; retain exact individual fallback if unsafe or
+        # not cheaper. Acknowledged zeros are removed only from this job.
+        while job.resets:
+            reset = job.resets.pop(0)
+            scope = reset.targets.keys()
+            if set(scope) <= job.remaining.keys() and self.owns(job, scope):
+                zeros = {c:0 for c in scope if job.targets[c] == 0}
+                if len(zeros) > 1:
+                    return reset.command, zeros
+        c = next(iter(job.remaining))
+        return f'0B{c-1:02X}{job.remaining[c]:02X}', {c:job.remaining[c]}
+
+    async def _run(self):
+        try:
+            while self.pending and not self.closed:
+                job = self.pending.popleft()
+                self.active = job
+                command = self._command(job)
+                if command is None:
+                    self._finish(job, 'superseded')
+                    continue
+                payload, fulfilled = command
+                try:
+                    # Only this task invokes send. Never tied to caller task.
+                    await self.send(payload)
+                    job.sent.append(payload)
+                    for c in fulfilled:
+                        job.remaining.pop(c, None)
+                except Exception as exc:
+                    self.error = f'{type(exc).__name__}: {exc}'
+                    self._finish(job, 'failed', self.error)
+                    # Unknown output after a failed write: no dependent sparse
+                    # continuation or automatic retry, no replay of queued jobs.
+                    while self.pending:
+                        self._finish(self.pending.popleft(), 'aborted', self.error)
+                    break
+                if self.closed and job.remaining:
+                    self._finish(job, 'aborted', 'Writer shutdown')
+                    continue
+                if job.remaining and not self.closed:
+                    self.pending.append(job)  # other rooms get a turn
+                else:
+                    status = 'completed' if self.owns(job, job.targets) else 'partial'
+                    if self.completed is not None:
+                        try:
+                            await self.completed(job)
+                        except Exception as exc:
+                            self.error = f'Completion callback: {exc}'
+                            self._finish(job, 'failed', self.error)
+                            continue
+                    self._finish(job, status)
+        finally:
+            self.active = None
+
+    async def close(self):
+        self.closed = True
+        while self.pending:
+            self._finish(self.pending.popleft(), 'aborted', 'Writer shutdown')
+        if self.task:
+            await asyncio.shield(self.task)  # finish the active command, never restart it
+
+    def status(self):
+        return {'active':self.active.number if self.active else None,
+                'pending':len(self.pending), 'error':self.error,
+                'history':list(self.history)}

dalicontrol_e64-0.2.0.dist-info/METADATA

@@ -0,0 +1,164 @@
+Metadata-Version: 2.4
+Name: dalicontrol-e64
+Version: 0.2.0
+Summary: Unofficial protocol notes and Python tools for the IPAS DaliControl e64 KNX/DALI gateway
+Author: NashEQify
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/NashEQify/dalicontrol-e64
+Project-URL: Documentation, https://github.com/NashEQify/dalicontrol-e64/tree/main/docs
+Project-URL: Issues, https://github.com/NashEQify/dalicontrol-e64/issues
+Keywords: dali,knx,ipas,dalicontrol,e64,lighting,home-assistant,home-automation
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: AsyncIO
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Home Automation
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: knx
+Requires-Dist: xknx>=3; extra == "knx"
+Dynamic: license-file
+
+# dalicontrol-e64
+
+Unofficial protocol notes, field experience and a small Python library for the
+**IPAS DaliControl e64** KNX/DALI gateway.
+
+The gateway is usually commissioned once with ETS and then only reached
+through KNX group addresses. It can do more: its built-in web page uses a plain
+HTTP interface, and the same commands can be sent over KNX without any ETS
+change. Neither is documented by the manufacturer. This repository writes down
+what was found while building a lighting control for a flat with 38 DALI
+ballasts, including the parts that went wrong.
+
+Use it with or without a home automation system.
+
+## No ETS, no DCA, no KNX software
+
+For working with the DALI side you do not need ETS, the DCA plug-in, an ETS
+licence or any other KNX vendor software. Switching and dimming channels,
+assigning groups, storing and recalling scenes and starting a DALI new
+installation all work with this repository alone: over HTTP with a browser,
+curl or Python, or over KNX with a free KNXnet/IP library such as
+[xknx](https://github.com/XKNX/xknx).
+
+ETS is only needed for the KNX side of the gateway: its individual address,
+group objects and KNX application parameters. If the gateway was commissioned
+once, you can leave that untouched. If you only use the HTTP interface, the
+KNX side does not matter at all.
+
+> **Tested on one device type and firmware only:** DaliControl e64, firmware
+> 1.3_06, ETS application e64-01-0110. Not affiliated with or endorsed by
+> IPAS. Several commands re-address or reconfigure your installation and have
+> no confirmation step. Read [the command table](docs/http-api.md#commands)
+> before you send anything. You act at your own risk.
+
+## What is in here
+
+| | |
+|---|---|
+| [docs/http-api.md](docs/http-api.md) | The HTTP interface: request format, every command with its risk, readable properties, timing |
+| [docs/knx-management.md](docs/knx-management.md) | The same commands over KNX, with the gateway's LAN cable unplugged; reading ETS parameters without ETS |
+| [docs/scenes.md](docs/scenes.md) | How DALI scenes are stored and recalled, and how to use them from software |
+| [docs/lessons-learned.md](docs/lessons-learned.md) | What failed and what replaced it |
+| [docs/home-automation.md](docs/home-automation.md) | Home Assistant, Node-RED, openHAB, ioBroker: from one HTTP request to a full integration |
+| `src/dalicontrol_e64/` | Python library on PyPI: command encoding with an allowlist, HTTP client, KNX transport, request queue |
+| `custom_components/dalicontrol_e64/` | Home Assistant integration (HACS): one light per channel, scene recall, all on/off, HTTP or KNX |
+
+## Five things to know first
+
+1. `010000` starts a DALI new installation. Nothing about the bytes tells you.
+2. The answer `00` means "accepted". It does not mean a lamp reacted.
+3. The channel-state read is a cache and is wrong after programming writes.
+4. One scene recall beats twenty single-channel writes. Use the 16 slots.
+5. If lights react late or not at all, check whether the gateway restarts
+   itself every few minutes while its Ethernet port is connected.
+
+## Home Assistant
+
+Add this repository in HACS as a custom repository (type *Integration*),
+install *DaliControl e64*, restart, then add the integration with the
+gateway's IP address or its KNX individual address. Details, a YAML-only
+alternative and examples for Node-RED, openHAB and ioBroker:
+[docs/home-automation.md](docs/home-automation.md).
+
+## Quick start (Python)
+
+```bash
+pip install dalicontrol-e64
+```
+
+```python
+from dalicontrol_e64 import HttpClient, commands
+
+gateway = HttpClient("192.0.2.10")          # the gateway's IP address
+print(gateway.reachable())                  # read-only check
+
+gateway.send(commands.level(4, 255))        # channel 4 to 100 %
+gateway.send(commands.level(4, 0))          # channel 4 off
+gateway.send(commands.scene_recall(5))      # recall scene slot 5
+gateway.send(commands.ALL_OFF)
+```
+
+`send` refuses everything that is not a level, a scene recall or all-off, and
+raises unless the gateway answers `00`.
+
+With curl, no library needed:
+
+```bash
+curl -sS --max-time 15 'http://192.0.2.10/?x=F6C35101DA000100010B03FF'   # channel 4 on
+```
+
+### Over KNX
+
+```bash
+pip install "dalicontrol-e64[knx]"
+```
+
+```python
+from dalicontrol_e64.knx import KnxTransport
+
+transport = KnxTransport(lambda: xknx, "1.1.2")   # connected XKNX, gateway's individual address
+await transport.send(commands.scene_recall(5))
+```
+
+### Many callers, one gateway
+
+`Writer` serialises requests from switches, apps and automations. A newer
+request replaces older waiting targets for the same channels; a failed write
+aborts what is waiting instead of retrying.
+
+```python
+from dalicontrol_e64 import Writer, Macro, commands
+
+writer = Writer(transport.send)                 # or an async wrapper around HttpClient.send
+job = writer.submit({14: 0, 15: 0, 16: 0, 17: 200}, label="dining strip white")
+result = await job.future                       # {'status': 'completed', 'commands': [...], ...}
+
+room = {c: 0 for c in range(20, 28)}
+writer.submit(room, macro=Macro(commands.scene_recall(8), dict(room)))   # one command
+```
+
+The Home Assistant integration in `custom_components/` is built on exactly
+these two parts and reuses the KNX integration's connection.
+
+## Tests
+
+```bash
+PYTHONPATH=src python3 -m unittest discover -s tests            # library
+pip install pytest-homeassistant-custom-component xknx -e .
+python3 -m pytest                                                # Home Assistant integration (Python 3.13)
+```
+
+The tests run against a simulated device. They prove the encoding, the
+allowlist and the queue logic, not the behaviour of your hardware.
+
+## Contributing
+
+Reports from other firmware versions, the e64 Pro, or decoded error flags and
+properties are welcome. Please say what you observed on the lamps, not only
+what the gateway answered.
+
+## License
+
+MIT, see [LICENSE](LICENSE).

dalicontrol_e64-0.2.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+dalicontrol_e64/__init__.py,sha256=lPMTvP0SokjmkjGFSozppIBraOlEYGdGTpvrIZRr2UI,271
+dalicontrol_e64/commands.py,sha256=zSO_SCGy9F2RCzNLSNA57XsVockjQYNJ7qxCEhFXrYs,4430
+dalicontrol_e64/http.py,sha256=_u0xbeOL8PG3YFaYTvAYjqp9hyx8DnqLSLgNx9zC_tA,3332
+dalicontrol_e64/knx.py,sha256=3Lbhfs8pDJtZh1SOPw-ZBysivivbopQ1E7SAPT3EPWk,4480
+dalicontrol_e64/writer.py,sha256=u4uXOXTP5Y74lCHBiwJPE-Ct69ctU5hlXXQwbAaAmhQ,7414
+dalicontrol_e64-0.2.0.dist-info/licenses/LICENSE,sha256=uMG5xAPM-U5RHOH8yUfGYV-gucXrNOnbS8MTzYoctfU,1066
+dalicontrol_e64-0.2.0.dist-info/METADATA,sha256=wSMUYLhKh20DWe_EntZ6LT0fY56F1lt7ND4Vg0sPiMg,6765
+dalicontrol_e64-0.2.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+dalicontrol_e64-0.2.0.dist-info/top_level.txt,sha256=nQImJR8WbzFHOyZdsCIM6hPM-MLry4BcapdEezoZB6w,16
+dalicontrol_e64-0.2.0.dist-info/RECORD,,

dalicontrol_e64-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

dalicontrol_e64-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 NashEQify
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

dalicontrol_e64-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+dalicontrol_e64