feat(docs): Mark task 1.1 as done

Set the task 'Set up development environment for STM32/Zephyr' to done in all planning files.

README.de.md

@@ -0,0 +1,18 @@
+🇩🇪 Deutsch | [🇬🇧 English](README.md) | [🇫🇷 Français](README.fr.md) | [🇪🇸 Español](README.es.md)
+
+# Modulares Bewässerungssystem
+
+Dieses Projekt realisiert ein smartes, modulares Bewässerungssystem, das über Home Assistant gesteuert wird.
+
+## Dokumentation
+
+Die detaillierte Dokumentation befindet sich im Verzeichnis [`docs/`](./docs/):
+
+*   **[Konzept](./docs/concept.de.md)**: Beschreibt die Systemarchitektur, die verwendeten Komponenten und die grundlegenden Design-Entscheidungen.
+*   **[MODBUS Register](./docs/modbus-registers.de.md)**: Definiert die Register-Map für die Kommunikation mit den Slave-Nodes.
+*   **[Projektplan](./docs/planning.de.md)**: Enthält den Entwicklungs- und Implementierungsplan.
+
+## Schnellstart
+
+*   **Hardware**: Die KiCad-Dateien für die Hardware befinden sich im Verzeichnis [`hardware/`](./hardware/).
+*   **Software**: Die Zephyr-basierte Firmware für die Slave-Nodes befindet sich im Verzeichnis [`software/`](./software/).

README.es.md

@@ -0,0 +1,18 @@
+[🇩🇪 Deutsch](README.de.md) | [🇬🇧 English](README.md) | [🇫🇷 Français](README.fr.md) | 🇪🇸 Español
+
+# Sistema de riego modular
+
+Este proyecto implementa un sistema de riego inteligente y modular controlado a través de Home Assistant.
+
+## Documentación
+
+La documentación detallada se puede encontrar en el directorio [`docs/`](./docs/):
+
+*   **[Concepto](./docs/concept.es.md)**: Describe la arquitectura del sistema, los componentes utilizados y las decisiones de diseño básicas.
+*   **[Registros MODBUS](./docs/modbus-registers.es.md)**: Define el mapa de registros para la comunicación con los nodos esclavos.
+*   **[Plan del proyecto](./docs/planning.es.md)**: Contiene el plan de desarrollo e implementación.
+
+## Inicio rápido
+
+*   **Hardware**: Los archivos KiCad para el hardware se encuentran en el directorio [`hardware/`](./hardware/).
+*   **Software**: El firmware basado en Zephyr para los nodos esclavos se encuentra en el directorio [`software/`](./software/).

README.fr.md

@@ -0,0 +1,18 @@
+[🇩🇪 Deutsch](README.de.md) | [🇬🇧 English](README.md) | 🇫🇷 Français | [🇪🇸 Español](README.es.md)
+
+# Système d'irrigation modulaire
+
+Ce projet met en œuvre un système d'irrigation intelligent et modulaire contrôlé via Home Assistant.
+
+## Documentation
+
+La documentation détaillée se trouve dans le répertoire [`docs/`](./docs/) :
+
+*   **[Concept](./docs/concept.fr.md)** : Décrit l'architecture du système, les composants utilisés et les décisions de conception de base.
+*   **[Registres MODBUS](./docs/modbus-registers.fr.md)** : Définit la carte des registres pour la communication avec les nœuds esclaves.
+*   **[Plan du projet](./docs/planning.fr.md)** : Contient le plan de développement et de mise en œuvre.
+
+## Démarrage rapide
+
+*   **Matériel** : Les fichiers KiCad pour le matériel se trouvent dans le répertoire [`hardware/`](./hardware/).
+*   **Logiciel** : Le firmware basé sur Zephyr pour les nœuds esclaves se trouve dans le répertoire [`software/`](./software/).

README.md

@@ -1,2 +1,18 @@
-# Home assistant irrigation system
-This is a home assistant irrigation system
+[🇩🇪 Deutsch](README.de.md) | 🇬🇧 English | [🇫🇷 Français](README.fr.md) | [🇪🇸 Español](README.es.md)
+
+# Modular Irrigation System
+
+This project implements a smart, modular irrigation system controlled via Home Assistant.
+
+## Documentation
+
+The detailed documentation can be found in the [`docs/`](./docs/) directory:
+
+*   **[Concept](./docs/concept.en.md)**: Describes the system architecture, the components used, and the basic design decisions.
+*   **[MODBUS Registers](./docs/modbus-registers.en.md)**: Defines the register map for communication with the slave nodes.
+*   **[Project Plan](./docs/planning.en.md)**: Contains the development and implementation plan.
+
+## Quick Start
+
+*   **Hardware**: The KiCad files for the hardware are located in the [`hardware/`](./hardware/) directory.
+*   **Software**: The Zephyr-based firmware for the slave nodes is located in the [`software/`](./software/) directory.

docs/concept.de.md

@@ -0,0 +1,75 @@
+🇩🇪 Deutsch | [🇬🇧 English](concept.en.md) | [🇫🇷 Français](concept.fr.md) | [🇪🇸 Español](concept.es.md)
+
+# Konzept: Modulares Bewässerungssystem
+
+Dieses Dokument beschreibt das Konzept für ein modulares, smartes Bewässerungssystem, das zentral über Home Assistant gesteuert wird.
+
+## 1. Architekturübersicht
+
+Das System ist in drei logische Ebenen aufgeteilt, um eine hohe Flexibilität und Wartbarkeit zu gewährleisten:
+
+1.  **Steuerungs-Ebene (Home Assistant):** Die gesamte Logik, alle Automationen und die Benutzeroberfläche residieren in Home Assistant. Dies ist das "Gehirn" des Systems.
+2.  **Gateway-Ebene (ESP32):** Ein reiner Protokoll-Übersetzer, der als Brücke zwischen dem Heimnetzwerk (WLAN/Thread) und dem physischen Bus-System der Anlage fungiert. Er enthält keine eigene Steuerungslogik.
+3.  **Aktor-/Sensor-Ebene (Slave-Nodes):** Robuste, spezialisierte Baugruppen, die über einen Bus angesteuert werden und die eigentlichen Aufgaben ausführen (Ventile schalten, Sensoren auslesen).
+
+![Systemarchitektur](./img/architecture.de.svg)
+
+## 2. Systemkomponenten
+
+* **Wassertank:** Ein IBC-Container dient als Wasserreservoir.
+* **Wasserzufuhr:** Ein "Regendieb" am Fallrohr leitet Regenwasser in den Tank.
+* **Pumpe:** Eine Pumpe mit integriertem Druckausgleichsbehälter sorgt für den nötigen Wasserdruck.
+* **Aktoren:** Motorisierte 12V-Kugelhähne zur Steuerung der Wasserabgänge.
+* **Füllstandsensor (präzise):** Ein `QDY30A` mit 4-20mA Ausgang und RS485/MODBUS-Schnittstelle zur kontinuierlichen Messung des Wasserpegels.
+* **Füllstandsensoren (Min/Max):** Optionale kapazitive Sensoren (`XKC-Y25-NPN` o.ä.) als redundante Absicherung gegen Leerlauf und Überlauf.
+
+## 3. Gateway
+
+Die zentrale Kommunikationsschnittstelle wird als "dummes" Gateway realisiert.
+
+* **Hardware:** Ein `ESP32C6`-basiertes Board.
+* **Funktion:** Das Gateway agiert als transparenter **MODBUS TCP/IP zu MODBUS RTU Konverter**. Es empfängt Befehle aus dem Heimnetzwerk und leitet sie an den RS485-Bus weiter und umgekehrt. Es führt keine eigene Steuerungslogik aus.
+* **Anbindung an Home Assistant:** Die Verbindung erfolgt über das Heimnetzwerk, wahlweise per WLAN oder zukünftig eventuell über Thread/Matter. In Home Assistant wird die offizielle MODBUS-Integration genutzt, um das Gateway und die dahinterliegenden Slaves direkt zu adressieren.
+
+## 4. Slave-Nodes
+
+Die Slave-Nodes sind die Arbeitseinheiten im Feld. Um bei der Fertigung kleiner Stückzahlen (z.B. bei JLCPCB) den Aufwand gering zu halten, wird ein universelles Platinen-Design für alle Slave-Typen angestrebt.
+
+* **Mikrocontroller:** Ein `STM32G431PB`. Dieser ist zwar leistungsstark, bietet aber alle nötigen Peripherien (mehrere UARTs, ADCs, CAN) und ermöglicht ein einheitliches Hardware- und Software-Design.
+* **Peripherie pro Node:**
+    * **Zwei High-Side Ausgänge (+12V):** Realisiert über einen `VND7050AJ`. Perfekt zur Ansteuerung der 12V-Motorventile (`Öffnen`/`Schliessen`). Die `Sense`-Leitung des Treibers wird über einen AD-Wandler ausgelesen, um durch Messung des Motorstroms eine Endlagen-Erkennung ohne physische Endschalter zu realisieren (Motorstrom im Stillstand ≈ 0).
+    * **Zwei Low-Side Ausgänge (0V):** Über N-Kanal-MOSFETs geschaltete Ausgänge. Nutzbar zur Ansteuerung von 12V-LEDs in Tastern oder zum Schalten des Halbleiter-Relais für die Pumpe.
+    * **Zwei digitale Eingänge:** Direkte, geschützte Eingänge am Controller zum Anschluss von Tastern oder den kapazitiven NPN-Sensoren.
+
+## 5. Bussystem: MODBUS-RTU über RS485
+
+Als Bussystem wird konsequent auf MODBUS-RTU gesetzt.
+
+* **Begründung:** Diese Wahl ist pragmatisch, da der Füllstandsensor bereits MODBUS voraussetzt. So wird für das gesamte System nur ein einziges, einfaches und weit verbreitetes Protokoll benötigt.
+* **Physische Schicht:** Die Verkabelung erfolgt über RS485. Es wird handelsübliches Cat-7-Ethernetkabel mit RJ45-Steckern verwendet:
+    * 1 Adernpaar (verdrillt) für die Bus-Signale `A` und `B`.
+    * 3 Adernpaare parallel für `+12V` und `GND` zur Stromversorgung der Slaves.
+
+## 6. Software
+
+* **Betriebssystem (Slaves):** `Zephyr OS`. Es ist ein modernes, leistungsfähiges Echtzeitbetriebssystem, das eine saubere und wartbare Firmware-Struktur ermöglicht.
+* **Logik-Implementierung:** Die gesamte Steuerungslogik (z.B. "Wenn Füllstand < 20% und Wochentag = Montag, dann schalte Ventil 3 für 10 Minuten ein") wird ausschliesslich in **Home Assistant** über dessen Automatisierungs-Engine abgebildet.
+
+### 6.1. Firmware-Update der Slaves (OTA)
+
+Die Firmware der Slaves kann im laufenden Betrieb über den Bus aktualisiert werden, ohne dass ein direkter physischer Zugriff nötig ist.
+
+* **Konzept:** Es wird der `MCUBoot`-Bootloader genutzt. Dieser ist vom Kommunikationsprotokoll entkoppelt.
+* **Ablauf:**
+    1.  Ein Skript in Home Assistant liest die neue Firmware-Datei (`firmware.bin`).
+    2.  Das Skript zerlegt die Datei in kleine Datenpakete und sendet diese nacheinander per MODBUS-Befehl an den Ziel-Slave.
+    3.  Die laufende Applikation auf dem Slave empfängt diese Pakete und schreibt sie direkt in den sekundären Flash-Speicher ("Update-Slot").
+    4.  Nach erfolgreicher Übertragung wird der Slave per Befehl neu gestartet.
+    5.  `MCUBoot` prüft die Signatur des neuen Images, kopiert es in den primären Slot und startet es.
+* **Sicherheit:** Die neue Firmware muss sich nach dem Start selbst als "funktionstüchtig" markieren. Tut sie dies nicht (z.B. wegen eines Absturzes), wird beim nächsten Neustart durch den Watchdog automatisch die vorherige, stabile Firmware-Version von `MCUBoot` wiederhergestellt.
+
+## 7. Sicherheits- und Robustheitskonzepte
+
+* **Fail-Safe-Verhalten:** Jeder Slave-Node implementiert einen Watchdog. Wenn über eine definierte Zeit (z.B. 15 Sekunden) keine gültige MODBUS-Abfrage vom Gateway eintrifft, geht der Slave in einen sicheren Zustand über: Alle Ventile werden geschlossen und Relais (z.B. für die Pumpe) werden ausgeschaltet.
+* **Elektrische Schutzschaltungen:** Alle externen Schnittstellen werden geschützt. Die RS485-Busleitungen (`A`/`B`) werden auf jeder Platine mit TVS-Dioden gegen Überspannungen gesichert. Eingänge und Ausgänge erhalten einen Basis-ESD-Schutz.
+* **Stromversorgung:** Die 12V-Busspannung wird auf jedem Slave-Node mit einem effizienten `TPS5430DDAR` Step-Down-Wandler auf die benötigten 3.3V für den Mikrocontroller und die Bustreiber geregelt.

docs/concept.en.md

