proxon-modbus 0.1.1__tar.gz

proxon_modbus-0.1.1/.gitignore

@@ -0,0 +1,7 @@
+__pycache__/
+*.py[cod]
+.venv/
+.pytest_cache/
+dist/
+build/
+*.egg-info/

proxon_modbus-0.1.1/PKG-INFO

@@ -0,0 +1,104 @@
+Metadata-Version: 2.5
+Name: proxon-modbus
+Version: 0.1.1
+Summary: Gerätebibliothek für Proxon FWT 2.0 und T300 über Modbus RTU
+License: MIT
+Requires-Python: >=3.12
+Requires-Dist: modbus-connection>=4.10.0
+Provides-Extra: pymodbus
+Requires-Dist: modbus-connection[pymodbus]>=4.10.0; extra == 'pymodbus'
+Provides-Extra: test
+Requires-Dist: pytest-asyncio>=0.24; extra == 'test'
+Requires-Dist: pytest>=8; extra == 'test'
+Provides-Extra: tmodbus
+Requires-Dist: modbus-connection[tmodbus]>=4.10.0; extra == 'tmodbus'
+Description-Content-Type: text/markdown
+
+# proxon-modbus
+
+Gerätebibliothek für **Proxon FWT 2.0** (Lüftungs-Wärmepumpe) und **T300**
+(Warmwasser-Wärmepumpe) über Modbus RTU.
+
+Die Bibliothek besitzt den Transport **nicht**. Anwendungen reichen eine
+`modbus_connection.ModbusUnit` herein — Backend `tmodbus` oder `pymodbus` —
+und bekommen dafür das Registerwissen der Anlage. Damit lässt sich sie ohne
+Hardware testen und teilt sich eine Verbindung mit anderen Verbrauchern
+desselben RS485-Strangs.
+
+```python
+from modbus_connection import ModbusTcpParams
+from modbus_connection.tmodbus import ModbusConnection
+from proxon_modbus import ProxonDevice
+
+conn = ModbusConnection(
+    ModbusTcpParams(host="192.0.2.10", port=502, framer="rtu"),
+    message_spacing=0.15,   # Pause zwischen Blöcken
+    connect_delay=0.30,     # Wartezeit nach Verbindungsaufbau
+)
+device = ProxonDevice(conn.for_unit(41))
+await device.async_update()
+
+print(device.t300_input.t21_behaelter_mitte)      # 57.5
+print(device.fwt_holding.bypass_min_frischluft)   # 8.0
+print([d.temperatur for d in device.nbe_temperatures.devices])
+```
+
+## Warum eigene Feldtypen
+
+Zwei Eigenheiten der Anlage kann `modbus_connection` nicht von sich aus:
+
+**Skalierung und Offset sind anders gemeint.** Proxon rechnet
+`(roh + offset) / scale`, die Bibliothek `roh * scale + offset`; Proxons
+`scale` ist ein Divisor, ihrer ein Multiplikator. `proxon_number()` nimmt die
+Proxon-Zahlen entgegen und rechnet um — Registerzeilen lassen sich also 1:1
+aus der Anlagendokumentation übernehmen. Ohne diese Umrechnung liest der
+Behälterfühler T21 statt **57,5 °C** ganze **−842,5 °C**.
+
+**Fremde Frames müssen verworfen werden.** Die USR-RS485-Bridge spiegelt den
+gesamten Busverkehr in die TCP-Verbindung; einzelne Register enthalten dadurch
+Werte anderer Geräte (klassisch: 128 °C Warmwasser). 46 der 94 Register tragen
+deshalb einen gültigen Rohbereich. `nan=` der Bibliothek trifft nur einzelne
+Werte, nicht Bereiche — `RangedNumberField` prüft `min_raw`/`max_raw` auf dem
+vorzeichenbehafteten Rohwert und liefert sonst `None`.
+
+Dazu kommt `Latin1StringField`: die Raumnamen liegen als zwei Latin-1-Bytes je
+Register, das `StringField` der Bibliothek ist ASCII — „Küche" käme kaputt an.
+
+## Aufbau
+
+| Baugruppe | Register |
+|---|---|
+| `FwtInput` | Input 0–51, 154–265 |
+| `FwtHolding` | Holding 16–22, 41–143, 187, 438, 460, 467–469, 613–619 |
+| `T300Input` / `T300Holding` | Input 811–900, Holding 2000–2025 |
+| `NbeTemperatures` | Input 590 + n·3, sieben Geräte |
+| `NbeSettingsBank` | Holding 213/233/253 + n |
+| `RoomNames` | Holding 620 + n·10, acht Slots |
+
+Namens-Slot 0 ist die HBDE und hat **kein** NBE-Gerät; Slot 1–7 gehören zu den
+Geräten 0–6 (`physical_index()`).
+
+## Freischaltung
+
+Register 438 = 55555 schaltet die vollen Modbus-Rechte frei. Ohne das antworten
+460 und 467–469 nicht und Schreibzugriffe werden abgelehnt. `ProxonDevice`
+erledigt das einmal je Verbindung — es ist ein Flash-Write im Gerät, gehört
+also nicht in jeden Zyklus — und setzt es nach einem Verbindungsabriss neu.
+
+## Teilausfall
+
+Einzelne Blöcke scheitern im Normalbetrieb, ohne dass die Anlage weg wäre.
+`async_update()` gibt die Namen der gescheiterten Baugruppen zurück und lässt
+deren zuletzt gelesene Werte stehen; `ProxonUnreachable` fliegt erst, wenn
+**keine** Baugruppe gelesen werden konnte.
+
+## Tests
+
+Vollständig ohne Hardware, über den Mock aus `modbus_connection`:
+
+```bash
+pip install -e ".[tmodbus,test]"
+pytest
+```
+
+Die Testdaten sind echte Registerwerte, am 2026-09-02 von der Anlage gelesen.

proxon_modbus-0.1.1/README.md

@@ -0,0 +1,88 @@
+# proxon-modbus
+
+Gerätebibliothek für **Proxon FWT 2.0** (Lüftungs-Wärmepumpe) und **T300**
+(Warmwasser-Wärmepumpe) über Modbus RTU.
+
+Die Bibliothek besitzt den Transport **nicht**. Anwendungen reichen eine
+`modbus_connection.ModbusUnit` herein — Backend `tmodbus` oder `pymodbus` —
+und bekommen dafür das Registerwissen der Anlage. Damit lässt sich sie ohne
+Hardware testen und teilt sich eine Verbindung mit anderen Verbrauchern
+desselben RS485-Strangs.
+
+```python
+from modbus_connection import ModbusTcpParams
+from modbus_connection.tmodbus import ModbusConnection
+from proxon_modbus import ProxonDevice
+
+conn = ModbusConnection(
+    ModbusTcpParams(host="192.0.2.10", port=502, framer="rtu"),
+    message_spacing=0.15,   # Pause zwischen Blöcken
+    connect_delay=0.30,     # Wartezeit nach Verbindungsaufbau
+)
+device = ProxonDevice(conn.for_unit(41))
+await device.async_update()
+
+print(device.t300_input.t21_behaelter_mitte)      # 57.5
+print(device.fwt_holding.bypass_min_frischluft)   # 8.0
+print([d.temperatur for d in device.nbe_temperatures.devices])
+```
+
+## Warum eigene Feldtypen
+
+Zwei Eigenheiten der Anlage kann `modbus_connection` nicht von sich aus:
+
+**Skalierung und Offset sind anders gemeint.** Proxon rechnet
+`(roh + offset) / scale`, die Bibliothek `roh * scale + offset`; Proxons
+`scale` ist ein Divisor, ihrer ein Multiplikator. `proxon_number()` nimmt die
+Proxon-Zahlen entgegen und rechnet um — Registerzeilen lassen sich also 1:1
+aus der Anlagendokumentation übernehmen. Ohne diese Umrechnung liest der
+Behälterfühler T21 statt **57,5 °C** ganze **−842,5 °C**.
+
+**Fremde Frames müssen verworfen werden.** Die USR-RS485-Bridge spiegelt den
+gesamten Busverkehr in die TCP-Verbindung; einzelne Register enthalten dadurch
+Werte anderer Geräte (klassisch: 128 °C Warmwasser). 46 der 94 Register tragen
+deshalb einen gültigen Rohbereich. `nan=` der Bibliothek trifft nur einzelne
+Werte, nicht Bereiche — `RangedNumberField` prüft `min_raw`/`max_raw` auf dem
+vorzeichenbehafteten Rohwert und liefert sonst `None`.
+
+Dazu kommt `Latin1StringField`: die Raumnamen liegen als zwei Latin-1-Bytes je
+Register, das `StringField` der Bibliothek ist ASCII — „Küche" käme kaputt an.
+
+## Aufbau
+
+| Baugruppe | Register |
+|---|---|
+| `FwtInput` | Input 0–51, 154–265 |
+| `FwtHolding` | Holding 16–22, 41–143, 187, 438, 460, 467–469, 613–619 |
+| `T300Input` / `T300Holding` | Input 811–900, Holding 2000–2025 |
+| `NbeTemperatures` | Input 590 + n·3, sieben Geräte |
+| `NbeSettingsBank` | Holding 213/233/253 + n |
+| `RoomNames` | Holding 620 + n·10, acht Slots |
+
+Namens-Slot 0 ist die HBDE und hat **kein** NBE-Gerät; Slot 1–7 gehören zu den
+Geräten 0–6 (`physical_index()`).
+
+## Freischaltung
+
+Register 438 = 55555 schaltet die vollen Modbus-Rechte frei. Ohne das antworten
+460 und 467–469 nicht und Schreibzugriffe werden abgelehnt. `ProxonDevice`
+erledigt das einmal je Verbindung — es ist ein Flash-Write im Gerät, gehört
+also nicht in jeden Zyklus — und setzt es nach einem Verbindungsabriss neu.
+
+## Teilausfall
+
+Einzelne Blöcke scheitern im Normalbetrieb, ohne dass die Anlage weg wäre.
+`async_update()` gibt die Namen der gescheiterten Baugruppen zurück und lässt
+deren zuletzt gelesene Werte stehen; `ProxonUnreachable` fliegt erst, wenn
+**keine** Baugruppe gelesen werden konnte.
+
+## Tests
+
+Vollständig ohne Hardware, über den Mock aus `modbus_connection`:
+
+```bash
+pip install -e ".[tmodbus,test]"
+pytest
+```
+
+Die Testdaten sind echte Registerwerte, am 2026-09-02 von der Anlage gelesen.