@@ -0,0 +1,75 @@
+[🇩🇪 Deutsch](concept.de.md) | 🇬🇧 English | [🇫🇷 Français](concept.fr.md) | [🇪🇸 Español](concept.es.md)
+
+# Concept: Modular Irrigation System
+
+This document describes the concept for a modular, smart irrigation system that is centrally controlled via Home Assistant.
+
+## 1. Architecture Overview
+
+The system is divided into three logical layers to ensure high flexibility and maintainability:
+
+1.  **Control Layer (Home Assistant):** All logic, automations, and the user interface reside in Home Assistant. This is the "brain" of the system.
+2.  **Gateway Layer (ESP32):** A pure protocol translator that acts as a bridge between the home network (WLAN/Thread) and the physical bus system of the plant. It contains no control logic of its own.
+3.  **Actor/Sensor Layer (Slave Nodes):** Robust, specialized modules that are controlled via a bus and perform the actual tasks (switching valves, reading sensors).
+
+![System Architecture](./img/architecture.en.svg)
+
+## 2. System Components
+
+* **Water Tank:** An IBC container serves as a water reservoir.
+* **Water Supply:** A "rain thief" on the downpipe directs rainwater into the tank.
+* **Pump:** A pump with an integrated pressure expansion tank provides the necessary water pressure.
+* **Actuators:** Motorized 12V ball valves to control the water outlets.
+* **Level Sensor (precise):** A `QDY30A` with 4-20mA output and RS485/MODBUS interface for continuous measurement of the water level.
+* **Level Sensors (Min/Max):** Optional capacitive sensors (`XKC-Y25-NPN` or similar) as redundant protection against running dry and overflowing.
+
+## 3. Gateway
+
+The central communication interface is implemented as a "dumb" gateway.
+
+* **Hardware:** An `ESP32C6`-based board.
+* **Function:** The gateway acts as a transparent **MODBUS TCP/IP to MODBUS RTU converter**. It receives commands from the home network and forwards them to the RS485 bus and vice versa. It does not execute its own control logic.
+* **Connection to Home Assistant:** The connection is made via the home network, either via WLAN or in the future possibly via Thread/Matter. In Home Assistant, the official MODBUS integration is used to address the gateway and the slaves behind it directly.
+
+## 4. Slave Nodes
+
+The slave nodes are the working units in the field. To keep the effort low for small series production (e.g. at JLCPCB), a universal board design for all slave types is sought.
+
+* **Microcontroller:** An `STM32G431PB`. Although powerful, it offers all the necessary peripherals (multiple UARTs, ADCs, CAN) and enables a uniform hardware and software design.
+* **Peripherals per Node:**
+    * **Two High-Side Outputs (+12V):** Realized via a `VND7050AJ`. Perfect for controlling the 12V motor valves (`Open`/`Close`). The `Sense` line of the driver is read out via an AD converter to realize an end position detection without physical limit switches by measuring the motor current (motor current at standstill ≈ 0).
+    * **Two Low-Side Outputs (0V):** Outputs switched via N-channel MOSFETs. Can be used to control 12V LEDs in buttons or to switch the solid-state relay for the pump.
+    * **Two digital inputs:** Direct, protected inputs on the controller for connecting buttons or the capacitive NPN sensors.
+
+## 5. Bus System: MODBUS-RTU via RS485
+
+MODBUS-RTU is consistently used as the bus system.
+
+* **Reasoning:** This choice is pragmatic, as the level sensor already requires MODBUS. This means that only a single, simple and widespread protocol is required for the entire system.
+* **Physical Layer:** The cabling is done via RS485. Commercially available Cat-7 Ethernet cable with RJ45 plugs is used:
+    * 1 twisted pair for the bus signals `A` and `B`.
+    * 3 pairs of wires in parallel for `+12V` and `GND` to supply power to the slaves.
+
+## 6. Software
+
+* **Operating System (Slaves):** `Zephyr OS`. It is a modern, powerful real-time operating system that enables a clean and maintainable firmware structure.
+* **Logic Implementation:** The entire control logic (e.g. "If level < 20% and day of the week = Monday, then switch on valve 3 for 10 minutes") is mapped exclusively in **Home Assistant** via its automation engine.
+
+### 6.1. Firmware Update of the Slaves (OTA)
+
+The firmware of the slaves can be updated during operation via the bus without the need for direct physical access.
+
+* **Concept:** The `MCUBoot` bootloader is used. This is decoupled from the communication protocol.
+* **Procedure:**
+    1.  A script in Home Assistant reads the new firmware file (`firmware.bin`).
+    2.  The script breaks the file down into small data packets and sends them one after the other to the target slave via MODBUS command.
+    3.  The running application on the slave receives these packets and writes them directly to the secondary flash memory ("update slot").
+    4.  After successful transmission, the slave is restarted by command.
+    5.  `MCUBoot` checks the signature of the new image, copies it to the primary slot and starts it.
+* **Security:** The new firmware must mark itself as "functional" after starting. If it does not do this (e.g. due to a crash), the previous, stable firmware version is automatically restored by `MCUBoot` on the next restart by the watchdog.
+
+## 7. Safety and Robustness Concepts
+
+* **Fail-Safe Behavior:** Each slave node implements a watchdog. If no valid MODBUS query is received from the gateway over a defined period of time (e.g. 15 seconds), the slave goes into a safe state: all valves are closed and relays (e.g. for the pump) are switched off.
+* **Electrical Protection Circuits:** All external interfaces are protected. The RS485 bus lines (`A`/`B`) are protected against overvoltages with TVS diodes on each board. Inputs and outputs receive basic ESD protection.
+* **Power Supply:** The 12V bus voltage is regulated on each slave node with an efficient `TPS5430DDAR` step-down converter to the required 3.3V for the microcontroller and the bus drivers.

docs/concept.es.md

@@ -0,0 +1,75 @@
+[🇩🇪 Deutsch](concept.de.md) | [🇬🇧 English](concept.en.md) | [🇫🇷 Français](concept.fr.md) | 🇪🇸 Español
+
+# Concepto: Sistema de riego modular
+
+Este documento describe el concepto de un sistema de riego modular e inteligente, controlado de forma centralizada a través de Home Assistant.
+
+## 1. Descripción general de la arquitectura
+
+El sistema se divide en tres capas lógicas para garantizar una alta flexibilidad y mantenibilidad:
+
+1.  **Capa de control (Home Assistant):** Toda la lógica, las automatizaciones y la interfaz de usuario residen en Home Assistant. Este es el "cerebro" del sistema.
+2.  **Capa de puerta de enlace (ESP32):** Un puro traductor de protocolos que actúa como puente entre la red doméstica (WLAN/Thread) y el sistema de bus físico de la planta. No contiene lógica de control propia.
+3.  **Capa de actuadores/sensores (nodos esclavos):** Módulos robustos y especializados que se controlan a través de un bus y realizan las tareas reales (conmutación de válvulas, lectura de sensores).
+
+![Arquitectura del sistema](./img/architecture.es.svg)
+
+## 2. Componentes del sistema
+
+*   **Depósito de agua:** Un contenedor IBC sirve como depósito de agua.
+*   **Suministro de agua:** Un "ladrón de lluvia" en el bajante dirige el agua de lluvia al depósito.
+*   **Bomba:** Una bomba con un tanque de expansión de presión integrado proporciona la presión de agua necesaria.
+*   **Actuadores:** Válvulas de bola motorizadas de 12V para controlar las salidas de agua.
+*   **Sensor de nivel (preciso):** Un `QDY30A` con salida de 4-20mA e interfaz RS485/MODBUS para la medición continua del nivel del agua.
+*   **Sensores de nivel (Min/Max):** Sensores capacitivos opcionales (`XKC-Y25-NPN` o similar) como protección redundante contra el funcionamiento en seco y el desbordamiento.
+
+## 3. Puerta de enlace
+
+La interfaz de comunicación central se implementa como una puerta de enlace "tonta".
+
+*   **Hardware:** Una placa basada en `ESP32C6`.
+*   **Función:** La puerta de enlace actúa como un **convertidor transparente de MODBUS TCP/IP a MODBUS RTU**. Recibe comandos de la red doméstica y los reenvía al bus RS485 y viceversa. No ejecuta su propia lógica de control.
+*   **Conexión a Home Assistant:** La conexión se realiza a través de la red doméstica, ya sea a través de WLAN o en el futuro posiblemente a través de Thread/Matter. En Home Assistant, la integración oficial de MODBUS se utiliza para direccionar directamente la puerta de enlace y los esclavos detrás de ella.
+
+## 4. Nodos esclavos
+
+Los nodos esclavos son las unidades de trabajo en el campo. Para mantener bajo el esfuerzo en la producción de series pequeñas (por ejemplo, en JLCPCB), se busca un diseño de placa universal para todos los tipos de esclavos.
+
+*   **Microcontrolador:** Un `STM32G431PB`. Aunque potente, ofrece todos los periféricos necesarios (múltiples UART, ADC, CAN) y permite un diseño de hardware y software uniforme.
+*   **Periféricos por nodo:**
+    *   **Dos salidas de lado alto (+12V):** Realizadas a través de un `VND7050AJ`. Perfecto para controlar las válvulas de motor de 12V (`Abrir`/`Cerrar`). La línea `Sense` del controlador se lee a través de un convertidor AD para realizar una detección de posición final sin interruptores de límite físicos midiendo la corriente del motor (corriente del motor en reposo ≈ 0).
+    *   **Dos salidas de lado bajo (0V):** Salidas conmutadas a través de MOSFET de canal N. Se pueden utilizar para controlar LED de 12V en botones o para conmutar el relé de estado sólido para la bomba.
+    *   **Dos entradas digitales:** Entradas directas y protegidas en el controlador para conectar botones o los sensores NPN capacitivos.
+
+## 5. Sistema de bus: MODBUS-RTU a través de RS485
+
+MODBUS-RTU se utiliza de forma consistente como sistema de bus.
+
+*   **Justificación:** Esta elección es pragmática, ya que el sensor de nivel ya requiere MODBUS. Esto significa que solo se requiere un único protocolo simple y extendido para todo el sistema.
+*   **Capa física:** El cableado se realiza a través de RS485. Se utiliza un cable Ethernet Cat-7 disponible en el mercado con conectores RJ45:
+    *   1 par trenzado para las señales de bus `A` y `B`.
+    *   3 pares de cables en paralelo para `+12V` y `GND` para suministrar energía a los esclavos.
+
+## 6. Software
+
+*   **Sistema operativo (esclavos):** `Zephyr OS`. Es un sistema operativo en tiempo real moderno y potente que permite una estructura de firmware limpia y mantenible.
+*   **Implementación de la lógica:** Toda la lógica de control (por ejemplo, "Si el nivel < 20% y el día de la semana = lunes, entonces enciende la válvula 3 durante 10 minutos") se asigna exclusivamente en **Home Assistant** a través de su motor de automatización.
+
+### 6.1. Actualización del firmware de los esclavos (OTA)
+
+El firmware de los esclavos se puede actualizar durante el funcionamiento a través del bus sin necesidad de acceso físico directo.
+
+*   **Concepto:** Se utiliza el cargador de arranque `MCUBoot`. Este está desacoplado del protocolo de comunicación.
+*   **Procedimiento:**
+    1.  Un script en Home Assistant lee el nuevo archivo de firmware (`firmware.bin`).
+    2.  El script divide el archivo en pequeños paquetes de datos y los envía uno tras otro al esclavo de destino mediante un comando MODBUS.
+    3.  La aplicación en ejecución en el esclavo recibe estos paquetes y los escribe directamente en la memoria flash secundaria ("ranura de actualización").
+    4.  Después de una transmisión exitosa, el esclavo se reinicia por comando.
+    5.  `MCUBoot` comprueba la firma de la nueva imagen, la copia en la ranura principal y la inicia.
+*   **Seguridad:** El nuevo firmware debe marcarse a sí mismo como "funcional" después de iniciarse. Si no lo hace (por ejemplo, debido a un bloqueo), la versión de firmware anterior y estable es restaurada automáticamente por `MCUBoot` en el siguiente reinicio por el watchdog.
+
+## 7. Conceptos de seguridad y robustez
+
+*   **Comportamiento a prueba de fallos:** Cada nodo esclavo implementa un watchdog. Si no se recibe ninguna consulta MODBUS válida de la puerta de enlace durante un período de tiempo definido (por ejemplo, 15 segundos), el esclavo pasa a un estado seguro: todas las válvulas se cierran y los relés (por ejemplo, para la bomba) se apagan.
+*   **Circuitos de protección eléctrica:** Todas las interfaces externas están protegidas. Las líneas de bus RS485 (`A`/`B`) están protegidas contra sobretensiones con diodos TVS en cada placa. Las entradas y salidas reciben protección ESD básica.
+*   **Fuente de alimentación:** La tensión del bus de 12V se regula en cada nodo esclavo con un convertidor reductor `TPS5430DDAR` eficiente a los 3.3V necesarios para el microcontrolador y los controladores del bus.

docs/concept.fr.md

@@ -0,0 +1,75 @@
+[🇩🇪 Deutsch](concept.de.md) | [🇬🇧 English](concept.en.md) | 🇫🇷 Français | [🇪🇸 Español](concept.es.md)
+
+# Concept : Système d'irrigation modulaire
+
+Ce document décrit le concept d'un système d'irrigation modulaire et intelligent, contrôlé de manière centralisée via Home Assistant.
+
+## 1. Aperçu de l'architecture
+
+Le système est divisé en trois couches logiques pour garantir une flexibilité et une maintenabilité élevées :
+
+1.  **Couche de contrôle (Home Assistant) :** Toute la logique, les automatisations et l'interface utilisateur résident dans Home Assistant. C'est le "cerveau" du système.
+2.  **Couche de passerelle (ESP32) :** Un simple traducteur de protocole qui sert de pont entre le réseau domestique (WLAN/Thread) et le système de bus physique de l'installation. Il ne contient aucune logique de contrôle propre.
+3.  **Couche d'acteurs/capteurs (nœuds esclaves) :** Des modules robustes et spécialisés, commandés via un bus, qui exécutent les tâches réelles (commutation de vannes, lecture de capteurs).
+
+![Architecture du système](./img/architecture.fr.svg)
+
+## 2. Composants du système
+
+*   **Réservoir d'eau :** Un conteneur IBC sert de réservoir d'eau.
+*   **Alimentation en eau :** Un "récupérateur d'eau de pluie" sur le tuyau de descente dirige l'eau de pluie dans le réservoir.
+*   **Pompe :** Une pompe avec un vase d'expansion intégré assure la pression d'eau nécessaire.
+*   **Actionneurs :** Des vannes à boisseau sphérique motorisées de 12V pour contrôler les sorties d'eau.
+*   **Capteur de niveau (précis) :** Un `QDY30A` avec une sortie 4-20mA et une interface RS485/MODBUS pour la mesure continue du niveau d'eau.
+*   **Capteurs de niveau (Min/Max) :** Des capteurs capacitifs optionnels (`XKC-Y25-NPN` ou similaire) comme protection redondante contre le fonctionnement à sec et le débordement.
+
+## 3. Passerelle
+
+L'interface de communication centrale est réalisée sous la forme d'une passerelle "stupide".
+
+*   **Matériel :** Une carte basée sur `ESP32C6`.
+*   **Fonction :** La passerelle agit comme un **convertisseur transparent MODBUS TCP/IP vers MODBUS RTU**. Elle reçoit les commandes du réseau domestique et les transmet au bus RS485 et vice versa. Elle n'exécute aucune logique de contrôle propre.
+*   **Connexion à Home Assistant :** La connexion se fait via le réseau domestique, soit par WLAN, soit à l'avenir éventuellement par Thread/Matter. Dans Home Assistant, l'intégration MODBUS officielle est utilisée pour adresser directement la passerelle et les esclaves qui se trouvent derrière.
+
+## 4. Nœuds esclaves
+
+Les nœuds esclaves sont les unités de travail sur le terrain. Pour réduire les efforts lors de la production en petites séries (par ex. chez JLCPCB), un design de platine universel pour tous les types d'esclaves est visé.
+
+*   **Microcontrôleur :** Un `STM32G431PB`. Bien que puissant, il offre toutes les périphériques nécessaires (plusieurs UART, ADC, CAN) et permet une conception matérielle et logicielle uniforme.
+*   **Périphériques par nœud :**
+    *   **Deux sorties High-Side (+12V) :** Réalisées via un `VND7050AJ`. Parfait pour commander les vannes motorisées 12V (`Ouvrir`/`Fermer`). La ligne `Sense` du pilote est lue via un convertisseur AN pour réaliser une détection de fin de course sans interrupteurs de fin de course physiques en mesurant le courant du moteur (courant du moteur à l'arrêt ≈ 0).
+    *   **Deux sorties Low-Side (0V) :** Sorties commutées via des MOSFET à canal N. Utilisables pour commander des LED 12V dans des boutons-poussoirs ou pour commuter le relais à semi-conducteurs pour la pompe.
+    *   **Deux entrées numériques :** Entrées directes et protégées sur le contrôleur pour connecter des boutons-poussoirs ou les capteurs NPN capacitifs.
+
+## 5. Système de bus : MODBUS-RTU via RS485
+
+Le système de bus repose systématiquement sur MODBUS-RTU.
+
+*   **Justification :** Ce choix est pragmatique, car le capteur de niveau requiert déjà MODBUS. Ainsi, un seul protocole simple et largement répandu est nécessaire pour l'ensemble du système.
+*   **Couche physique :** Le câblage est réalisé via RS485. Un câble Ethernet Cat-7 du commerce avec des connecteurs RJ45 est utilisé :
+    *   1 paire torsadée pour les signaux de bus `A` et `B`.
+    *   3 paires de fils en parallèle pour `+12V` et `GND` pour l'alimentation des esclaves.
+
+## 6. Logiciel
+
+*   **Système d'exploitation (esclaves) :** `Zephyr OS`. C'est un système d'exploitation temps réel moderne et performant qui permet une structure de firmware propre et maintenable.
+*   **Implémentation de la logique :** Toute la logique de commande (par ex. "Si niveau < 20% et jour de la semaine = Lundi, alors activer la vanne 3 pendant 10 minutes") est exclusivement représentée dans **Home Assistant** via son moteur d'automatisation.
+
+### 6.1. Mise à jour du firmware des esclaves (OTA)
+
+Le firmware des esclaves peut être mis à jour en cours de fonctionnement via le bus, sans nécessiter d'accès physique direct.
+
+*   **Concept :** Le bootloader `MCUBoot` est utilisé. Celui-ci est découplé du protocole de communication.
+*   **Déroulement :**
+    1.  Un script dans Home Assistant lit le nouveau fichier de firmware (`firmware.bin`).
+    2.  Le script décompose le fichier en petits paquets de données et les envoie successivement à l'esclave cible par commande MODBUS.
+    3.  L'application en cours d'exécution sur l'esclave reçoit ces paquets et les écrit directement dans la mémoire flash secondaire ("slot de mise à jour").
+    4.  Après une transmission réussie, l'esclave est redémarré par commande.
+    5.  `MCUBoot` vérifie la signature de la nouvelle image, la copie dans le slot primaire et la démarre.
+*   **Sécurité :** Le nouveau firmware doit se marquer comme "fonctionnel" après le démarrage. S'il ne le fait pas (par ex. à cause d'un crash), la version précédente et stable du firmware est automatiquement restaurée par `MCUBoot` au prochain redémarrage par le watchdog.
+
+## 7. Concepts de sécurité et de robustesse
+
+*   **Comportement Fail-Safe :** Chaque nœud esclave implémente un watchdog. Si aucune requête MODBUS valide n'est reçue de la passerelle pendant une période définie (par ex. 15 secondes), le nœud esclave passe dans un état sûr : toutes les vannes sont fermées et les relais (par ex. pour la pompe) sont désactivés.
+*   **Circuits de protection électrique :** Toutes les interfaces externes sont protégées. Les lignes de bus RS485 (`A`/`B`) sont protégées contre les surtensions par des diodes TVS sur chaque platine. Les entrées et les sorties reçoivent une protection ESD de base.
+*   **Alimentation électrique :** La tension de bus de 12V est régulée sur chaque nœud esclave avec un convertisseur abaisseur `TPS5430DDAR` efficace pour fournir les 3.3V nécessaires au microcontrôleur et aux pilotes de bus.

docs/img/architecture.de.svg

@@ -0,0 +1,86 @@
+<svg width="650" height="500" viewBox="0 0 650 500" xmlns="http://www.w3.org/2000/svg">
+  <defs>
+    <style>
+      .box {
+        fill: #f0f7ff;
+        stroke: #0d47a1;
+        stroke-width: 1.5;
+        rx: 8;
+      }
+      .label-main {
+        font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
+        font-size: 16px;
+        font-weight: 500;
+        text-anchor: middle;
+        fill: #111;
+      }
+      .label-sub {
+        font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
+        font-size: 12px;
+        text-anchor: middle;
+        fill: #444;
+      }
+      .label-arrow {
+        font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
+        font-size: 13px;
+        text-anchor: middle;
+        fill: #333;
+      }
+      .arrow-line {
+        stroke: #333;
+        stroke-width: 2;
+      }
+      .arrow-head {
+        fill: #333;
+      }
+      .bus-line {
+        stroke: #212121;
+        stroke-width: 4;
+      }
+      .bus-connector {
+        stroke: #212121;
+        stroke-width: 2;
+      }
+    </style>
+    <marker id="arrowhead" viewBox="0 0 10 10" refX="5" refY="5" markerWidth="6" markerHeight="6" orient="auto-start-reverse">
+      <path d="M 0 0 L 10 5 L 0 10 z" fill="#333" />
+    </marker>
+  </defs>
+
+  <text x="325" y="30" class="label-main" font-size="20">Systemarchitektur</text>
+
+  <rect x="225" y="60" width="200" height="70" class="box"/>
+  <text x="325" y="90" class="label-main">Home Assistant</text>
+  <text x="325" y="110" class="label-sub">(Logik &amp; UI)</text>
+
+  <line x1="325" y1="130" x2="325" y2="170" class="arrow-line" marker-end="url(#arrowhead)"/>
+  <text x="445" y="155" class="label-arrow">WLAN / Thread</text>
+  <text x="445" y="170" class="label-arrow" font-size="11">(MODBUS TCP/IP)</text>
+
+
+  <rect x="225" y="180" width="200" height="70" class="box"/>
+  <text x="325" y="210" class="label-main">Gateway (ESP32C6)</text>
+  <text x="325" y="230" class="label-sub">(Protokoll-Übersetzer)</text>
+
+  <line x1="325" y1="250" x2="325" y2="300" class="bus-line"/>
+  <line x1="50" y1="300" x2="600" y2="300" class="bus-line"/>
+  <text x="500" y="285" class="label-arrow">RS485 Bus (MODBUS RTU)</text>
+
+  <line x1="125" y1="300" x2="125" y2="340" class="bus-connector"/>
+  <rect x="50" y="340" width="150" height="60" class="box"/>
+  <text x="125" y="365" class="label-main">Slave-Node</text>
+  <text x="125" y="385" class="label-sub">(Ventil, Taster)</text>
+
+  <line x1="325" y1="300" x2="325" y2="340" class="bus-connector"/>
+  <rect x="250" y="340" width="150" height="60" class="box"/>
+  <text x="325" y="365" class="label-main">Slave-Node</text>
+  <text x="325" y="385" class="label-sub">(Pumpe, Sensoren)</text>
+
+  <line x1="525" y1="300" x2="525" y2="340" class="bus-connector"/>
+  <rect x="450" y="340" width="150" height="60" class="box"/>
+  <text x="525" y="365" class="label-main">Füllstandsensor</text>
+  <text x="525" y="385" class="label-sub">(QDY30A)</text>
+  
+  <text x="325" y="440" class="label-sub" font-size="20">...</text>
+
+</svg>

docs/img/architecture.en.svg

@@ -0,0 +1,77 @@
+<svg width="650" height="500" viewBox="0 0 650 500" xmlns="http://www.w3.org/2000/svg">
+  <defs>
+    <style>
+      .box {
+        fill: #f0f7ff;
+        stroke: #0d47a1;
+        stroke-width: 1.5;
+        rx: 8;
+      }
+      .label-main {
+        font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
+        font-size: 16px;
+        font-weight: 500;
+        text-anchor: middle;
+        fill: #111;
+      }
+      .label-sub {
+        font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
+        font-size: 12px;
+        text-anchor: middle;
+        fill: #444;
+      }
+      .label-arrow {
+        font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
+        font-size: 13px;
+        text-anchor: middle;
+        fill: #333;
+      }
+      .arrow-line {
+        stroke: #333;
+        stroke-width: 2;
+      }
+      .arrow-head {
+        fill: #333;
+      }
+      .bus-line {
+        stroke: #212121;
+        stroke-width: 4;
+      }
+      .bus-connector {
+        stroke: #212121;
+        stroke-width: 2;
+      }
+    </style>
+    <marker id="arrowhead" viewBox="0 0 10 10" refX="5" refY="5" markerWidth="6" markerHeight="6" orient="auto-start-reverse">
+      <path d="M 0 0 L 10 5 L 0 10 z" fill="#333" />
+    </marker>
+  </defs>
+
+    <text x="325" y="30" class="label-main" font-size="20">System Architecture</text>
+    <rect x="225" y="60" width="200" height="70" class="box"/>
+    <text x="325" y="90" class="label-main">Home Assistant</text>
+    <text x="325" y="110" class="label-sub">(Logic &amp; UI)</text>
+    <line x1="325" y1="130" x2="325" y2="170" class="arrow-line" marker-end="url(#arrowhead)"/>
+    <text x="445" y="155" class="label-arrow">WLAN / Thread</text>
+    <text x="445" y="170" class="label-arrow" font-size="11">(MODBUS TCP/IP)</text>
+    <rect x="225" y="180" width="200" height="70" class="box"/>
+    <text x="325" y="210" class="label-main">Gateway (ESP32C6)</text>
+    <text x="325" y="230" class="label-sub">(Protocol Translator)</text>
+    <line x1="325" y1="250" x2="325" y2="300" class="bus-line"/>
+    <line x1="50" y1="300" x2="600" y2="300" class="bus-line"/>
+    <text x="500" y="285" class="label-arrow">RS485 Bus (MODBUS RTU)</text>
+    <line x1="125" y1="300" x2="125" y2="340" class="bus-connector"/>
+    <rect x="50" y="340" width="150" height="60" class="box"/>
+    <text x="125" y="365" class="label-main">Slave Node</text>
+    <text x="125" y="385" class="label-sub">(Valve, Button)</text>
+    <line x1="325" y1="300" x2="325" y2="340" class="bus-connector"/>
+    <rect x="250" y="340" width="150" height="60" class="box"/>
+    <text x="325" y="365" class="label-main">Slave Node</text>
+    <text x="325" y="385" class="label-sub">(Pump, Sensors)</text>
+    <line x1="525" y1="300" x2="525" y2="340" class="bus-connector"/>
+    <rect x="450" y="340" width="150" height="60" class="box"/>
+    <text x="525" y="365" class="label-main">Level Sensor</text>
+    <text x="525" y="385" class="label-sub">(QDY30A)</text>
+    <text x="325" y="440" class="label-sub" font-size="20">...</text>
+
+</svg>

docs/img/architecture.es.svg

@@ -0,0 +1,77 @@
+<svg width="650" height="500" viewBox="0 0 650 500" xmlns="http://www.w3.org/2000/svg">
+  <defs>
+    <style>
+      .box {
+        fill: #f0f7ff;
+        stroke: #0d47a1;
+        stroke-width: 1.5;
+        rx: 8;
+      }
+      .label-main {
+        font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
+        font-size: 16px;
+        font-weight: 500;
+        text-anchor: middle;
+        fill: #111;
+      }
+      .label-sub {
+        font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
+        font-size: 12px;
+        text-anchor: middle;
+        fill: #444;
+      }
+      .label-arrow {
+        font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
+        font-size: 13px;
+        text-anchor: middle;
+        fill: #333;
+      }
+      .arrow-line {
+        stroke: #333;
+        stroke-width: 2;
+      }
+      .arrow-head {
+        fill: #333;
+      }
+      .bus-line {
+        stroke: #212121;
+        stroke-width: 4;
+      }
+      .bus-connector {
+        stroke: #212121;
+        stroke-width: 2;
+      }
+    </style>
+    <marker id="arrowhead" viewBox="0 0 10 10" refX="5" refY="5" markerWidth="6" markerHeight="6" orient="auto-start-reverse">
+      <path d="M 0 0 L 10 5 L 0 10 z" fill="#333" />
+    </marker>
+  </defs>
+
+   <text x="325" y="30" class="label-main" font-size="20">Arquitectura del sistema</text>
+    <rect x="225" y="60" width="200" height="70" class="box"/>
+    <text x="325" y="90" class="label-main">Home Assistant</text>
+    <text x="325" y="110" class="label-sub">(Lógica e Interfaz de Usuario)</text>
+    <line x1="325" y1="130" x2="325" y2="170" class="arrow-line" marker-end="url(#arrowhead)"/>
+    <text x="445" y="155" class="label-arrow">WLAN / Thread</text>
+    <text x="445" y="170" class="label-arrow" font-size="11">(MODBUS TCP/IP)</text>
+    <rect x="225" y="180" width="200" height="70" class="box"/>
+    <text x="325" y="210" class="label-main">Pasarela (ESP32C6)</text>
+    <text x="325" y="230" class="label-sub">(Traductor de protocolo)</text>
+    <line x1="325" y1="250" x2="325" y2="300" class="bus-line"/>
+    <line x1="50" y1="300" x2="600" y2="300" class="bus-line"/>
+    <text x="500" y="285" class="label-arrow">Bus RS485 (MODBUS RTU)</text>
+    <line x1="125" y1="300" x2="125" y2="340" class="bus-connector"/>
+    <rect x="50" y="340" width="150" height="60" class="box"/>
+    <text x="125" y="365" class="label-main">Nodo esclavo</text>
+    <text x="125" y="385" class="label-sub">(Válvula, Botón)</text>
+    <line x1="325" y1="300" x2="325" y2="340" class="bus-connector"/>
+    <rect x="250" y="340" width="150" height="60" class="box"/>
+    <text x="325" y="365" class="label-main">Nodo esclavo</text>
+    <text x="325" y="385" class="label-sub">(Bomba, Sensores)</text>
+    <line x1="525" y1="300" x2="525" y2="340" class="bus-connector"/>
+    <rect x="450" y="340" width="150" height="60" class="box"/>
+    <text x="525" y="365" class="label-main">Sensor de nivel</text>
+    <text x="525" y="385" class="label-sub">(QDY30A)</text>
+    <text x="325" y="440" class="label-sub" font-size="20">...</text>
+
+</svg>