proxon_modbus-0.1.1/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "proxon-modbus"
+version = "0.1.1"
+description = "Gerätebibliothek für Proxon FWT 2.0 und T300 über Modbus RTU"
+readme = "README.md"
+requires-python = ">=3.12"
+license = { text = "MIT" }
+dependencies = ["modbus-connection>=4.10.0"]
+
+[project.optional-dependencies]
+tmodbus = ["modbus-connection[tmodbus]>=4.10.0"]
+pymodbus = ["modbus-connection[pymodbus]>=4.10.0"]
+test = ["pytest>=8", "pytest-asyncio>=0.24"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/proxon_modbus"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]
+
+[tool.ruff]
+line-length = 120
+target-version = "py312"

proxon_modbus-0.1.1/src/proxon_modbus/__init__.py

@@ -0,0 +1,77 @@
+"""proxon-modbus — Geräte-Bibliothek für Proxon FWT 2.0 / T300 über Modbus RTU.
+
+Besitzt den Transport **nicht**: Anwendungen reichen eine
+`modbus_connection.ModbusUnit` herein (Backend tmodbus oder pymodbus) und
+bekommen dafür das Registerwissen der Anlage.
+
+    from modbus_connection import ModbusTcpParams
+    from modbus_connection.tmodbus import ModbusConnection
+    from proxon_modbus import ProxonDevice
+
+    conn = ModbusConnection(
+        ModbusTcpParams(host="192.0.2.10", port=502, framer="rtu"),
+        message_spacing=0.15,   # entspricht _INTER_BLOCK_DELAY
+        connect_delay=0.30,     # entspricht _POST_CONNECT_DRAIN
+    )
+    device = ProxonDevice(conn.for_unit(41))
+    await device.async_update()
+    print(device.t300_input.t21_behaelter_mitte)
+"""
+
+from .device import (
+    UNLOCK_REGISTER,
+    UNLOCK_VALUE,
+    ProxonDevice,
+    ProxonUnreachable,
+)
+from .fields import (
+    Latin1StringField,
+    RangedNumberField,
+    latin1_string,
+    proxon_number,
+)
+from .fwt import Betriebsart, BypassModus, FwtHolding, FwtInput
+from .nbe import (
+    NBE_DEVICE_COUNT,
+    NAME_SLOT_COUNT,
+    NbeSettings,
+    NbeSettingsBank,
+    NbeTemperature,
+    NbeTemperatures,
+    RoomNames,
+    RoomNameSlot,
+    is_configured_room,
+    physical_index,
+)
+from .t300 import T300, T300Holding, T300Input
+
+__version__ = "0.1.1"
+
+__all__ = [
+    "ProxonDevice",
+    "ProxonUnreachable",
+    "UNLOCK_REGISTER",
+    "UNLOCK_VALUE",
+    "FwtInput",
+    "FwtHolding",
+    "Betriebsart",
+    "BypassModus",
+    "T300",
+    "T300Input",
+    "T300Holding",
+    "NbeTemperature",
+    "NbeTemperatures",
+    "NbeSettings",
+    "NbeSettingsBank",
+    "RoomNames",
+    "RoomNameSlot",
+    "NBE_DEVICE_COUNT",
+    "NAME_SLOT_COUNT",
+    "is_configured_room",
+    "physical_index",
+    "RangedNumberField",
+    "Latin1StringField",
+    "proxon_number",
+    "latin1_string",
+    "__version__",
+]

proxon_modbus-0.1.1/src/proxon_modbus/device.py

@@ -0,0 +1,118 @@
+"""Proxon-Anlage als Ganzes: FWT + optionale T300 + NBE.
+
+Bündelt die Baugruppen und trägt das gerätespezifische Wissen, das keine
+Modbus-Bibliothek kennen kann:
+
+* **Freischaltung.** Register 438 = 55555 schaltet die vollen Modbus-Rechte
+  frei. Ohne das antworten 460 und 467–469 gar nicht, und Schreibzugriffe
+  werden abgelehnt. Einmal je Verbindung, nicht je Zyklus — es ist ein
+  Flash-Write im Gerät.
+
+* **Teilausfall ist normal.** Die USR-Bridge spiegelt fremde RS485-Frames in
+  unsere Verbindung; einzelne Blöcke scheitern regelmäßig, ohne dass die Anlage
+  weg wäre. Ein gescheiterter Block darf deshalb nicht die ganze Aktualisierung
+  umwerfen — die Komponente behält ihre zuletzt gelesenen Werte
+  (entspricht `_prev_raw` in der bestehenden Integration). Erst wenn **alle**
+  Blöcke scheitern, ist es ein echter Ausfall.
+"""
+
+from __future__ import annotations
+
+import logging
+
+from modbus_connection import ModbusError, ModbusUnit
+
+from .fwt import FwtHolding, FwtInput
+from .nbe import NbeSettingsBank, NbeTemperatures, RoomNames
+from .t300 import T300Holding, T300Input
+
+_LOGGER = logging.getLogger(__name__)
+
+UNLOCK_REGISTER = 438
+UNLOCK_VALUE = 55555
+
+
+class ProxonUnreachable(RuntimeError):
+    """Kein einziger Block konnte gelesen werden."""
+
+
+class ProxonDevice:
+    """Alle Register-Baugruppen einer Proxon-Installation."""
+
+    def __init__(self, unit: ModbusUnit, *, has_t300: bool = True) -> None:
+        self._unit = unit
+        self.has_t300 = has_t300
+
+        self.fwt_input = FwtInput(unit)
+        self.fwt_holding = FwtHolding(unit)
+        self.nbe_temperatures = NbeTemperatures(unit)
+        self.nbe_settings = NbeSettingsBank(unit)
+        self.room_names = RoomNames(unit)
+        self.t300_input = T300Input(unit) if has_t300 else None
+        self.t300_holding = T300Holding(unit) if has_t300 else None
+
+        self._unlocked = False
+        # Nach einem Verbindungsabriss ist die Freischaltung der alten Sitzung
+        # nichts mehr wert — beim nächsten Zyklus neu setzen.
+        unit.on_connection_lost(self._on_connection_lost)
+
+    def _on_connection_lost(self) -> None:
+        _LOGGER.debug("Verbindung verloren — Freischaltung wird neu gesetzt")
+        self._unlocked = False
+
+    @property
+    def components(self):
+        """Alle aktiven Baugruppen (ohne T300, wenn keine verbaut ist)."""
+        parts = [
+            self.fwt_input,
+            self.fwt_holding,
+            self.nbe_temperatures,
+            self.nbe_settings,
+        ]
+        if self.t300_input is not None and self.t300_holding is not None:
+            parts += [self.t300_input, self.t300_holding]
+        return parts
+
+    async def async_unlock(self) -> bool:
+        """Volle Modbus-Rechte anfordern. Einmal je Verbindung."""
+        if self._unlocked:
+            return True
+        try:
+            await self._unit.write_register(UNLOCK_REGISTER, UNLOCK_VALUE)
+        except ModbusError as exc:
+            _LOGGER.debug("Freischaltung fehlgeschlagen: %s", exc)
+            return False
+        self._unlocked = True
+        return True
+
+    async def async_update(self) -> list[str]:
+        """Alle Baugruppen lesen.
+
+        Gibt die Namen der gescheiterten Baugruppen zurück (leer = alles gut).
+        Wirft `ProxonUnreachable`, wenn **keine** Baugruppe gelesen werden
+        konnte — nur das ist ein Geräteausfall.
+        """
+        await self.async_unlock()
+
+        failed: list[str] = []
+        for component in self.components:
+            try:
+                await component.async_update()
+            except ModbusError as exc:
+                name = type(component).__name__
+                failed.append(name)
+                _LOGGER.debug("Baugruppe %s nicht gelesen: %s", name, exc)
+
+        if len(failed) == len(self.components):
+            raise ProxonUnreachable(", ".join(failed))
+        return failed
+
+    async def async_update_room_names(self) -> None:
+        """Raumnamen lesen — ändern sich fast nie, gehört nicht in jeden Zyklus."""
+        await self.async_unlock()
+        await self.room_names.async_update()
+
+    async def async_write(self, component, field: str, value) -> None:
+        """Feld schreiben; sorgt vorher für die Freischaltung."""
+        await self.async_unlock()
+        await component.write(field, value)

proxon_modbus-0.1.1/src/proxon_modbus/fields.py

@@ -0,0 +1,130 @@
+"""Feld-Fabriken, die Proxons Register-Semantik auf `modbus_connection` abbilden.
+
+Zwei Unterschiede zur Bibliothek, beide gemessen (2026-09-02), nicht geraten:
+
+1. **Skalierung ist invertiert.** Proxon speichert `scale` als *Divisor*
+   (`real = roh / scale`), `modbus_connection.gauge()` nimmt einen *Multiplikator*
+   (`real = roh * scale`). Proxon-`scale=10` ist also `scale=0.1`.
+
+2. **Offset greift an anderer Stelle.** Proxon rechnet `(roh + offset) / scale`,
+   die Bibliothek `roh * scale + offset`. Umrechnung:
+
+       mc_scale  = 1 / proxon_scale
+       mc_offset = proxon_offset / proxon_scale
+
+   Beispiel T21 Behälter Mitte (Reg 814, scale=10, offset=-1000): roh 1575
+   → Proxon `(1575-1000)/10 = 57,5 °C`; naiv portiert (`1575*0.1 - 1000`)
+   käme **-842,5 °C** heraus.
+
+Dazu der Bereichsfilter (`min_raw`/`max_raw`): die USR-Bridge spiegelt fremde
+RS485-Frames in unsere Verbindung, was einzelne Register mit Müll füllt
+(klassisch: 128 °C Warmwasser). Die Bibliothek kennt nur `nan=` für einzelne
+Sentinel-Werte, keine Bereiche — und ihr `convert=`-Haken ist keine Lösung, weil
+er die Skalierung kurzschließt und pro unbekanntem Wert eine Warnung loggt.
+Deshalb ein eigenes Feld, das `decode()` überschreibt.
+
+46 der 94 Proxon-Register tragen so einen Bereichsschutz.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from modbus_connection.model import NumberField, StringField
+from modbus_connection.model.fields import WriteValidator
+
+
+class RangedNumberField(NumberField[float]):
+    """Zahlenfeld, das Rohwerte außerhalb `[min_raw, max_raw]` als None liefert.
+
+    Die Prüfung läuft auf dem **vorzeichenbehafteten** Rohwert, genau wie
+    `_decode()` in der bestehenden Integration: dort wird erst `_to_signed16()`
+    angewandt und danach gegen min/max verglichen.
+    """
+
+    def __init__(
+        self,
+        address: int,
+        *,
+        min_raw: int | None = None,
+        max_raw: int | None = None,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(address, **kwargs)
+        self.min_raw = min_raw
+        self.max_raw = max_raw
+
+    def decode(self, words: list[int], scale_exponent: int | None = None) -> Any:
+        if self.min_raw is not None or self.max_raw is not None:
+            # Alle Proxon-Register sind einzelne 16-Bit-Wörter.
+            raw = words[0]
+            value = raw - 0x10000 if (self.signed and raw >= 0x8000) else raw
+            if self.min_raw is not None and value < self.min_raw:
+                return None
+            if self.max_raw is not None and value > self.max_raw:
+                return None
+        return super().decode(words, scale_exponent)
+
+
+class Latin1StringField(StringField):
+    """Name-Register der Proxon: zwei **Latin-1**-Bytes je Register, big-endian.
+
+    `StringField` der Bibliothek ist ASCII und null-gepolstert — für „Küche"
+    oder „Büro" reicht das nicht. Kodierung und Abschneiden am ersten Nullbyte
+    entsprechen exakt `config_flow._discover_rooms()` und
+    `text._name_to_registers()` der bestehenden Integration.
+    """
+
+    def decode(self, words: list[int], scale_exponent: int | None = None) -> str:
+        chars: list[str] = []
+        for word in words:
+            # chr() auf einem Byte 0–255 *ist* die Latin-1-Zuordnung.
+            chars.append(chr((word >> 8) & 0xFF))
+            chars.append(chr(word & 0xFF))
+        return "".join(chars).split("\x00")[0].strip()
+
+    def encode(self, value: Any, scale_exponent: int | None = None) -> list[int]:
+        width = self.count * 2
+        encoded = str(value).encode("latin-1", errors="replace")[:width]
+        padded = encoded.ljust(width, b"\x00")
+        return [(padded[i] << 8) | padded[i + 1] for i in range(0, width, 2)]
+
+
+def latin1_string(
+    address: int,
+    length: int,
+    *,
+    stride: int = 0,
+    writable: bool | WriteValidator = False,
+) -> Latin1StringField:
+    """Latin-1-Namensfeld über `length` Register (2 Zeichen je Register)."""
+    return Latin1StringField(address, count=length, stride=stride, writable=writable)
+
+
+def proxon_number(
+    address: int,
+    *,
+    scale: float = 1,
+    offset: int = 0,
+    signed: bool = False,
+    min_raw: int | None = None,
+    max_raw: int | None = None,
+    writable: bool | WriteValidator = False,
+    unit: str | None = None,
+) -> RangedNumberField:
+    """Feld aus einer Proxon-`ModbusRegister`-Zeile.
+
+    `scale` und `offset` werden in Proxon-Semantik übergeben (Divisor bzw.
+    Summand vor der Division) und hier umgerechnet — Aufrufer schreiben also
+    dieselben Zahlen wie in `const.py`.
+    """
+    return RangedNumberField(
+        address,
+        scale=1 / scale,
+        offset=offset / scale,
+        signed=signed,
+        min_raw=min_raw,
+        max_raw=max_raw,
+        writable=writable,
+        unit=unit,
+    )

proxon_modbus-0.1.1/src/proxon_modbus/fwt.py

@@ -0,0 +1,174 @@
+"""FWT 2.0 — Lüftungs-Wärmepumpe, Register-Modell.
+
+Adressen, Skalen und Bereiche 1:1 aus `custom_components/proxon/const.py`
+(FWT_INPUT_REGISTERS / FWT_HOLDING_REGISTERS). Proxon-Semantik bleibt in den
+Aufrufen stehen (`scale` = Divisor), die Umrechnung macht `proxon_number()`.
+"""
+
+from __future__ import annotations
+
+from enum import IntEnum
+
+from modbus_connection.model import Component
+
+from .fields import proxon_number
+
+
+class Betriebsart(IntEnum):
+    """Holding 16 / Input 23. 9 = Test ist Technikermodus und bleibt draußen."""
+
+    AUS = 0
+    SOMMER = 1
+    WINTER = 2
+    KOMFORT = 3
+    OFEN = 4
+
+
+class BypassModus(IntEnum):
+    """Holding 21 (Menü T05). 1/2 hebeln die Automatik dauerhaft aus."""
+
+    GEREGELT = 0
+    GESCHLOSSEN = 1
+    GEOEFFNET = 2
+
+
+class FwtInput(Component):
+    """Nur-Lese-Register der FWT (FC4).
+
+    Die Anlage antwortet auf die Blöcke 0–51 und 154–265; dazwischen liegt eine
+    Lücke von rund 100 Registern, die sie nicht bedient. `max_gap` ist deshalb
+    klein genug gewählt, dass der Planer die beiden Blöcke **nicht** zu einem
+    zusammenzieht — ein Block über die Lücke quittiert der Adapter mit Fehlern.
+    """
+
+    register_space = "input"
+    max_span = 112
+    max_gap = 60
+
+    # Ventilatoren
+    drehzahl_zuluft = proxon_number(0, signed=True, unit="rpm")
+    drehzahl_abluft = proxon_number(1, signed=True, unit="rpm")
+    stufe_zuluft = proxon_number(154, signed=True)
+    stufe_abluft = proxon_number(211, signed=True)
+
+    # Leistung
+    power_pcb = proxon_number(19, scale=10, signed=True, unit="W")
+    power_fu = proxon_number(20, scale=10, signed=True, unit="W")
+    power_total = proxon_number(25, scale=10, signed=True, unit="W")
+
+    # Luft
+    co2_sensor1 = proxon_number(21, signed=True, unit="ppm")
+    rf_sensor1 = proxon_number(22, signed=True, unit="%")
+    druckventilator_pa = proxon_number(24, scale=10, signed=True, unit="Pa")
+    luftmenge_m3h = proxon_number(26, scale=10, signed=True, unit="m³/h")
+    umluft_aktiv = proxon_number(39, signed=True)
+
+    betriebsart = proxon_number(23, signed=True)
+
+    # Arbeitszahlen
+    jaz_komp_1h = proxon_number(28, scale=100, signed=True)
+    jaz_komp_24h = proxon_number(29, scale=100, signed=True)
+    jaz_total_1h = proxon_number(33, scale=100, signed=True)
+    jaz_total_24h = proxon_number(34, scale=100, signed=True)
+
+    # Temperaturen: roh = °C * 100
+    temp_hnbe = proxon_number(40, scale=100, min_raw=0, max_raw=4000, unit="°C")
+    temp_hbde = proxon_number(41, scale=100, min_raw=0, max_raw=4000, unit="°C")
+    t5_vorverdampfer = proxon_number(175, scale=100, min_raw=0, max_raw=6000, unit="°C")
+    t6_verdampfer = proxon_number(176, scale=100, min_raw=0, max_raw=6000, unit="°C")
+    t13_kompressor = proxon_number(180, scale=100, min_raw=0, max_raw=15000, unit="°C")
+    t9_aussenluft = proxon_number(181, scale=100, min_raw=0, max_raw=5000, unit="°C")
+    t1_zuluft = proxon_number(195, scale=100, min_raw=0, max_raw=6000, unit="°C")
+    t7_abluft = proxon_number(196, scale=100, min_raw=0, max_raw=6000, unit="°C")
+    t4_fortluft = proxon_number(197, scale=100, min_raw=0, max_raw=6000, unit="°C")
+    t3_frischluft = proxon_number(198, scale=100, min_raw=0, max_raw=6000, unit="°C")
+    t21_zone1 = proxon_number(263, scale=100, min_raw=0, max_raw=6000, unit="°C")
+    t22_zone2 = proxon_number(264, scale=100, min_raw=0, max_raw=6000, unit="°C")
+    soll_zone2 = proxon_number(251, scale=100, min_raw=1000, max_raw=3000, unit="°C")
+    soll_zone1 = proxon_number(265, scale=100, min_raw=1000, max_raw=3000, unit="°C")
+
+    # Kompressor
+    kompressor_status = proxon_number(162, signed=True)
+    kompressor_leistung = proxon_number(171, scale=100, signed=True, unit="%")
+    kompressor_drehzahl = proxon_number(190, signed=True, unit="rpm")
+
+    # Ventile / Zustände
+    schieber_position = proxon_number(159, signed=True)
+    erdwaerme_aktiv = proxon_number(220, signed=True)
+    magnetventil = proxon_number(221, signed=True)
+    bypass_zustand = proxon_number(222, signed=True)
+    vierwege_ventil = proxon_number(223, signed=True)
+
+    # Fehler
+    stoerung = proxon_number(47, signed=True)
+    error_status1 = proxon_number(48, signed=True)
+    error_status2 = proxon_number(49, signed=True)
+    error_status3 = proxon_number(50, signed=True)
+    error_status4 = proxon_number(51, signed=True)
+
+    @property
+    def filter_wechsel_faellig(self) -> bool | None:
+        """Bit 1 aus Fehlerstatus 1 — abgeleitet, kein eigenes Register."""
+        if self.error_status1 is None:
+            return None
+        return bool(int(self.error_status1) & 0x0002)
+
+
+class FwtHolding(Component):
+    """Lese-/Schreibregister der FWT (FC3/FC6).
+
+    460 und 467–469 antworten erst nach dem Freischalten von Register 438
+    (= 55555); ohne Unlock liefern sie Fehler, nicht etwa Nullen.
+    """
+
+    register_space = "holding"
+    max_span = 103
+    max_gap = 60
+
+    sollbetriebsart = proxon_number(16, min_raw=0, max_raw=9, writable=True)
+    luefterstufe = proxon_number(22, min_raw=1, max_raw=4, writable=True)
+    kuehlung_freigabe = proxon_number(62, min_raw=0, max_raw=1, writable=True)
+    betriebsart_wp = proxon_number(69)
+    schreibrechte = proxon_number(438)
+
+    soll_temp_zone1 = proxon_number(70, scale=100, signed=True, min_raw=1000, max_raw=3000, writable=True, unit="°C")
+    soll_temp_zone2 = proxon_number(75, scale=100, signed=True, min_raw=1000, max_raw=3000, writable=True, unit="°C")
+    intensivlueftung = proxon_number(133, min_raw=0, max_raw=1440, writable=True, unit="min")
+
+    # Schwellen (nur lesen)
+    wp_kuehlschwelle = proxon_number(41, scale=100, signed=True, unit="°C")
+    wp_einschaltschwelle = proxon_number(42, scale=100, signed=True, unit="°C")
+    wp_ausschaltschwelle = proxon_number(134, scale=100, signed=True, unit="°C")
+    frischluft_obergrenze = proxon_number(97, scale=100, signed=True, unit="°C")
+    frischluft_untergrenze = proxon_number(98, scale=100, signed=True, unit="°C")
+
+    # Sommerbypass
+    bypass_min_frischluft = proxon_number(19, scale=100, signed=True, min_raw=800, max_raw=2000, writable=True, unit="°C")
+    bypass_modus = proxon_number(21, min_raw=0, max_raw=2, writable=True)
+    bypass_hysterese = proxon_number(102, scale=100, signed=True, min_raw=0, max_raw=1000, writable=True, unit="K")
+    bypass_laufzeit = proxon_number(107, min_raw=10, max_raw=20, writable=True, unit="s")
+
+    # Bewusst ohne Bereichsschutz: ein Fremdframe soll hier keinen None-Wert
+    # erzeugen, sonst flackert die PTC-Freigabe im Frontend.
+    hbde_ptc_freigabe = proxon_number(187, writable=True)
+
+    # Nachtabsenkung
+    zeitprogramm_luft = proxon_number(613, min_raw=0, max_raw=1, writable=True)
+    nacht_temperatur = proxon_number(618, scale=100, signed=True, min_raw=1000, max_raw=3000, writable=True, unit="°C")
+    nachtabsenkung = proxon_number(619, min_raw=0, max_raw=1, writable=True)
+
+    # Filter / Stundenzähler — brauchen Unlock (Reg 438 = 55555)
+    geraetefilter_standzeit_monate = proxon_number(460, min_raw=3, max_raw=8, unit="Monate")
+    fwt_betriebsstunden = proxon_number(467, min_raw=0, max_raw=65535, unit="h")
+    umluft_betriebsstunden = proxon_number(468, min_raw=0, max_raw=65535, unit="h")
+    geraetefilter_stunden = proxon_number(469, min_raw=0, max_raw=65535, unit="h")
+
+    @property
+    def geraetefilter_remaining_days(self) -> float | None:
+        """Resttage bis Filterwechsel, aus Standzeit (460) und Laufzeit (469)."""
+        monate = self.geraetefilter_standzeit_monate
+        stunden = self.geraetefilter_stunden
+        if monate is None or stunden is None:
+            return None
+        remaining = ((monate * 30 * 24) - stunden) / 24
+        return round(max(0.0, remaining), 1)

proxon_modbus-0.1.1/src/proxon_modbus/nbe.py

@@ -0,0 +1,84 @@
+"""NBE-Nachheizregister und Raumnamen.
+
+Bis zu sieben physische NBE-Geräte, deren Register in drei parallelen Reihen
+liegen — je Gerät ein Schritt weiter:
+
+    Temperatur   Input   590 + n*3      (roh/10, gültig 100–400 = 10–40 °C)
+    Offset       Holding 213 + n        (vorzeichenbehaftet, -10…10 K)
+    Mitteltemp.  Holding 233 + n        (vorzeichenbehaftet, 10…35 °C)
+    PTC-Freigabe Holding 253 + n
+
+Die bestehende Integration bildet das mit `for n in range(7)` und
+Schlüsseln wie `nbe_temp_3` ab. Hier übernimmt `repeating_group(..., stride=…)`
+diese Arbeit: eine Deklaration, danach `rooms[n].temperatur`.
+
+Namen liegen getrennt davon in acht Slots à zehn Registern ab 620.
+Slot 0 ist die HBDE (Wohnen/Essen, **ohne** NBE-Sensor), Slot 1–7 gehören zu
+den physischen Geräten 0–6 — der Versatz um eins ist die häufigste
+Verwechslungsquelle in diesem Teil.
+"""
+
+from __future__ import annotations
+
+import re
+
+from modbus_connection.model import Component, repeating_group
+
+from .fields import latin1_string, proxon_number
+
+NBE_DEVICE_COUNT = 7
+NAME_SLOT_COUNT = 8
+NAME_REGS = 10
+
+# "Raum 1", "raum  3" … = Werkseinstellung, kein echter Name.
+_DEFAULT_NAME = re.compile(r"^Raum\s*\d+$", re.IGNORECASE)
+
+
+class NbeTemperature(Component):
+    """Ein NBE-Temperaturfühler (Input, Schrittweite 3)."""
+
+    register_space = "input"
+    temperatur = proxon_number(590, scale=10, min_raw=100, max_raw=400, unit="°C")
+
+
+class NbeSettings(Component):
+    """Einstellungen eines NBE-Geräts (Holding, Schrittweite 1)."""
+
+    register_space = "holding"
+    offset_k = proxon_number(213, signed=True, min_raw=-10, max_raw=10, writable=True, unit="K")
+    mitteltemperatur = proxon_number(233, signed=True, min_raw=10, max_raw=35, unit="°C")
+    ptc_freigabe = proxon_number(253, writable=True)
+
+
+class RoomNameSlot(Component):
+    """Ein Namens-Slot: zehn Register, 20 Latin-1-Zeichen."""
+
+    register_space = "holding"
+    name = latin1_string(620, NAME_REGS, writable=True)
+
+
+class NbeTemperatures(Component):
+    register_space = "input"
+    devices = repeating_group(NBE_DEVICE_COUNT, NbeTemperature, stride=3)
+
+
+class NbeSettingsBank(Component):
+    register_space = "holding"
+    devices = repeating_group(NBE_DEVICE_COUNT, NbeSettings, stride=1)
+
+
+class RoomNames(Component):
+    register_space = "holding"
+    slots = repeating_group(NAME_SLOT_COUNT, RoomNameSlot, stride=NAME_REGS)
+
+
+def is_configured_room(name: str | None) -> bool:
+    """True, wenn der Slot einen echten Namen trägt (nicht leer, nicht „Raum N")."""
+    if not name:
+        return False
+    return _DEFAULT_NAME.match(name) is None
+
+
+def physical_index(name_idx: int) -> int | None:
+    """Namens-Slot → physisches NBE-Gerät. Slot 0 (HBDE) hat keines."""
+    return None if name_idx == 0 else name_idx - 1

proxon_modbus-0.1.1/src/proxon_modbus/t300.py

@@ -0,0 +1,96 @@
+"""T300 Warmwasser-Wärmepumpe — Register-Modell.
+
+Erste portierte Baugruppe: klein (26 Register), in sich geschlossen und gegen
+echte Werte prüfbar. Adressen und Bereiche 1:1 aus
+`custom_components/proxon/const.py` (T300_INPUT_REGISTERS / T300_HOLDING_REGISTERS).
+
+Input und Holding sind getrennte Register-Räume, brauchen also je eine
+`Component`; `T300` fasst beide zusammen.
+"""
+
+from __future__ import annotations
+
+from modbus_connection import ModbusUnit
+from modbus_connection.model import Component
+
+from .fields import proxon_number
+
+# Die Anlage beantwortet den Block 811–900 am Stück; so liest ihn die
+# bestehende Integration seit je, und so ist er am 2026-09-02 gegen die echte
+# Bridge verifiziert.
+#
+# Ohne `max_gap` plant die Bibliothek stattdessen vier kleine Reads
+# (811+28, 861+2, 879+4, 899+2): weniger Register, aber **vier** Requests statt
+# einem. Auf dieser USR-Bridge ist jeder zusätzliche Request eine weitere
+# Gelegenheit, ein fremdes RS485-Frame als Antwort zu missdeuten — deshalb
+# bewusst ein Block. Die größte Lücke ist 838→861 (22 Register).
+#
+# ⚠️ Noch nicht gemessen, welche Variante die Bridge besser verträgt. Bei der
+# Migration nur *eine* Sache auf einmal ändern: erst die bewährte Blockform
+# übernehmen, Alternativen später gegen echte Hardware vergleichen.
+_T300_INPUT_SPAN = 90
+_T300_INPUT_MAX_GAP = 30
+_T300_HOLDING_SPAN = 26
+
+
+class T300Input(Component):
+    """Nur-Lese-Register der T300 (FC4)."""
+
+    register_space = "input"
+    max_span = _T300_INPUT_SPAN
+    max_gap = _T300_INPUT_MAX_GAP
+
+    # Temperaturen: roh = (°C * 10) + 1000, Bereich 500–2000 = -50…+100 °C
+    t5_vorverdampfer = proxon_number(811, scale=10, offset=-1000, min_raw=500, max_raw=2000, unit="°C")
+    t6_verdampfer = proxon_number(812, scale=10, offset=-1000, min_raw=500, max_raw=2000, unit="°C")
+    t20_behaelter_unten = proxon_number(813, scale=10, offset=-1000, min_raw=500, max_raw=2000, unit="°C")
+    t21_behaelter_mitte = proxon_number(814, scale=10, offset=-1000, min_raw=500, max_raw=2000, unit="°C")
+    t13_kompressor = proxon_number(815, scale=10, offset=-1000, min_raw=500, max_raw=2500, unit="°C")
+    t11_sauggas = proxon_number(816, scale=10, offset=-1000, min_raw=500, max_raw=2000, unit="°C")
+    t9_extern = proxon_number(817, scale=10, offset=-1000, min_raw=500, max_raw=2000, unit="°C")
+
+    behaelter_avg = proxon_number(882, scale=100, min_raw=1000, max_raw=10000, unit="°C")
+    solltemperatur_akt = proxon_number(879, scale=10, min_raw=200, max_raw=700, unit="°C")
+
+    # Relais
+    r2_kompressor = proxon_number(824)
+    r3_solar = proxon_number(825)
+    r4_eheiz = proxon_number(826)
+    r5_ventilator = proxon_number(827)
+    r6_abtau = proxon_number(828)
+
+    # Ventilator
+    ventilator_pct = proxon_number(838, unit="%")
+    ventilator_rpm = proxon_number(862, unit="rpm")
+
+    # PV
+    pv_eheiz = proxon_number(899)
+    pv_wp = proxon_number(900)
+
+    fehlerliste = proxon_number(861)
+
+
+class T300Holding(Component):
+    """Schreibbare Register der T300 (FC3/FC6)."""
+
+    register_space = "holding"
+    max_span = _T300_HOLDING_SPAN
+
+    solltemperatur = proxon_number(2000, scale=10, min_raw=200, max_raw=550, writable=True, unit="°C")
+    eheiz_freigabe = proxon_number(2001, min_raw=0, max_raw=1, writable=True)
+    betriebsart = proxon_number(2002, min_raw=0, max_raw=3, writable=True)
+    temp_eheiz = proxon_number(2003, scale=10, min_raw=200, max_raw=700, writable=True, unit="°C")
+    pv_funktion = proxon_number(2010, min_raw=0, max_raw=1, writable=True)
+    legionella = proxon_number(2025, min_raw=0, max_raw=1, writable=True)
+
+
+class T300:
+    """Beide Register-Räume der T300 hinter einer Fassade."""
+
+    def __init__(self, unit: ModbusUnit) -> None:
+        self.inputs = T300Input(unit)
+        self.holding = T300Holding(unit)
+
+    async def async_update(self) -> None:
+        await self.inputs.async_update()
+        await self.holding.async_update()

proxon_modbus-0.1.1/tests/test_device.py

@@ -0,0 +1,112 @@
+"""Gerätefassade: Freischaltung, Teilausfall, Schreibweg."""
+
+from __future__ import annotations
+
+import pytest
+from modbus_connection import ModbusError
+from modbus_connection.mock import MockModbusConnection
+
+from proxon_modbus.device import (
+    UNLOCK_REGISTER,
+    UNLOCK_VALUE,
+    ProxonDevice,
+    ProxonUnreachable,
+)
+
+
+def _seed(unit):
+    """Genug Register, dass jede Baugruppe etwas zu lesen findet."""
+    for addr in list(range(0, 52)) + list(range(154, 266)) + list(range(590, 611)):
+        unit.input[addr] = 0
+    for addr in list(range(811, 901)):
+        unit.input[addr] = 1000
+    for addr in (
+        list(range(16, 23)) + list(range(41, 144)) + [187]
+        + list(range(213, 260)) + [438, 460] + list(range(467, 470))
+        + list(range(613, 620)) + list(range(620, 700)) + list(range(2000, 2026))
+    ):
+        unit.holding[addr] = 0
+
+
+@pytest.fixture
+def conn():
+    c = MockModbusConnection()
+    _seed(c.for_unit(41))
+    return c
+
+
+@pytest.fixture
+def unit(conn):
+    return conn.for_unit(41)
+
+
+async def test_freischaltung_wird_einmal_geschrieben(unit):
+    writes = []
+    unit.on_write(lambda ev: writes.append(ev))
+
+    dev = ProxonDevice(unit)
+    await dev.async_update()
+    await dev.async_update()
+    await dev.async_update()
+
+    unlocks = [w for w in writes if getattr(w, "address", None) == UNLOCK_REGISTER]
+    assert len(unlocks) == 1, f"Freischaltung mehrfach geschrieben: {unlocks}"
+    assert unlocks[0].values == [UNLOCK_VALUE]
+
+
+async def test_freischaltung_nach_verbindungsverlust_erneut(conn, unit):
+    writes = []
+    unit.on_write(lambda ev: writes.append(ev))
+
+    dev = ProxonDevice(unit)
+    await dev.async_update()
+    conn.simulate_connection_lost()
+    await dev.async_update()
+
+    unlocks = [w for w in writes if getattr(w, "address", None) == UNLOCK_REGISTER]
+    assert len(unlocks) == 2, "nach Reconnect muss neu freigeschaltet werden"
+
+
+async def test_teilausfall_behaelt_alte_werte(unit):
+    """Ein kaputter Block darf den Rest nicht mitreißen."""
+    unit.input[263] = 2150
+    dev = ProxonDevice(unit)
+    await dev.async_update()
+    assert dev.fwt_input.t21_zone1 == 21.5
+
+    # T300-Input scheitert ab jetzt, FWT bleibt lesbar
+    unit.fail_read(811, ModbusError("Bus belegt"), register_type="input")
+    unit.input[263] = 2200
+    failed = await dev.async_update()
+
+    assert "T300Input" in failed
+    assert dev.fwt_input.t21_zone1 == 22.0        # FWT weiter aktuell
+    assert dev.t300_input.t21_behaelter_mitte is not None  # alter Wert bleibt
+
+
+async def test_kompletter_ausfall_wirft(unit):
+    unit.fail_requests(ModbusError("Adapter weg"))
+    dev = ProxonDevice(unit)
+
+    with pytest.raises(ProxonUnreachable):
+        await dev.async_update()
+
+
+async def test_ohne_t300_keine_t300_baugruppen(unit):
+    dev = ProxonDevice(unit, has_t300=False)
+    await dev.async_update()
+
+    assert dev.t300_input is None
+    assert not any("T300" in type(c).__name__ for c in dev.components)
+
+
+async def test_schreiben_schaltet_vorher_frei(unit):
+    writes = []
+    unit.on_write(lambda ev: writes.append(ev))
+
+    dev = ProxonDevice(unit)
+    await dev.async_write(dev.fwt_holding, "luefterstufe", 2)
+
+    adressen = [getattr(w, "address", None) for w in writes]
+    assert adressen[0] == UNLOCK_REGISTER, "Freischaltung muss zuerst kommen"
+    assert 22 in adressen

proxon_modbus-0.1.1/tests/test_fwt.py

@@ -0,0 +1,120 @@
+"""FWT-Modell gegen echte Registerwerte vom 2026-09-02 (Bridge 10.42.22.2).
+
+Mehrere Werte lassen sich gegen die damals in HA angezeigten Entities prüfen:
+  Reg  16 = 3    -> select.proxon_fwt_betriebsart == "Komfortbetrieb"
+  Reg  19 = 800  -> number.hwr_proxon_fwt_bypass_minimum_frischlufttemperatur == 8.0
+  Reg 618 = 1800 -> number.proxon_fwt_nachttemperatur == 18.0
+"""
+
+from __future__ import annotations
+
+import pytest
+from modbus_connection.mock import MockModbusConnection
+
+from proxon_modbus.fwt import Betriebsart, BypassModus, FwtHolding, FwtInput
+
+# input 0+ und 154+ (jeweils die protokollierten ersten Wörter)
+REAL_INPUT = {
+    0: 1872, 1: 1804,           # Drehzahlen Zu-/Abluft
+    154: 3, 155: 4900, 156: 5000, 157: 0, 158: 0, 159: 2,
+}
+# holding 16+, 41+, 460, 467+, 613+
+REAL_HOLDING = {
+    16: 3, 17: 0, 18: 1, 19: 800, 20: 900, 21: 0,
+    41: 300, 42: 40,
+    460: 6,
+    467: 34855, 468: 0, 469: 1706,
+    613: 0, 618: 1800, 619: 0,
+}
+
+
+@pytest.fixture
+def unit():
+    u = MockModbusConnection().for_unit(41)
+    u.input.update(REAL_INPUT)
+    u.holding.update(REAL_HOLDING)
+    return u
+
+
+async def test_input_echte_werte(unit):
+    fwt = FwtInput(unit)
+    await fwt.async_update()
+
+    assert fwt.drehzahl_zuluft == 1872
+    assert fwt.drehzahl_abluft == 1804
+    assert fwt.stufe_zuluft == 3
+    assert fwt.schieber_position == 2
+
+
+async def test_holding_echte_werte(unit):
+    fwt = FwtHolding(unit)
+    await fwt.async_update()
+
+    assert fwt.sollbetriebsart == 3            # == "Komfortbetrieb" in HA
+    assert fwt.bypass_min_frischluft == 8.0    # der auf 8 °C gesenkte Sommerbypass
+    assert fwt.bypass_modus == 0               # Geregelt (Automatik aktiv)
+    assert fwt.nacht_temperatur == 18.0        # == number.proxon_fwt_nachttemperatur
+    assert fwt.wp_kuehlschwelle == 3.0
+    assert fwt.wp_einschaltschwelle == 0.4
+
+
+async def test_betriebsart_enum_passt_zu_rohwert(unit):
+    fwt = FwtHolding(unit)
+    await fwt.async_update()
+    assert Betriebsart(int(fwt.sollbetriebsart)) is Betriebsart.KOMFORT
+    assert BypassModus(int(fwt.bypass_modus)) is BypassModus.GEREGELT
+
+
+async def test_filter_resttage(unit):
+    """Standzeit 6 Monate, 1706 h gelaufen -> (4320-1706)/24 = 108,9 Tage."""
+    fwt = FwtHolding(unit)
+    await fwt.async_update()
+
+    assert fwt.geraetefilter_standzeit_monate == 6
+    assert fwt.geraetefilter_stunden == 1706
+    assert fwt.geraetefilter_remaining_days == 108.9
+
+
+async def test_resttage_none_wenn_quelle_fehlt(unit):
+    """Ohne Unlock (Reg 438) liefern 460/469 nichts — dann kein Fantasiewert."""
+    u = MockModbusConnection().for_unit(41)
+    u.holding.update({k: v for k, v in REAL_HOLDING.items() if k not in (460, 469)})
+    fwt = FwtHolding(u)
+    await fwt.async_update()
+
+    assert fwt.geraetefilter_remaining_days is None
+
+
+@pytest.mark.parametrize(
+    "bit,erwartet", [(0b0000, False), (0b0010, True), (0b0011, True), (0b0001, False)]
+)
+async def test_filterwechsel_aus_fehlerstatus1(unit, bit, erwartet):
+    """Bit 1 aus Reg 48 — abgeleitet, nicht als eigenes Register gelesen."""
+    unit.input[48] = bit
+    fwt = FwtInput(unit)
+    await fwt.async_update()
+
+    assert fwt.filter_wechsel_faellig is erwartet
+
+
+async def test_negative_temperatur_wird_signiert_gelesen(unit):
+    """int16: Frischluft unter 0 °C darf nicht als 655 °C erscheinen."""
+    unit.holding[618] = 0x10000 - 500      # -5,00 °C
+    fwt = FwtHolding(unit)
+    await fwt.async_update()
+
+    # -500 liegt außerhalb min_raw=1000 -> Bereichsfilter greift, kein Unsinnwert
+    assert fwt.nacht_temperatur is None
+
+
+async def test_bereichsfilter_auf_zonentemperatur(unit):
+    """6000 = 60 °C ist die Obergrenze; darüber ist es ein Fremdframe."""
+    unit.input[263] = 6001
+    fwt = FwtInput(unit)
+    await fwt.async_update()
+    assert fwt.t21_zone1 is None
+
+    unit.input[263] = 2150
+    fwt2 = FwtInput(unit)
+    await fwt2.async_update()
+    assert fwt2.t21_zone1 == 21.5

proxon_modbus-0.1.1/tests/test_nbe.py

@@ -0,0 +1,104 @@
+"""NBE-Wiederholgruppen und Raumnamen."""
+
+from __future__ import annotations
+
+import pytest
+from modbus_connection.mock import MockModbusConnection
+
+from proxon_modbus.nbe import (
+    NbeSettingsBank,
+    NbeTemperatures,
+    RoomNames,
+    is_configured_room,
+    physical_index,
+)
+
+
+def _pack(text: str, regs: int = 10) -> dict[int, int]:
+    """Namen in Register packen, wie die Anlage sie ablegt."""
+    width = regs * 2
+    raw = text.encode("latin-1").ljust(width, b"\x00")
+    return {i // 2: (raw[i] << 8) | raw[i + 1] for i in range(0, width, 2)}
+
+
+@pytest.fixture
+def unit():
+    return MockModbusConnection().for_unit(41)
+
+
+async def test_temperaturen_liegen_im_dreierschritt(unit):
+    """Gerät n liest 590 + n*3 — nicht 590 + n."""
+    for n in range(7):
+        unit.input[590 + n * 3] = 200 + n * 10  # 20,0 °C aufsteigend
+    comp = NbeTemperatures(unit)
+    await comp.async_update()
+
+    werte = [d.temperatur for d in comp.devices]
+    assert werte == [20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0]
+
+
+async def test_settings_drei_parallele_reihen(unit):
+    """Offset/Mittel/PTC liegen 20 Register auseinander, Schrittweite 1."""
+    for n in range(7):
+        unit.holding[213 + n] = 0xFFFF if n == 0 else n      # n=0 → -1 K
+        unit.holding[233 + n] = 20 + n
+        unit.holding[253 + n] = n % 2
+    comp = NbeSettingsBank(unit)
+    await comp.async_update()
+
+    assert comp.devices[0].offset_k == -1
+    assert comp.devices[3].offset_k == 3
+    assert [d.mitteltemperatur for d in comp.devices] == [20, 21, 22, 23, 24, 25, 26]
+    assert [d.ptc_freigabe for d in comp.devices] == [0, 1, 0, 1, 0, 1, 0]
+
+
+async def test_offset_ausserhalb_bereich_wird_none(unit):
+    """-10…10 K ist der gültige Bereich; alles andere ist Busmüll."""
+    for n in range(7):
+        unit.holding[213 + n] = 0
+        unit.holding[233 + n] = 20
+        unit.holding[253 + n] = 0
+    unit.holding[213 + 2] = 99
+    comp = NbeSettingsBank(unit)
+    await comp.async_update()
+
+    assert comp.devices[2].offset_k is None
+    assert comp.devices[1].offset_k == 0
+
+
+async def test_raumnamen_latin1(unit):
+    """Umlaute müssen durchkommen — StringField der Lib kann das nicht."""
+    for base, text in ((620, "Wohnen/Essen"), (630, "Küche"), (640, "Büro")):
+        for rel, word in _pack(text).items():
+            unit.holding[base + rel] = word
+    comp = RoomNames(unit)
+    await comp.async_update()
+
+    assert comp.slots[0].name == "Wohnen/Essen"
+    assert comp.slots[1].name == "Küche"
+    assert comp.slots[2].name == "Büro"
+
+
+async def test_namen_slots_im_zehnerschritt(unit):
+    """Slot 7 liegt bei 620 + 7*10 = 690."""
+    for rel, word in _pack("Dachzimmer").items():
+        unit.holding[690 + rel] = word
+    comp = RoomNames(unit)
+    await comp.async_update()
+
+    assert comp.slots[7].name == "Dachzimmer"
+
+
+def test_werksnamen_gelten_nicht_als_konfiguriert():
+    assert is_configured_room("Küche")
+    assert not is_configured_room("Raum 1")
+    assert not is_configured_room("raum  3")
+    assert not is_configured_room("")
+    assert not is_configured_room(None)
+
+
+def test_slot_zu_geraet_versatz():
+    """Slot 0 = HBDE ohne Gerät; Slot 1 ist Gerät 0."""
+    assert physical_index(0) is None
+    assert physical_index(1) == 0
+    assert physical_index(7) == 6

proxon_modbus-0.1.1/tests/test_t300.py

@@ -0,0 +1,96 @@
+"""T300-Modell gegen echte Registerwerte.
+
+Die Rohwerte unten stammen aus dem Lauf gegen die echte Anlage am 2026-09-02
+(USR-Bridge 10.42.22.2:502, Slave 41) — nicht ausgedacht. `t21_behaelter_mitte`
+ist zusätzlich gegen den damals in HA angezeigten Wert (57,5 °C) abgeglichen.
+"""
+
+from __future__ import annotations
+
+import pytest
+from modbus_connection.mock import MockModbusConnection
+
+from proxon_modbus import T300
+
+# Gelesen wurden die Blöcke input 811+90 und holding 2000+26; protokolliert sind
+# jeweils die ersten sechs Wörter, also die Adressen 811–816 bzw. 2000–2005.
+# Nur diese stehen hier — 2010 und 2025 wurden nicht einzeln festgehalten und
+# werden deshalb nicht als Messwerte ausgegeben.
+REAL_INPUT = {811: 1218, 812: 1224, 813: 1403, 814: 1575, 815: 1348, 816: 1316}
+REAL_HOLDING = {2000: 520, 2001: 0, 2002: 1, 2003: 590}
+
+
+def _seed(unit, holding=None, inputs=None):
+    unit.input.update(inputs if inputs is not None else REAL_INPUT)
+    unit.holding.update(holding if holding is not None else REAL_HOLDING)
+
+
+@pytest.fixture
+def unit():
+    return MockModbusConnection().for_unit(41)
+
+
+async def test_temperaturen_echte_werte(unit):
+    """Offset-vor-Skalierung korrekt umgerechnet."""
+    _seed(unit)
+    t300 = T300(unit)
+    await t300.async_update()
+
+    assert t300.inputs.t21_behaelter_mitte == 57.5  # == HA-Sensor am 02.09.
+    assert t300.inputs.t5_vorverdampfer == 21.8
+    assert t300.inputs.t6_verdampfer == 22.4
+    assert t300.inputs.t20_behaelter_unten == 40.3
+    assert t300.inputs.t13_kompressor == 34.8
+
+
+async def test_holding_echte_werte(unit):
+    _seed(unit)
+    t300 = T300(unit)
+    await t300.async_update()
+
+    assert t300.holding.solltemperatur == 52.0
+    assert t300.holding.temp_eheiz == 59.0  # Boost-Ziel, wie dokumentiert
+    assert t300.holding.eheiz_freigabe == 0
+    assert t300.holding.betriebsart == 1
+
+
+async def test_naive_portierung_waere_falsch(unit):
+    """Absicherung gegen den Offset-Fehler: roh*0.1-1000 ergäbe -842.5."""
+    _seed(unit)
+    t300 = T300(unit)
+    await t300.async_update()
+
+    assert t300.inputs.t21_behaelter_mitte != pytest.approx(-842.5)
+    assert 0 < t300.inputs.t21_behaelter_mitte < 100
+
+
+@pytest.mark.parametrize("garbage", [0, 499, 2001, 65535])
+async def test_bereichsfilter_verwirft_muell(unit, garbage):
+    """Fremdframes der USR-Bridge (z. B. 128 °C Warmwasser) -> None statt Unsinn."""
+    _seed(unit, inputs={**REAL_INPUT, 814: garbage})
+    t300 = T300(unit)
+    await t300.async_update()
+
+    assert t300.inputs.t21_behaelter_mitte is None
+
+
+async def test_gueltige_randwerte_bleiben(unit):
+    """Die Grenzen selbst sind gültig — kein Off-by-one im Filter."""
+    for raw, expected in ((500, -50.0), (2000, 100.0)):
+        u = MockModbusConnection().for_unit(41)
+        _seed(u, inputs={**REAL_INPUT, 814: raw})
+        t300 = T300(u)
+        await t300.async_update()
+        assert t300.inputs.t21_behaelter_mitte == expected
+
+
+async def test_ein_request_pro_raum(unit):
+    """Der Planer soll je Raum einen Block lesen, nicht pro Feld einen."""
+    _seed(unit)
+    t300 = T300(unit)
+    await t300.async_update()
+
+    inputs = [e for e in unit.read_events if e.register_type == "input"]
+    holding = [e for e in unit.read_events if e.register_type == "holding"]
+    assert len(inputs) == 1, unit.read_events
+    assert len(holding) == 1, unit.read_events