docs/img/architecture.fr.svg

@@ -0,0 +1,78 @@
+<svg width="650" height="500" viewBox="0 0 650 500" xmlns="http://www.w3.org/2000/svg">
+  <defs>
+    <style>
+      .box {
+        fill: #f0f7ff;
+        stroke: #0d47a1;
+        stroke-width: 1.5;
+        rx: 8;
+      }
+      .label-main {
+        font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
+        font-size: 16px;
+        font-weight: 500;
+        text-anchor: middle;
+        fill: #111;
+      }
+      .label-sub {
+        font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
+        font-size: 12px;
+        text-anchor: middle;
+        fill: #444;
+      }
+      .label-arrow {
+        font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
+        font-size: 13px;
+        text-anchor: middle;
+        fill: #333;
+      }
+      .arrow-line {
+        stroke: #333;
+        stroke-width: 2;
+      }
+      .arrow-head {
+        fill: #333;
+      }
+      .bus-line {
+        stroke: #212121;
+        stroke-width: 4;
+      }
+      .bus-connector {
+        stroke: #212121;
+        stroke-width: 2;
+      }
+    </style>
+    <marker id="arrowhead" viewBox="0 0 10 10" refX="5" refY="5" markerWidth="6" markerHeight="6" orient="auto-start-reverse">
+      <path d="M 0 0 L 10 5 L 0 10 z" fill="#333" />
+    </marker>
+  </defs>
+
+    <text x="325" y="30" class="label-main" font-size="20">Architecture du système</text>
+    <rect x="225" y="60" width="200" height="70" class="box"/>
+    <text x="325" y="90" class="label-main">Home Assistant</text>
+    <text x="325" y="110" class="label-sub">(Logique &amp; UI)</text>
+    <line x1="325" y1="130" x2="325" y2="170" class="arrow-line" marker-end="url(#arrowhead)"/>
+    <text x="445" y="155" class="label-arrow">WLAN / Thread</text>
+    <text x="445" y="170" class="label-arrow" font-size="11">(MODBUS TCP/IP)</text>
+    <rect x="225" y="180" width="200" height="70" class="box"/>
+    <text x="325" y="210" class="label-main">Passerelle (ESP32C6)</text>
+    <text x="325" y="230" class="label-sub">(Traducteur de protocole)</text>
+    <line x1="325" y1="250" x2="325" y2="300" class="bus-line"/>
+    <line x1="50" y1="300" x2="600" y2="300" class="bus-line"/>
+    <text x="500" y="285" class="label-arrow">Bus RS485 (MODBUS RTU)</text>
+    <line x1="125" y1="300" x2="125" y2="340" class="bus-connector"/>
+    <rect x="50" y="340" width="150" height="60" class="box"/>
+    <text x="125" y="365" class="label-main">Nœud esclave</text>
+    <text x="125" y="385" class="label-sub">(Vanne, Bouton)</text>
+    <line x1="325" y1="300" x2="325" y2="340" class="bus-connector"/>
+    <rect x="250" y="340" width="150" height="60" class="box"/>
+    <text x="325" y="365" class="label-main">Nœud esclave</text>
+    <text x="325" y="385" class="label-sub">(Pompe, Capteurs)</text>
+    <line x1="525" y1="300" x2="525" y2="340" class="bus-connector"/>
+    <rect x="450" y="340" width="150" height="60" class="box"/>
+    <text x="525" y="365" class="label-main">Capteur de niveau</text>
+    <text x="525" y="385" class="label-sub">(QDY30A)</text>
+    <text x="325" y="440" class="label-sub" font-size="20">...</text>
+
+
+</svg>

docs/modbus-registers.de.md

@@ -0,0 +1,85 @@
+🇩🇪 Deutsch | [🇬🇧 English](modbus-registers.en.md) | [🇫🇷 Français](modbus-registers.fr.md) | [🇪🇸 Español](modbus-registers.es.md)
+
+# MODBUS Register Map Definition v1.0
+
+## 1. Einleitung
+
+Dieses Dokument definiert die MODBUS-Register für die universellen Slave-Nodes des Bewässerungssystems.
+
+### 1.1. Adressierungs-Philosophie
+
+Alle Register sind in einer einzigen, durchgehenden Liste pro Register-Typ (`Input` oder `Holding`) definiert. Eine Spalte "Zugehörigkeit" ordnet die Funktion logisch zu. Die Adressen sind in Blöcken gruppiert, um Raum für zukünftige Erweiterungen zu lassen und die Lesbarkeit zu erhöhen.
+
+* **`0x0000 - 0x000F`**: Ventilsteuerung & Status
+* **`0x0010 - 0x001F`**: Digitale Ausgänge (LEDs / Relais)
+* **`0x0020 - 0x002F`**: Digitale Eingänge (Taster / Sensoren)
+* **`0x00F0 - 0x00FF`**: Allgemeine Gerätekonfiguration & Status
+* **`0x0100 - 0x01FF`**: Firmware-Update-Mechanismus
+
+### 1.2. Verwendete Funktionscodes
+
+* **`0x03` (Read Holding Registers):** Zum Lesen von `4xxxx` Registern.
+* **`0x04` (Read Input Registers):** Zum Lesen von `3xxxx` Registern.
+* **`0x06` (Write Single Register):** Zum Schreiben eines einzelnen `4xxxx` Registers.
+* **`0x10` (Write Multiple Registers):** Zum Schreiben mehrerer `4xxxx` Register am Stück.
+
+## 2. Input Registers (3xxxx, Read-Only)
+
+| Adresse (hex) | Name                           | Zugehörigkeit     | Beschreibung                                                                                                                              |
+| :------------ | :----------------------------- | :---------------- | :---------------------------------------------------------------------------------------------------------------------------------------- |
+| **0x0000** | `VENTIL_ZUSTAND_BEWEGUNG`        | Ventil            | Kombiniertes Status-Register. **High-Byte**: Bewegung (`0`=Idle, `1`=Öffnet, `2`=Schliesst, `3`=Fehler). **Low-Byte**: Zustand (`0`=Geschlossen, `1`=Geöffnet). |
+| **0x0001** | `MOTORSTROM_MA`                | Ventil            | Aktueller Motorstrom in Milliampere (mA).                                                                                                 |
+| **0x0020** | `DIGITAL_EINGAENGE_ZUSTAND`    | Eingänge          | Bitmaske der digitalen Eingänge. Bit 0: Eingang 1, Bit 1: Eingang 2. `1`=Aktiv.                                                          |
+| **0x0021** | `TASTER_EVENTS`                | Eingänge          | Event-Flags für Taster (Clear-on-Read). Bit 0: Taster 1 gedrückt. Bit 1: Taster 2 gedrückt.                                                 |
+| **0x00F0** | `FIRMWARE_VERSION_MAJOR_MINOR` | System            | z.B. `0x0102` für v1.2.                                                                                                                   |
+| **0x00F1** | `FIRMWARE_VERSION_PATCH`       | System            | z.B. `3` für v1.2.3.                                                                                                                      |
+| **0x00F2** | `DEVICE_STATUS`                | System            | `0`=OK, `1`=Allgemeiner Fehler.                                                                                                           |
+| **0x00F3** | `UPTIME_SECONDS_LOW`           | System            | Untere 16 Bit der Uptime in Sekunden.                                                                                                     |
+| **0x00F4** | `UPTIME_SECONDS_HIGH`          | System            | Obere 16 Bit der Uptime.                                                                                                                  |
+| **0x0100** | `FWU_LAST_CHUNK_CRC`           | Firmware-Update   | Enthält den CRC16 des zuletzt im Puffer empfangenen Daten-Chunks.                                                                         |
+
+## 3. Holding Registers (4xxxx, Read/Write)
+
+| Adresse (hex) | Name                          | Zugehörigkeit     | Beschreibung                                                                                                                              |
+| :------------ | :---------------------------- | :---------------- | :---------------------------------------------------------------------------------------------------------------------------------------- |
+| **0x0000** | `VENTIL_BEFEHL`               | Ventil            | `1`=Öffnen, `2`=Schliessen, `0`=Bewegung stoppen.                                                                                           |
+| **0x0001** | `MAX_OEFFNUNGSZEIT_S`         | Ventil            | Sicherheits-Timeout in Sekunden für den Öffnen-Vorgang.                                                                                    |
+| **0x0002** | `MAX_SCHLIESSZEIT_S`          | Ventil            | Sicherheits-Timeout in Sekunden für den Schliessen-Vorgang.                                                                                |
+| **0x0010** | `DIGITAL_AUSGAENGE_ZUSTAND`   | Ausgänge          | Bitmaske zum Lesen und Schreiben der Ausgänge. Bit 0: Ausgang 1, Bit 1: Ausgang 2. `1`=AN, `0`=AUS.                                         |
+| **0x00F0** | `WATCHDOG_TIMEOUT_S`          | System            | Timeout des Fail-Safe-Watchdogs in Sekunden. `0`=Deaktiviert.                                                                             |
+| **0x0100** | `FWU_COMMAND`                 | Firmware-Update   | `1`: **Verify Chunk**: Der zuletzt übertragene Chunk wurde vom Client als gültig befunden. Der Slave soll ihn nun ins Flash schreiben. `2`: **Finalize Update**: Alle Chunks sind übertragen. Installation abschliessen und neu starten. |
+| **0x0101** | `FWU_CHUNK_OFFSET_LOW`        | Firmware-Update   | Untere 16 Bit des 32-Bit-Offsets, an den der nächste Chunk geschrieben werden soll.                                                         |
+| **0x0102** | `FWU_CHUNK_OFFSET_HIGH`       | Firmware-Update   | Obere 16 Bit des 32-Bit-Offsets.                                                                                                          |
+| **0x0103** | `FWU_CHUNK_SIZE`              | Firmware-Update   | Grösse des nächsten Chunks in Bytes (max. 256).                                                                                           |
+| **0x0180** | `FWU_DATA_BUFFER`             | Firmware-Update   | **Startadresse** eines 128x16-bit Puffers (256 Bytes). Entspricht den Registern `40384` bis `40511`.                                       |
+
+## 4. Detaillierter Firmware-Update-Prozess
+
+Dieser Prozess ist zustandslos und robust gegen Übertragungsfehler.
+
+1.  **Client:** Wählt einen Chunk (max. 256 Bytes) aus der Firmware-Datei und berechnet dessen CRC16.
+2.  **Client:** Schreibt den Ziel-Offset (z.B. `0`) in `FWU_CHUNK_OFFSET_...` und die Grösse in `FWU_CHUNK_SIZE`.
+3.  **Client:** Schreibt die Chunk-Daten in den `FWU_DATA_BUFFER` (ab Adresse `0x0180`).
+4.  **Slave:** Empfängt die Daten, legt sie im RAM-Puffer ab und berechnet den CRC. Das Ergebnis wird in `FWU_LAST_CHUNK_CRC` (`30256`) bereitgestellt.
+5.  **Client:** Liest `FWU_LAST_CHUNK_CRC` und vergleicht den Wert mit dem selbst berechneten CRC.
+    * **Fehler:** Gehe zurück zu Schritt 3, um den gleichen Chunk erneut zu senden.
+    * **Erfolg:** Fährt mit dem nächsten Schritt fort.
+6.  **Client:** Schreibt den Befehl `1` ("Verify Chunk") in `FWU_COMMAND` (`40256`).
+7.  **Slave:** Empfängt den Befehl, nimmt den verifizierten Chunk aus dem RAM-Puffer und schreibt ihn an die richtige Stelle im Flash-Speicher.
+8.  **Client:** Fährt mit dem nächsten Chunk fort (zurück zu Schritt 1 mit neuem Offset und Daten).
+9.  **Letzter Chunk:** Nachdem der letzte Chunk übertragen und mit Befehl `1` ins Flash geschrieben wurde, schreibt der Client den Befehl `2` ("Finalize Update") in `FWU_COMMAND`.
+10. **Slave:** Führt Abschlussprüfungen durch und startet neu, damit MCUBoot die Installation durchführt.
+
+## Anhang: QDY30A Füllstandsensor Register
+
+Diese Register gehören zum externen Füllstandsensor und können auf dem Bus ebenfalls adressiert werden. Es handelt sich laut Hersteller um Holding Registers (`4xxxx`), die mit Funktionscode `0x03` gelesen werden.
+
+| Adresse (hex) | Name                       | R/W | Beschreibung                                                                                                                              |
+| :------------ | :------------------------- | :-- | :---------------------------------------------------------------------------------------------------------------------------------------- |
+| **0x0000** | `NODE_ADRESSE`             | R/W | Geräteadresse des Sensors (1-255).                                                                                                        |
+| **0x0001** | `BAUDRATE`                 | R/W | `0`=1200, `1`=2400, `2`=4800, `3`=9600, `4`=19200, `5`=38400, `6`=57600, `7`=115200.                                                       |
+| **0x0002** | `EINHEIT`                  | R/W | `0`=Keine, `1`=cm, `2`=mm, `3`=MPa, `4`=Pa, `5`=kPa.                                                                                        |
+| **0x0003** | `NACHKOMMASTELLEN`         | R/W | Anzahl der Dezimalstellen für den Messwert (0-3).                                                                                         |
+| **0x0004** | `MESSWERT_AKTUELL`         | R   | Der skalierte Messwert als vorzeichenbehafteter 16-Bit-Integer.                                                                           |
+| **0x0005** | `MESSBEREICH_NULLPUNKT`    | R/W | Rohwert für den Nullpunkt der Skala.                                                                                                      |
+| **0x0006** | `MESSBEREICH_ENDPUNKT`     | R/W | Rohwert für den Endpunkt der Skala.                                                                                                       |

docs/modbus-registers.en.md

@@ -0,0 +1,85 @@
+[🇩🇪 Deutsch](modbus-registers.de.md) | 🇬🇧 English | [🇫🇷 Français](modbus-registers.fr.md) | [🇪🇸 Español](modbus-registers.es.md)
+
+# MODBUS Register Map Definition v1.0
+
+## 1. Introduction
+
+This document defines the MODBUS registers for the universal slave nodes of the irrigation system.
+
+### 1.1. Addressing Philosophy
+
+All registers are defined in a single, continuous list per register type (`Input` or `Holding`). A "Category" column logically assigns the function. The addresses are grouped in blocks to leave room for future extensions and to increase readability.
+
+* **`0x0000 - 0x000F`**: Valve control & status
+* **`0x0010 - 0x001F`**: Digital outputs (LEDs / relays)
+* **`0x0020 - 0x002F`**: Digital inputs (buttons / sensors)
+* **`0x00F0 - 0x00FF`**: General device configuration & status
+* **`0x0100 - 0x01FF`**: Firmware update mechanism
+
+### 1.2. Used Function Codes
+
+* **`0x03` (Read Holding Registers):** For reading `4xxxx` registers.
+* **`0x04` (Read Input Registers):** For reading `3xxxx` registers.
+* **`0x06` (Write Single Register):** For writing a single `4xxxx` register.
+* **`0x10` (Write Multiple Registers):** For writing multiple `4xxxx` registers at once.
+
+## 2. Input Registers (3xxxx, Read-Only)
+
+| Address (hex) | Name | Category | Description |
+| :--- | :--- | :--- | :--- |
+| **0x0000** | `VALVE_STATE_MOVEMENT` | Valve | Combined status register. **High-Byte**: Movement (`0`=Idle, `1`=Opening, `2`=Closing, `3`=Error). **Low-Byte**: State (`0`=Closed, `1`=Open). |
+| **0x0001** | `MOTOR_CURRENT_MA` | Valve | Current motor current in milliamperes (mA). |
+| **0x0020** | `DIGITAL_INPUTS_STATE` | Inputs | Bitmask of the digital inputs. Bit 0: Input 1, Bit 1: Input 2. `1`=Active. |
+| **0x0021** | `BUTTON_EVENTS` | Inputs | Event flags for buttons (Clear-on-Read). Bit 0: Button 1 pressed. Bit 1: Button 2 pressed. |
+| **0x00F0** | `FIRMWARE_VERSION_MAJOR_MINOR` | System | e.g. `0x0102` for v1.2. |
+| **0x00F1** | `FIRMWARE_VERSION_PATCH` | System | e.g. `3` for v1.2.3. |
+| **0x00F2** | `DEVICE_STATUS` | System | `0`=OK, `1`=General error. |
+| **0x00F3** | `UPTIME_SECONDS_LOW` | System | Lower 16 bits of the uptime in seconds. |
+| **0x00F4** | `UPTIME_SECONDS_HIGH` | System | Upper 16 bits of the uptime. |
+| **0x0100** | `FWU_LAST_CHUNK_CRC` | Firmware-Update | Contains the CRC16 of the last data chunk received in the buffer. |
+
+## 3. Holding Registers (4xxxx, Read/Write)
+
+| Address (hex) | Name | Category | Description |
+| :--- | :--- | :--- | :--- |
+| **0x0000** | `VALVE_COMMAND` | Valve | `1`=Open, `2`=Close, `0`=Stop movement. |
+| **0x0001** | `MAX_OPENING_TIME_S` | Valve | Safety timeout in seconds for the opening process. |
+| **0x0002** | `MAX_CLOSING_TIME_S` | Valve | Safety timeout in seconds for the closing process. |
+| **0x0010** | `DIGITAL_OUTPUTS_STATE` | Outputs | Bitmask for reading and writing the outputs. Bit 0: Output 1, Bit 1: Output 2. `1`=ON, `0`=OFF. |
+| **0x00F0** | `WATCHDOG_TIMEOUT_S` | System | Timeout of the fail-safe watchdog in seconds. `0`=Disabled. |
+| **0x0100** | `FWU_COMMAND` | Firmware-Update | `1`: **Verify Chunk**: The last transmitted chunk was found to be valid by the client. The slave should now write it to flash. `2`: **Finalize Update**: All chunks have been transmitted. Finalize installation and restart. |
+| **0x0101** | `FWU_CHUNK_OFFSET_LOW` | Firmware-Update | Lower 16 bits of the 32-bit offset to which the next chunk is to be written. |
+| **0x0102** | `FWU_CHUNK_OFFSET_HIGH` | Firmware-Update | Upper 16 bits of the 32-bit offset. |
+| **0x0103** | `FWU_CHUNK_SIZE` | Firmware-Update | Size of the next chunk in bytes (max. 256). |
+| **0x0180** | `FWU_DATA_BUFFER` | Firmware-Update | **Start address** of a 128x16-bit buffer (256 bytes). Corresponds to registers `40384` to `40511`. |
+
+## 4. Detailed Firmware Update Process
+
+This process is stateless and robust against transmission errors.
+
+1.  **Client:** Selects a chunk (max. 256 bytes) from the firmware file and calculates its CRC16.
+2.  **Client:** Writes the target offset (e.g. `0`) to `FWU_CHUNK_OFFSET_...` and the size to `FWU_CHUNK_SIZE`.
+3.  **Client:** Writes the chunk data to the `FWU_DATA_BUFFER` (from address `0x0180`).
+4.  **Slave:** Receives the data, places it in the RAM buffer and calculates the CRC. The result is provided in `FWU_LAST_CHUNK_CRC` (`30256`).
+5.  **Client:** Reads `FWU_LAST_CHUNK_CRC` and compares the value with the self-calculated CRC.
+    * **Error:** Go back to step 3 to send the same chunk again.
+    * **Success:** Continues with the next step.
+6.  **Client:** Writes the command `1` ("Verify Chunk") to `FWU_COMMAND` (`40256`).
+7.  **Slave:** Receives the command, takes the verified chunk from the RAM buffer and writes it to the correct location in the flash memory.
+8.  **Client:** Continues with the next chunk (back to step 1 with new offset and data).
+9.  **Last Chunk:** After the last chunk has been transferred and written to flash with command `1`, the client writes the command `2` ("Finalize Update") to `FWU_COMMAND`.
+10. **Slave:** Performs final checks and restarts so that MCUBoot can perform the installation.
+
+## Appendix: QDY30A Level Sensor Registers
+
+These registers belong to the external level sensor and can also be addressed on the bus. According to the manufacturer, these are Holding Registers (`4xxxx`) that are read with function code `0x03`.
+
+| Address (hex) | Name | R/W | Description |
+| :--- | :--- | :-- | :--- |
+| **0x0000** | `NODE_ADDRESS` | R/W | Device address of the sensor (1-255). |
+| **0x0001** | `BAUDRATE` | R/W | `0`=1200, `1`=2400, `2`=4800, `3`=9600, `4`=19200, `5`=38400, `6`=57600, `7`=115200. |
+| **0x0002** | `UNIT` | R/W | `0`=None, `1`=cm, `2`=mm, `3`=MPa, `4`=Pa, `5`=kPa. |
+| **0x0003** | `DECIMAL_PLACES` | R/W | Number of decimal places for the measured value (0-3). |
+| **0x0004** | `CURRENT_MEASUREMENT` | R | The scaled measured value as a signed 16-bit integer. |
+| **0x0005** | `MEASURING_RANGE_ZERO_POINT` | R/W | Raw value for the zero point of the scale. |
+| **0x0006** | `MEASURING_RANGE_END_POINT` | R/W | Raw value for the end point of the scale. |

docs/modbus-registers.es.md

@@ -0,0 +1,85 @@
+[🇩🇪 Deutsch](modbus-registers.de.md) | [🇬🇧 English](modbus-registers.en.md) | [🇫🇷 Français](modbus-registers.fr.md) | 🇪🇸 Español
+
+# Definición del mapa de registros MODBUS v1.0
+
+## 1. Introducción
+
+Este documento define los registros MODBUS para los nodos esclavos universales del sistema de riego.
+
+### 1.1. Filosofía de direccionamiento
+
+Todos los registros se definen en una única lista continua por tipo de registro (`Input` o `Holding`). Una columna "Categoría" asigna lógicamente la función. Las direcciones se agrupan en bloques para dejar espacio para futuras ampliaciones y para aumentar la legibilidad.
+
+*   **`0x0000 - 0x000F`**: Control y estado de la válvula
+*   **`0x0010 - 0x001F`**: Salidas digitales (LEDs / relés)
+*   **`0x0020 - 0x002F`**: Entradas digitales (botones / sensores)
+*   **`0x00F0 - 0x00FF`**: Configuración y estado general del dispositivo
+*   **`0x0100 - 0x01FF`**: Mecanismo de actualización de firmware
+
+### 1.2. Códigos de función utilizados
+
+*   **`0x03` (Read Holding Registers):** Para leer registros `4xxxx`.
+*   **`0x04` (Read Input Registers):** Para leer registros `3xxxx`.
+*   **`0x06` (Write Single Register):** Para escribir un único registro `4xxxx`.
+*   **`0x10` (Write Multiple Registers):** Para escribir varios registros `4xxxx` a la vez.
+
+## 2. Registros de entrada (3xxxx, solo lectura)
+
+| Dirección (hex) | Nombre | Categoría | Descripción |
+| :--- | :--- | :--- | :--- |
+| **0x0000** | `VALVE_STATE_MOVEMENT` | Válvula | Registro de estado combinado. **Byte alto**: Movimiento (`0`=Inactivo, `1`=Abriendo, `2`=Cerrando, `3`=Error). **Byte bajo**: Estado (`0`=Cerrado, `1`=Abierto). |
+| **0x0001** | `MOTOR_CURRENT_MA` | Válvula | Corriente actual del motor en miliamperios (mA). |
+| **0x0020** | `DIGITAL_INPUTS_STATE` | Entradas | Máscara de bits de las entradas digitales. Bit 0: Entrada 1, Bit 1: Entrada 2. `1`=Activo. |
+| **0x0021** | `BUTTON_EVENTS` | Entradas | Banderas de eventos para botones (Borrar al leer). Bit 0: Botón 1 presionado. Bit 1: Botón 2 presionado. |
+| **0x00F0** | `FIRMWARE_VERSION_MAJOR_MINOR` | Sistema | p. ej. `0x0102` para v1.2. |
+| **0x00F1** | `FIRMWARE_VERSION_PATCH` | Sistema | p. ej. `3` para v1.2.3. |
+| **0x00F2** | `DEVICE_STATUS` | Sistema | `0`=OK, `1`=Error general. |
+| **0x00F3** | `UPTIME_SECONDS_LOW` | Sistema | 16 bits inferiores del tiempo de actividad en segundos. |
+| **0x00F4** | `UPTIME_SECONDS_HIGH` | Sistema | 16 bits superiores del tiempo de actividad. |
+| **0x0100** | `FWU_LAST_CHUNK_CRC` | Actualización FW | Contiene el CRC16 del último trozo de datos recibido en el búfer. |
+
+## 3. Registros de retención (4xxxx, lectura/escritura)
+
+| Dirección (hex) | Nombre | Categoría | Descripción |
+| :--- | :--- | :--- | :--- |
+| **0x0000** | `VALVE_COMMAND` | Válvula | `1`=Abrir, `2`=Cerrar, `0`=Detener movimiento. |
+| **0x0001** | `MAX_OPENING_TIME_S` | Válvula | Tiempo de espera de seguridad en segundos para el proceso de apertura. |
+| **0x0002** | `MAX_CLOSING_TIME_S` | Válvula | Tiempo de espera de seguridad en segundos para el proceso de cierre. |
+| **0x0010** | `DIGITAL_OUTPUTS_STATE` | Salidas | Máscara de bits para leer y escribir las salidas. Bit 0: Salida 1, Bit 1: Salida 2. `1`=ON, `0`=OFF. |
+| **0x00F0** | `WATCHDOG_TIMEOUT_S` | Sistema | Tiempo de espera del watchdog de seguridad en segundos. `0`=Desactivado. |
+| **0x0100** | `FWU_COMMAND` | Actualización FW | `1`: **Verificar trozo**: El último trozo transmitido fue considerado válido por el cliente. El esclavo ahora debe escribirlo en la flash. `2`: **Finalizar actualización**: Todos los trozos han sido transmitidos. Finalizar la instalación y reiniciar. |
+| **0x0101** | `FWU_CHUNK_OFFSET_LOW` | Actualización FW | 16 bits inferiores del desplazamiento de 32 bits en el que se escribirá el siguiente trozo. |
+| **0x0102** | `FWU_CHUNK_OFFSET_HIGH` | Actualización FW | 16 bits superiores del desplazamiento de 32 bits. |
+| **0x0103** | `FWU_CHUNK_SIZE` | Actualización FW | Tamaño del siguiente trozo en bytes (máx. 256). |
+| **0x0180** | `FWU_DATA_BUFFER` | Actualización FW | **Dirección de inicio** de un búfer de 128x16 bits (256 bytes). Corresponde a los registros `40384` a `40511`. |
+
+## 4. Proceso detallado de actualización de firmware
+
+Este proceso no tiene estado y es robusto frente a errores de transmisión.
+
+1.  **Cliente:** Selecciona un trozo (máx. 256 bytes) del archivo de firmware y calcula su CRC16.
+2.  **Cliente:** Escribe el desplazamiento de destino (p. ej. `0`) en `FWU_CHUNK_OFFSET_...` y el tamaño en `FWU_CHUNK_SIZE`.
+3.  **Cliente:** Escribe los datos del trozo en el `FWU_DATA_BUFFER` (desde la dirección `0x0180`).
+4.  **Esclavo:** Recibe los datos, los coloca en el búfer de RAM y calcula el CRC. El resultado se proporciona en `FWU_LAST_CHUNK_CRC` (`30256`).
+5.  **Cliente:** Lee `FWU_LAST_CHUNK_CRC` y compara el valor con el CRC autocalculado.
+    *   **Error:** Volver al paso 3 para enviar el mismo trozo de nuevo.
+    *   **Éxito:** Continúa con el siguiente paso.
+6.  **Cliente:** Escribe el comando `1` ("Verificar trozo") en `FWU_COMMAND` (`40256`).
+7.  **Esclavo:** Recibe el comando, toma el trozo verificado del búfer de RAM y lo escribe en la ubicación correcta en la memoria flash.
+8.  **Cliente:** Continúa con el siguiente trozo (vuelta al paso 1 con nuevo desplazamiento y datos).
+9.  **Último trozo:** Después de que el último trozo ha sido transferido y escrito en la flash con el comando `1`, el cliente escribe el comando `2` ("Finalizar actualización") en `FWU_COMMAND`.
+10. **Esclavo:** Realiza las comprobaciones finales y se reinicia para que MCUBoot pueda realizar la instalación.
+
+## Apéndice: Registros del sensor de nivel QDY30A
+
+Estos registros pertenecen al sensor de nivel externo y también se pueden direccionar en el bus. Según el fabricante, se trata de registros de retención (`4xxxx`) que se leen con el código de función `0x03`.
+
+| Dirección (hex) | Nombre | L/E | Descripción |
+| :--- | :--- | :-- | :--- |
+| **0x0000** | `NODE_ADDRESS` | L/E | Dirección del dispositivo del sensor (1-255). |
+| **0x0001** | `BAUDRATE` | L/E | `0`=1200, `1`=2400, `2`=4800, `3`=9600, `4`=19200, `5`=38400, `6`=57600, `7`=115200. |
+| **0x0002** | `UNIT` | L/E | `0`=Ninguno, `1`=cm, `2`=mm, `3`=MPa, `4`=Pa, `5`=kPa. |
+| **0x0003** | `DECIMAL_PLACES` | L/E | Número de decimales para el valor medido (0-3). |
+| **0x0004** | `CURRENT_MEASUREMENT` | L | El valor medido escalado como un entero de 16 bits con signo. |
+| **0x0005** | `MEASURING_RANGE_ZERO_POINT` | L/E | Valor bruto para el punto cero de la escala. |
+| **0x0006** | `MEASURING_RANGE_END_POINT` | L/E | Valor bruto para el punto final de la escala. |

docs/modbus-registers.fr.md

@@ -0,0 +1,85 @@
+[🇩🇪 Deutsch](modbus-registers.de.md) | [🇬🇧 English](modbus-registers.en.md) | 🇫🇷 Français | [🇪🇸 Español](modbus-registers.es.md)
+
+# Définition de la carte des registres MODBUS v1.0
+
+## 1. Introduction
+
+Ce document définit les registres MODBUS pour les nœuds esclaves universels du système d'irrigation.
+
+### 1.1. Philosophie d'adressage
+
+Tous les registres sont définis dans une seule liste continue par type de registre (`Input` ou `Holding`). Une colonne "Catégorie" attribue logiquement la fonction. Les adresses sont regroupées en blocs pour laisser de la place à de futures extensions et pour améliorer la lisibilité.
+
+*   **`0x0000 - 0x000F`** : Commande et état de la vanne
+*   **`0x0010 - 0x001F`** : Sorties numériques (LEDs / relais)
+*   **`0x0020 - 0x002F`** : Entrées numériques (boutons / capteurs)
+*   **`0x00F0 - 0x00FF`** : Configuration et état général de l'appareil
+*   **`0x0100 - 0x01FF`** : Mécanisme de mise à jour du firmware
+
+### 1.2. Codes de fonction utilisés
+
+*   **`0x03` (Read Holding Registers) :** Pour lire les registres `4xxxx`.
+*   **`0x04` (Read Input Registers) :** Pour lire les registres `3xxxx`.
+*   **`0x06` (Write Single Register) :** Pour écrire un seul registre `4xxxx`.
+*   **`0x10` (Write Multiple Registers) :** Pour écrire plusieurs registres `4xxxx` à la fois.
+
+## 2. Registres d'entrée (3xxxx, Lecture seule)
+
+| Adresse (hex) | Nom | Catégorie | Description |
+| :--- | :--- | :--- | :--- |
+| **0x0000** | `VALVE_STATE_MOVEMENT` | Vanne | Registre d'état combiné. **Octet haut** : Mouvement (`0`=Inactif, `1`=Ouverture, `2`=Fermeture, `3`=Erreur). **Octet bas** : État (`0`=Fermé, `1`=Ouvert). |
+| **0x0001** | `MOTOR_CURRENT_MA` | Vanne | Courant moteur actuel en milliampères (mA). |
+| **0x0020** | `DIGITAL_INPUTS_STATE` | Entrées | Masque de bits des entrées numériques. Bit 0 : Entrée 1, Bit 1 : Entrée 2. `1`=Actif. |
+| **0x0021** | `BUTTON_EVENTS` | Entrées | Indicateurs d'événements pour les boutons (Effacement à la lecture). Bit 0 : Bouton 1 pressé. Bit 1 : Bouton 2 pressé. |
+| **0x00F0** | `FIRMWARE_VERSION_MAJOR_MINOR` | Système | ex. `0x0102` pour v1.2. |
+| **0x00F1** | `FIRMWARE_VERSION_PATCH` | Système | ex. `3` pour v1.2.3. |
+| **0x00F2** | `DEVICE_STATUS` | Système | `0`=OK, `1`=Erreur générale. |
+| **0x00F3** | `UPTIME_SECONDS_LOW` | Système | 16 bits inférieurs du temps de fonctionnement en secondes. |
+| **0x00F4** | `UPTIME_SECONDS_HIGH` | Système | 16 bits supérieurs du temps de fonctionnement. |
+| **0x0100** | `FWU_LAST_CHUNK_CRC` | Mise à jour FW | Contient le CRC16 du dernier bloc de données reçu dans le tampon. |
+
+## 3. Registres de maintien (4xxxx, Lecture/Écriture)
+
+| Adresse (hex) | Nom | Catégorie | Description |
+| :--- | :--- | :--- | :--- |
+| **0x0000** | `VALVE_COMMAND` | Vanne | `1`=Ouvrir, `2`=Fermer, `0`=Arrêter le mouvement. |
+| **0x0001** | `MAX_OPENING_TIME_S` | Vanne | Temporisation de sécurité en secondes pour le processus d'ouverture. |
+| **0x0002** | `MAX_CLOSING_TIME_S` | Vanne | Temporisation de sécurité en secondes pour le processus de fermeture. |
+| **0x0010** | `DIGITAL_OUTPUTS_STATE` | Sorties | Masque de bits pour lire et écrire les sorties. Bit 0 : Sortie 1, Bit 1 : Sortie 2. `1`=ON, `0`=OFF. |
+| **0x00F0** | `WATCHDOG_TIMEOUT_S` | Système | Temporisation du watchdog de sécurité en secondes. `0`=Désactivé. |
+| **0x0100** | `FWU_COMMAND` | Mise à jour FW | `1` : **Vérifier le bloc** : Le dernier bloc transmis a été jugé valide par le client. L'esclave doit maintenant l'écrire en flash. `2` : **Finaliser la mise à jour** : Tous les blocs ont été transmis. Finaliser l'installation et redémarrer. |
+| **0x0101** | `FWU_CHUNK_OFFSET_LOW` | Mise à jour FW | 16 bits inférieurs de l'offset 32 bits où le prochain bloc doit être écrit. |
+| **0x0102** | `FWU_CHUNK_OFFSET_HIGH` | Mise à jour FW | 16 bits supérieurs de l'offset 32 bits. |
+| **0x0103** | `FWU_CHUNK_SIZE` | Mise à jour FW | Taille du prochain bloc en octets (max. 256). |
+| **0x0180** | `FWU_DATA_BUFFER` | Mise à jour FW | **Adresse de début** d'un tampon de 128x16 bits (256 octets). Correspond aux registres `40384` à `40511`. |
+
+## 4. Processus détaillé de mise à jour du firmware
+
+Ce processus est sans état et robuste aux erreurs de transmission.
+
+1.  **Client :** Sélectionne un bloc (max. 256 octets) dans le fichier de firmware et calcule son CRC16.
+2.  **Client :** Écrit l'offset cible (par ex. `0`) dans `FWU_CHUNK_OFFSET_...` et la taille dans `FWU_CHUNK_SIZE`.
+3.  **Client :** Écrit les données du bloc dans le `FWU_DATA_BUFFER` (à partir de l'adresse `0x0180`).
+4.  **Esclave :** Reçoit les données, les place dans le tampon RAM et calcule le CRC. Le résultat est fourni dans `FWU_LAST_CHUNK_CRC` (`30256`).
+5.  **Client :** Lit `FWU_LAST_CHUNK_CRC` et compare la valeur avec le CRC auto-calculé.
+    *   **Erreur :** Retourner à l'étape 3 pour renvoyer le même bloc.
+    *   **Succès :** Continue à l'étape suivante.
+6.  **Client :** Écrit la commande `1` ("Vérifier le bloc") dans `FWU_COMMAND` (`40256`).
+7.  **Esclave :** Reçoit la commande, prend le bloc vérifié du tampon RAM et l'écrit à l'emplacement correct dans la mémoire flash.
+8.  **Client :** Continue avec le bloc suivant (retour à l'étape 1 avec un nouvel offset et de nouvelles données).
+9.  **Dernier bloc :** Après que le dernier bloc a été transféré et écrit en flash avec la commande `1`, le client écrit la commande `2` ("Finaliser la mise à jour") dans `FWU_COMMAND`.
+10. **Esclave :** Effectue les vérifications finales et redémarre pour que MCUBoot puisse effectuer l'installation.
+
+## Annexe : Registres du capteur de niveau QDY30A
+
+Ces registres appartiennent au capteur de niveau externe et peuvent également être adressés sur le bus. Selon le fabricant, il s'agit de registres de maintien (`4xxxx`) qui sont lus avec le code de fonction `0x03`.
+
+| Adresse (hex) | Nom | L/E | Description |
+| :--- | :--- | :-- | :--- |
+| **0x0000** | `NODE_ADDRESS` | L/E | Adresse de l'appareil du capteur (1-255). |
+| **0x0001** | `BAUDRATE` | L/E | `0`=1200, `1`=2400, `2`=4800, `3`=9600, `4`=19200, `5`=38400, `6`=57600, `7`=115200. |
+| **0x0002** | `UNIT` | L/E | `0`=Aucun, `1`=cm, `2`=mm, `3`=MPa, `4`=Pa, `5`=kPa. |
+| **0x0003** | `DECIMAL_PLACES` | L/E | Nombre de décimales pour la valeur mesurée (0-3). |
+| **0x0004** | `CURRENT_MEASUREMENT` | L | La valeur mesurée mise à l'échelle sous forme d'entier signé de 16 bits. |
+| **0x0005** | `MEASURING_RANGE_ZERO_POINT` | L/E | Valeur brute pour le point zéro de l'échelle. |
+| **0x0006** | `MEASURING_RANGE_END_POINT` | L/E | Valeur brute pour le point final de l'échelle. |

docs/planning.de.md

@@ -0,0 +1,33 @@
+🇩🇪 Deutsch | [🇬🇧 English](planning.en.md) | [🇫🇷 Français](planning.fr.md) | [🇪🇸 Español](planning.es.md)
+
+# Projektplan: Modulares Bewässerungssystem
+
+| Abgehakt | Aufgabe | Datum | Bemerkungen |
+| :---: | :--- | :--- | :--- |
+| ✅ | **Phase 0: Planung & Definition** | | |
+| ✅ | Konzept erstellen und finalisieren | 30.06.2025 | Architektur, Komponenten und grundlegende Architektur sind festgelegt. |
+| ✅ | MODBUS Register Map definieren | 30.06.2025 | Die "API" der Slaves ist definiert und bildet die Grundlage für die Software-Entwicklung. |
+| ☐ | **Phase 1: Slave-Node Prototyp (STM32 Eval-Board)** | | **Ziel:** Ein einzelner Slave wird auf dem Eval-Board zum Leben erweckt. |
+| ✅ | 1.1 Entwicklungsumgebung für STM32/Zephyr einrichten | 30.06.2025 | Toolchain, VS Code, Zephyr-SDK, MCUBoot etc. installieren und ein "Hello World" zum Laufen bringen. |
+| ☐ | 1.2 Basis-Firmware für Slave-Node erstellen | | Hardware-Abstraktion (GPIOs, ADC, UART für RS485) implementieren. |
+| ☐ | 1.3 MODBUS-RTU Stack auf dem Slave implementieren | | Basierend auf der definierten Register-Map. Zuerst nur lesende Funktionen (Status, Version). |
+| ☐ | 1.4 Kernlogik implementieren (z.B. Ventilsteuerung) | | Umsetzung der `VENTIL_ZUSTAND_BEWEGUNG` Logik, Strommessung für Endlagen etc. |
+| ☐ | **Phase 2: Verifikation der Slave-Firmware** | | **Ziel:** Nachweisen, dass der Slave sich exakt an die MODBUS-Spezifikation hält. |
+| ☐ | 2.1 Slave-Node mit PC via USB-MODBUS-Adapter testen | | **Kritischer Meilenstein.** Mit Tools wie "QModMaster" oder einem Python-Skript die Register lesen & schreiben. Die Slave-Firmware wird so unabhängig vom Gateway validiert. |
+| ☐ | 2.2 Firmware-Update Mechanismus testen | | Den kompletten Update-Prozess (Chunking, CRC-Check) mit einem Skript vom PC aus testen. Der Slave schreibt die Firmware dabei vorerst nur in einen ungenutzten RAM-Bereich. |
+| ☐ | **Phase 3: Hardware-Design und Prototypenbau** | | **Ziel:** Von der Entwicklung auf dem Eval-Board zum massgeschneiderten PCB. |
+| ☐ | 3.1 Schaltplan und PCB-Layout für Slave-Node entwerfen | | Basierend auf den Erfahrungen mit dem Eval-Board. |
+| ☐ | 3.2 Prototypen-Platinen bestellen und bestücken | | Z.B. bei JLCPCB. THT-Komponenten (Stecker etc.) selbst löten. |
+| ☐ | 3.3 Hardware-Inbetriebnahme des ersten Prototyps | | Spannungen prüfen, Firmware aufspielen und die Tests aus Phase 2 wiederholen, um die Hardware zu validieren. |
+| ☐ | 3.4 Flash-Schreibroutine für Firmware-Update implementieren | | Den in Schritt 2.2 im RAM validierten Prozess nun auf den echten Flash-Speicher anwenden. |
+| ☐ | **Phase 4: Gateway Entwicklung (ESP32 Eval-Board)** | | **Ziel:** Die Brücke von der RS485-Welt ins Heimnetzwerk bauen. |
+| ☐ | 4.1 Gateway-Firmware (ESPHome) erstellen | | Einfaches MODBUS TCP zu RTU Gateway auf dem ESP32C6 Eval-Board aufsetzen. |
+| ☐ | 4.2 Gateway mit Slave-Node Prototyp verbinden und testen | | Test der Kette: PC (als MODBUS TCP Client) -> WLAN -> Gateway -> RS485 -> Slave. |
+| ☐ | **Phase 5: System-Integration in Home Assistant** | | **Ziel:** Das System "smart" machen. |
+| ☐ | 5.1 MODBUS-Integration in Home Assistant konfigurieren | | Anlegen der Sensoren und Entitäten für den Slave-Node in der `configuration.yaml` oder über die UI. |
+| ☐ | 5.2 Dashboards und Automationen in HA erstellen | | Visualisierung der Zustände (Ventil, Pumpe etc.) und Erstellen der eigentlichen Bewässerungs-Logik. |
+| ☐ | 5.3 Python-Skript für Firmware-Update in HA entwickeln | | Implementierung des Chunk-basierten Uploads als Skript, das aus HA heraus aufgerufen werden kann. |
+| ☐ | **Phase 6: Aufbau und Inbetriebnahme** | | **Ziel:** Das fertige System installieren. |
+| ☐ | 6.1 Alle benötigten Slave-Nodes aufbauen und testen | | Jeden Slave einzeln mit dem PC via USB-Adapter testen und die MODBUS-Adresse konfigurieren. |
+| ☐ | 6.2 System final installieren und verkabeln | | Einbau der Komponenten in den Schuppen, Verkabelung des RS485-Busses. |
+| ☐ | 6.3 Gesamtsystemtest und Kalibrierung | | Füllstandsensor kalibrieren, Laufzeiten der Ventile prüfen, Fail-Safe-Verhalten testen. |

docs/planning.en.md

@@ -0,0 +1,33 @@
+[🇩🇪 Deutsch](planning.de.md) | 🇬🇧 English | [🇫🇷 Français](planning.fr.md) | [🇪🇸 Español](planning.es.md)
+
+# Project Plan: Modular Irrigation System
+
+| Done | Task | Date | Remarks |
+| :---: | :--- | :--- | :--- |
+| ✅ | **Phase 0: Planning & Definition** | | |
+| ✅ | Create and finalize concept | 2025-06-30 | Architecture, components and basic architecture are defined. |
+| ✅ | Define MODBUS Register Map | 2025-06-30 | The "API" of the slaves is defined and forms the basis for software development. |
+| ☐ | **Phase 1: Slave Node Prototype (STM32 Eval-Board)** | | **Goal:** A single slave is brought to life on the eval board. |
+| ✅ | 1.1 Set up development environment for STM32/Zephyr | 2025-06-30 | Install toolchain, VS Code, Zephyr-SDK, MCUBoot etc. and get a "Hello World" running. |
+| ☐ | 1.2 Create basic firmware for slave node | | Implement hardware abstraction (GPIOs, ADC, UART for RS485). |
+| ☐ | 1.3 Implement MODBUS-RTU stack on the slave | | Based on the defined register map. Initially only read functions (status, version). |
+| ☐ | 1.4 Implement core logic (e.g. valve control) | | Implementation of the `VALVE_STATE_MOVEMENT` logic, current measurement for end positions etc. |
+| ☐ | **Phase 2: Verification of the Slave Firmware** | | **Goal:** Prove that the slave adheres exactly to the MODBUS specification. |
+| ☐ | 2.1 Test slave node with PC via USB-MODBUS adapter | | **Critical milestone.** Read & write the registers with tools like "QModMaster" or a Python script. The slave firmware is thus validated independently of the gateway. |
+| ☐ | 2.2 Test firmware update mechanism | | Test the complete update process (chunking, CRC check) with a script from the PC. The slave initially only writes the firmware to an unused RAM area. |
+| ☐ | **Phase 3: Hardware Design and Prototype Construction** | | **Goal:** From development on the eval board to a customized PCB. |
+| ☐ | 3.1 Design schematic and PCB layout for slave node | | Based on the experience with the eval board. |
+| ☐ | 3.2 Order and assemble prototype boards | | E.g. at JLCPCB. Solder THT components (connectors etc.) yourself. |
+| ☐ | 3.3 Hardware commissioning of the first prototype | | Check voltages, upload firmware and repeat the tests from phase 2 to validate the hardware. |
+| ☐ | 3.4 Implement flash write routine for firmware update | | Apply the process validated in RAM in step 2.2 to the real flash memory. |
+| ☐ | **Phase 4: Gateway Development (ESP32 Eval-Board)** | | **Goal:** Build the bridge from the RS485 world to the home network. |
+| ☐ | 4.1 Create gateway firmware (ESPHome) | | Set up a simple MODBUS TCP to RTU gateway on the ESP32C6 eval board. |
+| ☐ | 4.2 Connect and test gateway with slave node prototype | | Test the chain: PC (as MODBUS TCP client) -> WLAN -> Gateway -> RS485 -> Slave. |
+| ☐ | **Phase 5: System Integration in Home Assistant** | | **Goal:** Make the system "smart". |
+| ☐ | 5.1 Configure MODBUS integration in Home Assistant | | Create the sensors and entities for the slave node in `configuration.yaml` or via the UI. |
+| ☐ | 5.2 Create dashboards and automations in HA | | Visualization of the states (valve, pump etc.) and creation of the actual irrigation logic. |
+| ☐ | 5.3 Develop Python script for firmware update in HA | | Implementation of the chunk-based upload as a script that can be called from HA. |
+| ☐ | **Phase 6: Setup and Commissioning** | | **Goal:** Install the finished system. |
+| ☐ | 6.1 Build and test all required slave nodes | | Test each slave individually with the PC via USB adapter and configure the MODBUS address. |
+| ☐ | 6.2 Final installation and cabling of the system | | Installation of the components in the shed, cabling of the RS485 bus. |
+| ☐ | 6.3 Overall system test and calibration | | Calibrate level sensor, check valve running times, test fail-safe behavior. |

docs/planning.es.md

@@ -0,0 +1,33 @@
+[🇩🇪 Deutsch](planning.de.md) | [🇬🇧 English](planning.en.md) | [🇫🇷 Français](planning.fr.md) | 🇪🇸 Español
+
+# Plan del proyecto: Sistema de riego modular
+
+| Hecho | Tarea | Fecha | Observaciones |
+| :---: | :--- | :--- | :--- |
+| ✅ | **Fase 0: Planificación y definición** | | |
+| ✅ | Crear y finalizar el concepto | 30.06.2025 | La arquitectura, los componentes y la arquitectura básica están definidos. |
+| ✅ | Definir el mapa de registros MODBUS | 30.06.2025 | La "API" de los esclavos está definida y constituye la base para el desarrollo del software. |
+| ☐ | **Fase 1: Prototipo de nodo esclavo (placa de evaluación STM32)** | | **Objetivo:** Un único esclavo cobra vida en la placa de evaluación. |
+| ✅ | 1.1 Configurar el entorno de desarrollo para STM32/Zephyr | 30.06.2025 | Instalar la cadena de herramientas, VS Code, el SDK de Zephyr, MCUBoot, etc. y hacer que funcione un "Hola Mundo". |
+| ☐ | 1.2 Crear el firmware básico para el nodo esclavo | | Implementar la abstracción de hardware (GPIO, ADC, UART para RS485). |
+| ☐ | 1.3 Implementar la pila MODBUS-RTU en el esclavo | | Basado en el mapa de registros definido. Inicialmente solo funciones de lectura (estado, versión). |
+| ☐ | 1.4 Implementar la lógica central (p. ej., control de válvulas) | | Implementación de la lógica `VALVE_STATE_MOVEMENT`, medición de corriente para posiciones finales, etc. |
+| ☐ | **Fase 2: Verificación del firmware del esclavo** | | **Objetivo:** Demostrar que el esclavo se adhiere exactamente a la especificación MODBUS. |
+| ☐ | 2.1 Probar el nodo esclavo con un PC a través de un adaptador USB-MODBUS | | **Hito crítico.** Leer y escribir los registros con herramientas como "QModMaster" o un script de Python. El firmware del esclavo se valida así independientemente de la puerta de enlace. |
+| ☐ | 2.2 Probar el mecanismo de actualización de firmware | | Probar el proceso de actualización completo (fragmentación, comprobación de CRC) con un script desde el PC. El esclavo inicialmente solo escribe el firmware en un área de RAM no utilizada. |
+| ☐ | **Fase 3: Diseño de hardware y construcción de prototipos** | | **Objetivo:** Pasar del desarrollo en la placa de evaluación a un PCB a medida. |
+| ☐ | 3.1 Diseñar el esquema y el diseño del PCB para el nodo esclavo | | Basado en la experiencia con la placa de evaluación. |
+| ☐ | 3.2 Pedir y ensamblar placas prototipo | | Por ejemplo, en JLCPCB. Soldar los componentes THT (conectores, etc.) uno mismo. |
+| ☐ | 3.3 Puesta en marcha del hardware del primer prototipo | | Comprobar voltajes, cargar el firmware y repetir las pruebas de la fase 2 para validar el hardware. |
+| ☐ | 3.4 Implementar la rutina de escritura en flash para la actualización del firmware | | Aplicar el proceso validado en la RAM en el paso 2.2 a la memoria flash real. |
+| ☐ | **Fase 4: Desarrollo de la puerta de enlace (placa de evaluación ESP32)** | | **Objetivo:** Construir el puente desde el mundo RS485 a la red doméstica. |
+| ☐ | 4.1 Crear el firmware de la puerta de enlace (ESPHome) | | Configurar una puerta de enlace simple de MODBUS TCP a RTU en la placa de evaluación ESP32C6. |
+| ☐ | 4.2 Conectar y probar la puerta de enlace con el prototipo de nodo esclavo | | Probar la cadena: PC (como cliente MODBUS TCP) -> WLAN -> Puerta de enlace -> RS485 -> Esclavo. |
+| ☐ | **Fase 5: Integración del sistema en Home Assistant** | | **Objetivo:** Hacer que el sistema sea "inteligente". |
+| ☐ | 5.1 Configurar la integración de MODBUS en Home Assistant | | Crear los sensores y las entidades para el nodo esclavo en `configuration.yaml` o a través de la interfaz de usuario. |
+| ☐ | 5.2 Crear paneles y automatizaciones en HA | | Visualización de los estados (válvula, bomba, etc.) y creación de la lógica de riego real. |
+| ☐ | 5.3 Desarrollar un script de Python para la actualización de firmware en HA | | Implementación de la carga basada en fragmentos como un script que se puede llamar desde HA. |
+| ☐ | **Fase 6: Montaje y puesta en marcha** | | **Objetivo:** Instalar el sistema terminado. |
+| ☐ | 6.1 Construir y probar todos los nodos esclavos necesarios | | Probar cada esclavo individualmente con el PC a través de un adaptador USB y configurar la dirección MODBUS. |
+| ☐ | 6.2 Instalación final y cableado del sistema | | Instalación de los componentes en el cobertizo, cableado del bus RS485. |
+| ☐ | 6.3 Prueba y calibración general del sistema | | Calibrar el sensor de nivel, comprobar los tiempos de funcionamiento de las válvulas, probar el comportamiento a prueba de fallos. |

docs/planning.fr.md

@@ -0,0 +1,33 @@
+[🇩🇪 Deutsch](planning.de.md) | [🇬🇧 English](planning.en.md) | 🇫🇷 Français | [🇪🇸 Español](planning.es.md)
+
+# Plan de projet : Système d'irrigation modulaire
+
+| Fait | Tâche | Date | Remarques |
+| :---: | :--- | :--- | :--- |
+| ✅ | **Phase 0 : Planification & Définition** | | |
+| ✅ | Créer et finaliser le concept | 30.06.2025 | L'architecture, les composants et l'architecture de base sont définis. |
+| ✅ | Définir la carte des registres MODBUS | 30.06.2025 | L'"API" des esclaves est définie et constitue la base du développement logiciel. |
+| ☐ | **Phase 1 : Prototype de nœud esclave (carte d'évaluation STM32)** | | **Objectif :** Un seul esclave est mis en service sur la carte d'évaluation. |
+| ✅ | 1.1 Mettre en place l'environnement de développement pour STM32/Zephyr | 30.06.2025 | Installer la chaîne d'outils, VS Code, le SDK Zephyr, MCUBoot, etc. et faire fonctionner un "Hello World". |
+| ☐ | 1.2 Créer le firmware de base pour le nœud esclave | | Implémenter l'abstraction matérielle (GPIO, ADC, UART pour RS485). |
+| ☐ | 1.3 Implémenter la pile MODBUS-RTU sur l'esclave | | Basé sur la carte des registres définie. D'abord uniquement les fonctions de lecture (état, version). |
+| ☐ | 1.4 Implémenter la logique de base (par ex. commande de vanne) | | Implémentation de la logique `VALVE_STATE_MOVEMENT`, mesure du courant pour les positions finales, etc. |
+| ☐ | **Phase 2 : Vérification du firmware de l'esclave** | | **Objectif :** Prouver que l'esclave respecte exactement la spécification MODBUS. |
+| ☐ | 2.1 Tester le nœud esclave avec un PC via un adaptateur USB-MODBUS | | **Jalon critique.** Lire et écrire les registres avec des outils comme "QModMaster" ou un script Python. Le firmware de l'esclave est ainsi validé indépendamment de la passerelle. |
+| ☐ | 2.2 Tester le mécanisme de mise à jour du firmware | | Tester le processus de mise à jour complet (fragmentation, vérification CRC) avec un script depuis le PC. L'esclave n'écrit d'abord le firmware que dans une zone RAM inutilisée. |
+| ☐ | **Phase 3 : Conception matérielle et construction de prototypes** | | **Objectif :** Passer du développement sur la carte d'évaluation à un PCB sur mesure. |
+| ☐ | 3.1 Concevoir le schéma et le layout du PCB pour le nœud esclave | | Basé sur l'expérience avec la carte d'évaluation. |
+| ☐ | 3.2 Commander et assembler les cartes prototypes | | Par ex. chez JLCPCB. Souder soi-même les composants THT (connecteurs, etc.). |
+| ☐ | 3.3 Mise en service matérielle du premier prototype | | Vérifier les tensions, charger le firmware et répéter les tests de la phase 2 pour valider le matériel. |
+| ☐ | 3.4 Implémenter la routine d'écriture flash pour la mise à jour du firmware | | Appliquer le processus validé en RAM à l'étape 2.2 à la mémoire flash réelle. |
+| ☐ | **Phase 4 : Développement de la passerelle (carte d'évaluation ESP32)** | | **Objectif :** Construire le pont entre le monde RS485 et le réseau domestique. |
+| ☐ | 4.1 Créer le firmware de la passerelle (ESPHome) | | Mettre en place une simple passerelle MODBUS TCP vers RTU sur la carte d'évaluation ESP32C6. |
+| ☐ | 4.2 Connecter et tester la passerelle avec le prototype de nœud esclave | | Tester la chaîne : PC (en tant que client MODBUS TCP) -> WLAN -> Passerelle -> RS485 -> Esclave. |
+| ☐ | **Phase 5 : Intégration du système dans Home Assistant** | | **Objectif :** Rendre le système "intelligent". |
+| ☐ | 5.1 Configurer l'intégration MODBUS dans Home Assistant | | Créer les capteurs et les entités pour le nœud esclave dans `configuration.yaml` ou via l'interface utilisateur. |
+| ☐ | 5.2 Créer des tableaux de bord et des automatisations dans HA | | Visualisation des états (vanne, pompe, etc.) et création de la logique d'irrigation réelle. |
+| ☐ | 5.3 Développer un script Python pour la mise à jour du firmware dans HA | | Implémentation du téléchargement basé sur des fragments sous forme de script pouvant être appelé depuis HA. |
+| ☐ | **Phase 6 : Montage et mise en service** | | **Objectif :** Installer le système final. |
+| ☐ | 6.1 Construire et tester tous les nœuds esclaves nécessaires | | Tester chaque esclave individuellement avec le PC via un adaptateur USB et configurer l'adresse MODBUS. |
+| ☐ | 6.2 Installation finale et câblage du système | | Installation des composants dans l'abri, câblage du bus RS485. |
+| ☐ | 6.3 Test et calibrage de l'ensemble du système | | Calibrer le capteur de niveau, vérifier les temps de fonctionnement des vannes, tester le comportement de sécurité. |

hardware/Valve Node.kicad_sch

@@ -139,6 +139,16 @@
 		)
 		(uuid "bb67995e-dd26-405f-a180-469631afb974")
 	)
+	(wire
+		(pts
+			(xy 87.63 71.12) (xy 115.57 71.12)
+		)
+		(stroke
+			(width 0)
+			(type default)
+		)
+		(uuid "ce130c11-4895-4efc-9628-ec9d597d9ae6")
+	)
 	(wire
 		(pts
 			(xy 87.63 80.01) (xy 115.57 80.01)
@@ -499,6 +509,16 @@
 				(justify left)
 			)
 		)
+		(pin "Ivalve" output
+			(at 115.57 71.12 180)
+			(uuid "8d6736b5-3866-4df2-bad1-f2395c16d41f")
+			(effects
+				(font
+					(size 1.27 1.27)
+				)
+				(justify left)
+			)
+		)
 		(instances
 			(project "Valve Node"
 				(path "/161a9599-9ba4-4610-99d7-67cfc29e63e3"
@@ -581,26 +601,6 @@
 				(justify right)
 			)
 		)
-		(pin "ESclose" input
-			(at 87.63 87.63 0)
-			(uuid "a290c1a4-d848-4121-a675-4dd8e2e53a46")
-			(effects
-				(font
-					(size 1.27 1.27)
-				)
-				(justify right)
-			)
-		)
-		(pin "ESopen" input
-			(at 87.63 85.09 0)
-			(uuid "aa847fd3-ccb3-4c7d-b0b7-91459ad41b22")
-			(effects
-				(font
-					(size 1.27 1.27)
-				)
-				(justify right)
-			)
-		)
 		(pin "LEDclose" output
 			(at 87.63 92.71 0)
 			(uuid "a8dbd0ef-81a9-476b-87d5-ae62f707d780")
@@ -621,6 +621,16 @@
 				(justify right)
 			)
 		)
+		(pin "Ivalve" input
+			(at 87.63 71.12 0)
+			(uuid "de7fd0b6-2acb-41c1-b304-b822527b109f")
+			(effects
+				(font
+					(size 1.27 1.27)
+				)
+				(justify right)
+			)
+		)
 		(instances
 			(project "Valve Node"
 				(path "/161a9599-9ba4-4610-99d7-67cfc29e63e3"

hardware/mcu.kicad_sch

@@ -3917,6 +3917,16 @@
 		)
 		(uuid "55981764-88f2-4c2a-bf6c-5e4515fc277b")
 	)
+	(wire
+		(pts
+			(xy 113.03 91.44) (xy 115.57 91.44)
+		)
+		(stroke
+			(width 0)
+			(type default)
+		)
+		(uuid "593d204f-ecbe-4ab2-acc6-25391daa36dc")
+	)
 	(wire
 		(pts
 			(xy 161.29 66.04) (xy 163.83 66.04)
@@ -5000,6 +5010,17 @@
 		)
 		(uuid "7df5abcb-1774-4d7e-acd9-7ec9198519d8")
 	)
+	(hierarchical_label "Ivalve"
+		(shape input)
+		(at 113.03 91.44 180)
+		(effects
+			(font
+				(size 1.27 1.27)
+			)
+			(justify right)
+		)
+		(uuid "90c664f3-747f-4ac7-a243-011a4fda9492")
+	)
 	(hierarchical_label "STclose"
 		(shape input)
 		(at 153.67 81.28 0)

software/CMakeLists.txt

@@ -2,24 +2,13 @@
 
 cmake_minimum_required(VERSION 3.20.0)
 
+# This line should ideally be after project() and find_package(Zephyr)
+# target_include_directories(app PRIVATE ${ZEPHYR_BASE}/include/zephyr/drivers) # <-- WRONG POSITION
+
 list(APPEND BOARD_ROOT ${CMAKE_CURRENT_SOURCE_DIR})
 
 find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE})
 project(valve_node)
 
-target_sources(app PRIVATE src/main.c)
-target_sources(app PRIVATE lib/canbus.c)
-
-# source files for modbus waterlevel sensor
-zephyr_library_sources_ifdef(CONFIG_HAS_MODBUS_WATERLEVEL_SENSOR
-    lib/waterlevel_sensor.c
-)
-
-#source files for valve
-zephyr_library_sources_ifdef(CONFIG_HAS_VALVE
-    lib/valve.c
-)
-
-zephyr_include_directories(
-    lib
-)
+target_include_directories(app PRIVATE ${ZEPHYR_BASE}/include/zephyr/drivers)
+target_sources(app PRIVATE src/main2.c)

software/CMakeLists.txt.orig

@@ -0,0 +1,25 @@
+# SPDX-License-Identifier: Apache-2.0
+
+cmake_minimum_required(VERSION 3.20.0)
+
+list(APPEND BOARD_ROOT ${CMAKE_CURRENT_SOURCE_DIR})
+
+find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE})
+project(valve_node)
+
+target_sources(app PRIVATE src/main.c)
+target_sources(app PRIVATE lib/canbus.c)
+
+# source files for modbus waterlevel sensor
+zephyr_library_sources_ifdef(CONFIG_HAS_MODBUS_WATERLEVEL_SENSOR
+    lib/waterlevel_sensor.c
+)
+
+#source files for valve
+zephyr_library_sources_ifdef(CONFIG_HAS_VALVE
+    lib/valve.c
+)
+
+zephyr_include_directories(
+    lib
+)

software/boards/iten/valve_node/valve_node.dts

@@ -5,13 +5,14 @@
  */
 
 /dts-v1/;
+#include <st/f1/stm32f1.dtsi>
 #include <st/f1/stm32f103Xb.dtsi>
 #include <st/f1/stm32f103r(8-b)tx-pinctrl.dtsi>
 #include <zephyr/dt-bindings/input/input-event-codes.h>
 
 / {
 	model = "Iten engineering Valve Node";
-	compatible = "iten,valve-node", "st,stm32f103rb";
+	compatible = "st,stm32f103rb";
 
 	can_loopback0: can_loopback0 {
 		status = "disabled";
@@ -24,7 +25,6 @@
 		zephyr,sram = &sram0;
 		zephyr,flash = &flash0;
 		zephyr,canbus = &can1;
-		//zephyr,canbus = &can_loopback0;
 	};
 
 	leds: leds {
@@ -71,19 +71,10 @@
 		sw0 = &user_button;
 		watchdog0 = &iwdg;
 		die-temp0 = &die_temp;
+		adc-motor-current = &motor_current_channel;
+		adc-vref = &vref_channel;
 	};
 
-
-	zephyr,user {
-		motoropen: motor_open {
-			gpios = <&gpiob 13 0>;
-			label = "Motor Open";
-		};
-		fake: fake {
-			gpios = <&gpiob 11 GPIO_PULL_UP>;
-			label = "CAN RX pullup";
-		};
-	};
 };
 
 &clk_lsi {
@@ -107,7 +98,7 @@
 	ahb-prescaler = <1>;
 	apb1-prescaler = <2>;
 	apb2-prescaler = <1>;
-	adc-prescaler = <2>;
+	adc-prescaler = <6>;
 };
 
 &usart1 {
@@ -125,7 +116,6 @@
 	modbus0 {
 		compatible = "zephyr,modbus-serial";
 		status = "okay";
-		//de-gpios = <&gpioa 15 GPIO_ACTIVE_LOW>;
 	};
 };
 
@@ -153,9 +143,28 @@
 };
 
 &adc1 {
-	pinctrl-0 = <&adc1_in0_pa0>;
+	pinctrl-0 = <&adc_pb1_pins>;
 	pinctrl-names = "default";
 	status = "okay";
+
+	#address-cells = <1>;
+	#size-cells = <0>;
+
+	motor_current_channel: channel@9 {
+		reg = <0x9>;
+		zephyr,gain = "ADC_GAIN_1";
+		zephyr,reference = "ADC_REF_VDD_1";
+		zephyr,acquisition-time = <49159>;
+		zephyr,resolution = <12>;
+	};
+
+	vref_channel: channel@11 { /* 17 dezimal = 11 hex */
+		reg = <0x11>;
+		zephyr,gain = "ADC_GAIN_1";
+		zephyr,reference = "ADC_REF_VDD_1";
+		zephyr,acquisition-time = <49159>;
+		zephyr,resolution = <12>;
+	};
 };
 
 &die_temp {
@@ -172,7 +181,6 @@
 		#address-cells = <1>;
 		#size-cells = <1>;
 
-		/* Set 2KB of storage at the end of 128KB flash */
 		storage_partition: partition@1f800 {
 			label = "storage";
 			reg = <0x0001f800 DT_SIZE_K(2)>;
@@ -184,9 +192,15 @@
 	pinctrl-0 = <&can_rx_pa11 &can_tx_pa12>;
 	pinctrl-names = "default";
 	status= "okay";
-	bus-speed = <125000>;
+	bitrate = <125000>;
 };
 
 &exti {
 	status = "okay";
 };
+
+&pinctrl {
+	adc_pb1_pins: adc_pb1_pins {
+		pinmux = <STM32F1_PINMUX('B', 1, ANALOG, NO_REMAP)>;
+	};
+};

software/lib/waterlevel_sensor.c

@@ -32,7 +32,6 @@ struct modbus_iface_param client_param = {
     .serial = {
         .baud = 9600,
         .parity = UART_CFG_PARITY_NONE,
-        .stop_bits_client = UART_CFG_STOP_BITS_1, // 1 stop bit for Modbus RTU
     },
 };
 

software/prj.conf

@@ -15,3 +15,6 @@ CONFIG_SHELL=y
 CONFIG_CAN_SHELL=y
 CONFIG_GPIO_SHELL=y
 CONFIG_REBOOT=y
+
+CONFIG_ADC=y
+CONFIG_ADC_STM32=y

software/src/main2.c

@@ -0,0 +1,86 @@
+#include <zephyr/kernel.h>
+#include <zephyr/drivers/adc.h>
+#include <zephyr/logging/log.h>
+#include <zephyr/device.h>
+#include <zephyr/devicetree.h>
+#include <stdint.h>
+
+LOG_MODULE_REGISTER(main2, LOG_LEVEL_DBG);
+
+#define MOTOR_ADC_NODE DT_ALIAS(adc_motor_current)
+#define VREF_ADC_NODE  DT_ALIAS(adc_vref)
+
+static const struct device * const adc_dev = DEVICE_DT_GET(DT_PARENT(MOTOR_ADC_NODE));
+static const uint8_t motor_channel_id = DT_REG_ADDR(MOTOR_ADC_NODE);
+static const uint8_t vref_channel_id = DT_REG_ADDR(VREF_ADC_NODE);
+
+int main(void)
+{
+    int err;
+    int16_t adc_raw_value;
+
+    LOG_INF("Starting ADC test with direct register setup...");
+
+    if (!device_is_ready(adc_dev)) {
+        LOG_ERR("ADC device is not ready");
+        return 0;
+    }
+
+    LOG_INF("Manually setting up ADC registers...");
+
+    uint32_t adc_base = DT_REG_ADDR(DT_NODELABEL(adc1));
+
+    volatile uint32_t *ADC_CR2   = (uint32_t *)(adc_base + 0x08);
+    volatile uint32_t *ADC_SMPR1 = (uint32_t *)(adc_base + 0x0C);
+    volatile uint32_t *ADC_SMPR2 = (uint32_t *)(adc_base + 0x10);
+
+    // Schritt 1: Internen VREFINT-Kanal einschalten
+    const uint32_t ADC_CR2_TSVREFE_BIT = 23;
+    *ADC_CR2 |= (1 << ADC_CR2_TSVREFE_BIT);
+    LOG_INF("VREFINT channel enabled via CR2 register.");
+
+    // Schritt 2: Lange Abtastzeiten für Stabilität setzen
+    *ADC_SMPR2 |= (0b111 << (3 * 9));
+    *ADC_SMPR1 |= (0b111 << (3 * (17 - 10)));
+    LOG_INF("Acquisition times set directly in SMPR registers.");
+
+
+    k_busy_wait(10);
+
+
+    while (1) {
+        int32_t motor_raw = 0;
+        int32_t vref_raw = 0;
+        
+        struct adc_sequence sequence = {
+            .buffer      = &adc_raw_value,
+            .buffer_size = sizeof(adc_raw_value),
+            .resolution  = 12,
+        };
+
+        // Motor-Kanal lesen
+        sequence.channels = BIT(motor_channel_id);
+        if (adc_read(adc_dev, &sequence) == 0) {
+            motor_raw = adc_raw_value;
+        }
+
+        // VREF-Kanal lesen
+        sequence.channels = BIT(vref_channel_id);
+        if (adc_read(adc_dev, &sequence) == 0) {
+            vref_raw = adc_raw_value;
+        }
+
+        // VDD-Berechnung mit dem generischen, aber für Sie gut funktionierenden 1200mV-Wert
+        int32_t vdd_mv = (vref_raw > 0) ? (1200 * 4095 / vref_raw) : 0;
+        int32_t motor_mv = 0;
+        
+        if (motor_raw > 0 && vdd_mv > 0) {
+            motor_mv = motor_raw;
+            err = adc_raw_to_millivolts(vdd_mv, ADC_GAIN_1, 12, &motor_mv);
+        }
+        
+        LOG_INF("Motor Raw: %4d, Motor mV: %4d | VDD: %4d mV", motor_raw, motor_mv, vdd_mv);
+        k_sleep(K_MSEC(2000));
+    }
+    return 0;
+}