--- title: "Resi Dali - Konfiguration" description: "DALI 2.0 Geräte am RESI-DALI-SIO/ETH Gateway aus TapHome in Betrieb nehmen: Kurzadressen 0–63 zuweisen, Gerätetyp prüfen, Broadcast-Tests über Modbus." url: "https://taphome.com/de/compatibility/resi-dali-daliconfig/" language: de lastmod: 2026-11-15 generator: hugo ai: topics: ["modbus-rtu","lighting","dali","dali-2.0","rs485","din-rail","commissioning","addressing","gateway"] questions: ["Wie weise ich DALI-Kurzadressen aus TapHome zu?","Wie nehme ich DALI 2.0 Steuergeräte mit dem RESI-DALI-SIO Gateway in Betrieb?","Was macht die Vorlage Resi Dali - Konfiguration in TapHome?","Wie stelle ich die Modbus Slave ID auf einem RESI-DALI-SIO / RESI-DALI-ETH ein?","Wie verdrahte ich den RESI-DALI-SIO an einen DALI-Bus mit RESI-DALI-PS Netzteil?","Was ist der Unterschied zwischen den Vorlagen Resi Dali - Konfiguration und der operativen Resi Dali?","Warum hat die DaliConfig-Vorlage einen IP-Adress-Importparameter auf einem RTU-Gateway?"] --- # Resi Dali - Konfiguration Kommunikation: Modbus RTU - [Produktseite RESI-DALI-SIO/ETH/PS](https://www.resi.cc/prestashop/en/home/1-resi-dali-sioethps.html) - [RESI Informatik & Automation](https://www.resi.cc) ## Integrationsanleitung Die Vorlage **Resi Dali - Konfiguration** ist ein einmaliges **Inbetriebnahme- und Adressierungstool** für das Modbus-zu-DALI-Gateway RESI-DALI-SIO und RESI-DALI-ETH von RESI Informatik & Automation GmbH. Sie steuert den DALI 2.0 Random-Addressing-Algorithmus direkt aus TapHome, um Steuergeräten an einem neu verkabelten DALI-Bus Kurzadressen 0–63 zuzuweisen, prüft bei jeder Adresse den DALI-Gerätetyp und bietet schnelle Broadcast-ON/OFF-Tests — alles was benötigt wird, um eine frische Installation in einen Zustand zu bringen, in dem Leuchten einzeln gesteuert werden können. Die Kommunikation mit dem Gateway erfolgt über Modbus RTU mit 9600 Baud 8N1. Die Vorlage stellt außerdem einen `IpAddress` Importparameter bereit, sodass der gleiche Ablauf auch über eine Serial-to-IP-Bridge (Moxa NPort, USR-TCP232) oder über einen RESI-DALI-ETH im transparenten RTU-over-Ethernet-Modus funktioniert. > [!NOTE] > Diese Vorlage ist bewusst **nur für die Adressierung** gedacht. Sobald die Kurzadressen zugewiesen sind, entfernen Sie das Resi Dali - Konfiguration Modul aus dem Projekt und verwenden Sie für die tägliche Steuerung die operative Schwestervorlage **Resi DALI** (`Dali.xml`) — Einzeldimmung von Leuchten, Gruppendimmung und Diagnose pro Gear. Das Konfigurationsmodul ist nicht dafür ausgelegt, nach der Ersteinrichtung im Projekt zu bleiben. ## Hardware-Anschluss Der RESI-DALI-SIO ist ein Hutschienen-Master-Gateway (17,5 × 90 × 56,4 mm, CEM17), das zwischen einem seriellen/Ethernet-Host und einem DALI-Lichtbus sitzt. Das Gateway **speist den DALI-Bus nicht** — ein kompatibles DALI-Netzteil (RESI-DALI-PS oder ein beliebiges normkonformes 200 mA DALI-Netzteil) ist zwingend erforderlich. ### Anschluss des RESI-DALI-SIO (RS-485) ![Anschlussdiagramm RESI-DALI-SIO — externes DALI-Netzteil (oben) und mit RESI-DALI-PS (unten)](https://taphome.com/images/compatibility/resi-dali-daliconfig/wiring-sio_hu_1af043ee91b2b0ed.jpg) Klemmen auf der linken Seite des RESI-DALI-SIO (von oben nach unten): `GND`, `+12..48V=`, `RS485 DATA+ (A+)`, `RS485 DATA- (B-)`, `RS485 GND`, `RS232 TX`, `RS232 RX`, `RS232 GND`. Die DALI-Bus-Klemmen auf der gegenüberliegenden Seite sind **`D+ / N/C / D-`** (3-poliger USLIM-Block, `N/C` bleibt unbeschaltet). Für eine TapHome-Installation verwenden Sie die RS-485-Schnittstelle: - `RS485 DATA+ (A+)` → A+/D+ am TapHome RS-485-Bus - `RS485 DATA- (B-)` → B-/D- am TapHome RS-485-Bus - `RS485 GND` → GND am TapHome-Netzteil (empfohlen für stabile Kommunikation) - `+12..48V=` / `GND` → 12–48 V DC Primärversorgung ### Anschluss des RESI-DALI-ETH (Ethernet) ![Anschlussdiagramm RESI-DALI-ETH — externes DALI-Netzteil (oben) und mit RESI-DALI-PS (unten)](https://taphome.com/images/compatibility/resi-dali-daliconfig/wiring-eth_hu_4bf0a5e8d8724d0b.jpg) Die Ethernet-Variante hat dieselben DALI-Bus-Klemmen (`D+ / N/C / D-`) und Primärversorgung (`GND`, `+12..48V=`) sowie einen einzelnen RJ45-Anschluss für 10/100 Mbit Ethernet. Die werkseitigen Standard-IP-Einstellungen sind **192.168.0.191 / 255.255.255.0 / 192.168.0.1** mit Modbus Unit ID 255; die Web-UI-Zugangsdaten sind `RESI` / `RESI`. TapHome kommuniziert mit der ETH-Variante im transparenten RTU-over-Ethernet-Modus, den diese Konfigurationsvorlage erwartet (siehe Konfiguration unten). ### DALI-Bus-Netzteil ![RESI-DALI-PS — eigenständige DALI-Bus-Versorgung (oben) und in Kombination mit einem SIO/ETH-Gateway (unten)](https://taphome.com/images/compatibility/resi-dali-daliconfig/wiring-dali-ps_hu_bea720a419338afa.jpg) Der RESI-DALI-PS liefert bis zu **200 mA** am DALI-Bus (Kurzschlussstrom ~225 mA, typische Busspannung 14–18 V) und unterstützt bis zu 64 DALI 1.0 Vorschaltgeräte oder DALI 2.0 Steuergeräte auf einer einzigen Linie. Die Primärseite akzeptiert die gleiche 12–48 V DC Versorgung wie die SIO/ETH-Einheit. Gateway und Netzteil greifen auf dasselbe `D+` / `D-` Paar zu — das Netzteil speist den Bus, während das Gateway DALI-Frames liest und schreibt. Drei LEDs am Netzteil helfen während der Inbetriebnahme: **POWER** (primäre 12–48 V OK, leuchtet immer), **DALI** (blinkt kurz bei Busverkehr), **ERR** (leuchtet dauerhaft bei Netzteilfehler, DALI-Kurzschluss oder Busüberlastung — muss im Normalbetrieb aus sein). ### DALI-Bus-Regeln Eine DALI-Linie unterliegt einigen strikten Einschränkungen, die den Erfolg der Inbetriebnahme direkt beeinflussen: | Leiterquerschnitt | Max. DALI-Kabellänge | |-------------------|---------------------| | 1,5 mm² | 300 m | | 1,0 mm² | 238 m | | 0,75 mm² | 174 m | | 0,5 mm² | 116 m | Die Grenze ergibt sich aus dem maximal zulässigen **Spannungsabfall von 2 V** am DALI-Kabel. Weitere Regeln: - Maximal 64 DALI 1.0 Vorschaltgeräte **und** bis zu 64 DALI 2.0 Steuergeräte pro Bus (getrennte Kurzadress-Räume). - Nur Baumtopologie — keine Ringe, keine Schleifen. - Die tatsächliche Anzahl der Geräte hängt auch von der Strombelastbarkeit des Netzteils ab (typisch 200 mA am RESI-DALI-PS, rechnen Sie mit ~2 mA pro Gerät plus Reserve). > [!WARNING] > **Der RESI-DALI-PS (oder ein gleichwertiges DALI-Netzteil) ist zwingend erforderlich.** Ohne ihn kann der RESI-DALI-SIO/ETH den Bus nicht ansteuern und der Konfigurationsassistent läuft bei jedem Schritt in einen Timeout. Wird auf einer langen Leitung ein zweites Netzteil verwendet, fügen Sie eine DALI-Drossel ein oder teilen Sie den Bus in galvanisch getrennte Segmente auf. ## Konfiguration ### Modbus-Kommunikation aktivieren Alle Host-Seriell-Parameter am RESI-DALI-SIO werden über einen 4-fach DIP-Schalter am Modul ausgewählt. Die TapHome-Vorlage legt **9600 Baud 8N1** fest, daher müssen die DIP-Schalter entsprechend gesetzt werden. | DIP1 | DIP2 | Baudrate | |------|------|----------| | **OFF** | **OFF** | **9600 bd (von TapHome erforderlich)** | | ON | OFF | 19200 bd | | OFF | ON | 38400 bd | | ON | ON | Verwendet im FLASH programmierte Baudrate (werkseitig 57600 bd) | | DIP4 | Modbus Unit ID Quelle | |------|----------------------| | **OFF** | FLASH-Register `H:65221` — erforderlich, damit die Aktion **Set Slave ID** wirkt | | ON | Erzwungen auf `255` (Hardware-Fallback, FLASH-Wert ignoriert) | `DIP3` ist ein produktspezifisches reserviertes Bit; belassen Sie es in der Werkseinstellung, sofern das RESI-Servicehandbuch es nicht ausdrücklich anders anweist. Die Parität ist in den FLASH-Standardeinstellungen fest auf `None` (8N1) — die Vorlage stellt die Paritäts-/Stoppbit-Register nicht bereit. **RS-485-Terminierung:** Terminieren Sie den Bus mit 120 Ω an beiden Enden. TapHome Core stellt eine Terminierung an seinen BUS-Klemmen bereit; ist das RESI-Gateway das letzte Gerät auf der Linie, fügen Sie an dessen RS-485-Klemmen einen diskreten 120 Ω Widerstand zwischen `A+`/`B-` hinzu. **RTU-over-TCP-Einrichtung:** Die Vorlage hat sowohl `SlaveId` als auch `IpAddress` Importparameter, weil der gleiche DALI-Konfigurationsfluss auch über eine **Serial-to-IP-Bridge** (Moxa NPort, USR-TCP232) oder über einen **RESI-DALI-ETH im transparenten RTU-over-Ethernet-Modus** funktioniert. Richten Sie in diesem Fall `IpAddress` auf die IP der Bridge / ETH-Einheit und lassen Sie die übrigen Einstellungen identisch mit der RS-485-Variante. Für reines Modbus/TCP am RESI-DALI-ETH wäre eine TCP-basierte Vorlage natürlicher — die DaliConfig-Vorlage geht speziell von Frame-RTU-Verkehr aus. ### Slave ID des Gateways einstellen Die werkseitige Unit ID ist **255**. So ändern Sie sie: 1. Setzen Sie am Gateway `DIP4 = OFF`, damit die FLASH Unit ID berücksichtigt wird. 2. Importieren Sie die Vorlage in TapHome mit `SlaveId = 255` (aktuelle Adresse). 3. Öffnen Sie die Service-Einstellungen des Moduls "Resi Dali - Konfiguration" und lösen Sie die Aktion **Set Slave ID** mit der gewünschten neuen ID aus (Bereich 1–255). Die Aktion schreibt den Wert in Register `H:65221` und löst sofort einen Software-Reset über `H:6000 = 1` aus, sodass das Gateway mit der neuen Adresse neu startet. 4. Entfernen Sie die Vorlage und importieren Sie sie erneut mit `SlaveId` auf den neuen Wert gesetzt. Das Modul kann dann für die Inbetriebnahme verwendet werden. Die Aktion **Reset Gateway** (schreibt `1` nach `H:6000`) ist ebenfalls als eigenständiger Wiederherstellungsschritt verfügbar — nützlich nach einem DALI-Buskurzschluss, der die DALI-Engine des Gateways in einem degradierten Zustand hinterlassen hat. > [!WARNING] > **Nur ein Modbus-Master gleichzeitig.** Weder DALI noch der Modbus-RTU-Bus arbitrieren zwischen gleichzeitigen Mastern. Wenn während der Inbetriebnahme eine SPS, ein BMS oder ein PC-Tool (z. B. MODBUSConfigurator) das Gateway ebenfalls pollt, kollidiert die Kurzadress-Programmierung und der Assistent meldet Fehler. ## Gerätefunktionen Die Vorlage ist um ein einziges Modbus-Modul herum aufgebaut — *Resi Dali - Konfiguration* — das den Konfigurationsassistenten, eine DALI-Gerätetyp-Sonde für jede Kurzadresse 0–63, Gateway-Informationsattribute und sieben Aktionen auf Gateway-Ebene bündelt. ### Konfigurationsassistent — Find New Devices *Find New Devices* ist ein neunstufiger Multi-Value-Schalter, der den DALI 2.0 Random-Addressing-Algorithmus als Zustandsautomat steuert. Jeder Zustandsname entspricht einer Phase der DALI 2.0 Konfigurationssequenz; in jedem Zustand sendet die Vorlage die richtigen rohen 16-Bit-DALI-Frames an `H:541` / `H:542`, fragt den DALI-RX-Status an `H:550` auf die Antwort des Gateways ab und schaltet den Schalter dann selbstständig in den nächsten Zustand. | Schritt | Zustand | Was er tut | |---------|---------|------------| | 0 | **TERMINATE** | DALI-Frame `TERMINATE` (`0xA100`) — beendet die aktuelle Adressierungssitzung und setzt den Gateway-Zustand zurück. Immer sicher aufzurufen | | 1 | **Start** | `INITIALISE` (`0xA5FF`) + `RANDOMISE` (`0xA700`) — schaltet alle nicht adressierten Geräte in den Adressierungspool und fordert von jedem eine zufällige 24-Bit-Adresse an. Der Assistent sendet beide Befehle vor jeder neuen Suchrunde erneut | | 2 | **Kurzadresse scannen** | Fragt die Kurzadressen 0–63 mit `QUERY CONTROL GEAR PRESENT` (`0x91`) ab, um die höchste bereits belegte Kurzadresse zu finden, sodass neue Geräte im Anschluss daran nummeriert werden. Wird nach **Kurzadressen zurücksetzen** übersprungen — die Nummerierung beginnt dann bei 0 | | 3 | **Set SEARCHADDR** | Führt die gesamte binäre Suche in einem Schritt aus: lädt die oberen/mittleren/unteren SEARCHADDR-Bytes (`0xB500/0xB300/0xB100`), sendet `COMPARE` (`0xA900`) und halbiert das 24-Bit-Suchfenster, bis es eingegrenzt ist, und fährt dann mit **Prüfen** fort | | 4 | **COMPARE** | Sendet `COMPARE` (`0xA900`) und engt das 24-Bit-Suchfenster basierend auf der Antwort ein | | 5 | **PROGRAM SHORT ADDRESS** | Schreibt die nächste Kurzadresse über `0xB7xx` und verifiziert sie (`0xB9xx`). Das Gerät blinkt dann auf seiner neuen Kurzadresse (`RECALL MIN`, `RECALL MAX`, `RECALL MIN`) und verlässt die Suche (`WITHDRAW`, `0xAB00`); der Assistent fährt mit der nächsten Runde ab **Start** fort | | 6 | **Prüfen** | Bestätigt die gefundene Zufallsadresse mit `COMPARE` am unteren und oberen Ende des eingegrenzten Fensters — eine einzelne Antwort führt zu **PROGRAM SHORT ADDRESS**, eine Kollision oder keine Antwort zu **Erneut versuchen** | | 7 | **Erneut versuchen** | Kollisions-/Timeout-Wiederherstellung — halbiert das aktuelle Suchintervall und versucht es erneut; ist das Intervall ausgeschöpft, beginnt eine neue Runde mit `INITIALISE` + `RANDOMISE` | | 8 | **Fertigstellen** | Wird nach drei Suchrunden ohne neu programmiertes Gerät erreicht oder wenn alle Kurzadressen 0–63 belegt sind. Liest das DALI-Ergebnisbyte, gibt eine TapHome-Info-/Fehlermeldung aus (`Search finished` bei Erfolg) und verlässt den Assistenten | **Typischer Inbetriebnahme-Ablauf:** 1. Speisen Sie den DALI-Bus (`RESI-DALI-PS`), verdrahten Sie Geräte in einer Baumtopologie und stellen Sie sicher, dass nichts anderes den Bus ansteuert. 2. (Optional, aber empfohlen) Führen Sie zunächst die Modulaktion **Kurzadressen zurücksetzen** mit *Confirm* = *Yes* aus, um von einem sauberen Zustand ohne adressierte Geräte zu starten. 3. Wählen Sie **Start** — sendet `INITIALISE` + `RANDOMISE`, sodass jedes Gerät eine neue 24-Bit-Zufallsadresse wählt. 4. Der Schalter durchläuft dann selbstständig **Kurzadresse scannen** → **Set SEARCHADDR** → **Prüfen** → **PROGRAM SHORT ADDRESS** und kehrt für das nächste Gerät zu **Start** zurück. Jedes neu programmierte Gerät blinkt einmal auf seiner neuen Kurzadresse, sodass erkennbar ist, welche Leuchte welche Adresse erhalten hat. 5. Kollisionen und Timeouts behandelt **Erneut versuchen** automatisch, ohne Eingriff des Installateurs. 6. Wenn der Schalter auf **Fertigstellen** stehen bleibt, lesen Sie die Info-/Fehlermeldung und wählen Sie dann **TERMINATE**, um die DALI-Adressierungssitzung zu schließen. 7. Verwenden Sie die Service-Attribute **Gear 0 … Gear 63** und die Aktionen **Turn On / Off All Lamps**, um zu überprüfen, dass die Kurzadressen 0–N nun belegt sind (siehe unten). Der Installateur muss das DALI-Busverhalten während des Durchlaufs dennoch beobachten (das Bestätigungsblinken, den `STATE`-LED-Rhythmus am Gateway), um fehlverdrahtete oder fehlende Geräte zu erkennen. ### DALI-Gerätesonde — Gear 0 … Gear 63 Jedes der 64 Service-Attribute **Gear 0**, **Gear 1**, … **Gear 63** sondiert eine DALI-Kurzadresse mit dem DALI 2.0 Befehl `QUERY DEVICE TYPE` (`0x99`). Intern schreibt die Vorlage `(SA << 8) | 0x99` nach `H:511`, pollt `H:550` Bits 0–2 bis eine Antwort eintrifft und liest dann das Antwortbyte aus `H:511` zurück. Mögliche Rückgabewerte in der TapHome-Service-UI: - **`DT{n}`** — ein Steuergerät ist an dieser Adresse programmiert und hat mit Gerätetyp *n* geantwortet. Typische Werte: `DT0` (Leuchtstoff), `DT1` (Notlicht), `DT2` (HID), `DT5` (0–10 V), `DT6` (LED-Treiber), `DT7` (Relais), `DT8` (Farbe / Tunable White), `DT9` (Sequenzer). - **`--`** — entweder ist an dieser Adresse kein Gerät programmiert oder das Gateway hat den `0x8000` "no answer / already consumed"-Sentinel zurückgegeben. Die Sonde liefert einen schnellen Pass/Fail-Überblick darüber, welche Kurzadressen nach der Inbetriebnahme belegt sind und welche Gerätetypen erkannt wurden — das ist der primäre Verifizierungsschritt vor dem Umschalten des Projekts auf die operative *Resi Dali* Vorlage. ### Gateway-Aktionen Sieben Service-Aktionen am Modul steuern das Gateway direkt an: - **Reset Gateway** — schreibt `1` nach `H:6000` (DIP SWITCH / SOFTWARE RESET). Startet das Gateway neu; nützlich nach einem Buskurzschluss zur Wiederherstellung der DALI-Engine. - **Set Slave ID** — schreibt die neue Unit ID (1–255) in FLASH-Register `H:65221`, setzt dann über `H:6000` zurück. Erfordert `DIP4 = OFF`, damit die Aktion wirkt. - **Turn On All Lamps** — schreibt `0xFE` (Arc Power 254 = 100 %) in das DALI-Broadcast-Level-Register `H:530`. Zündet jedes Gerät am Bus unabhängig von der Kurzadresse — eine schnelle visuelle Bestätigung, dass Bus und Netzteil gesund sind. - **Turn Off All Lamps** — schreibt `0x00` nach `H:530`, schaltet jedes Gerät aus. Gleicher Broadcast-Pfad, entgegengesetzter Wert. - **Kurzadressen zurücksetzen** — Parameter *Confirm* (*Yes* / *No*). Mit *Yes* sendet die Aktion `DTR0 = 0xFF` (`0xA3FF`) und einen Broadcast `SET SHORT ADDRESS`, sodass jedes Gerät am Bus seine Kurzadresse verliert; der nächste Durchlauf des Assistenten nummeriert die Geräte dann ab Kurzadresse 0. Mit *No* wird nichts gesendet. - **Delete short address** — Parameter *Short address* (0–63) und *Confirm* (*Yes* / *No*). Prüft mit `QUERY CONTROL GEAR PRESENT` (`0x91`), ob an der Adresse ein Gerät antwortet, sendet `DTR0 = 0xFF` und `SET SHORT ADDRESS` an diese Adresse, prüft dann erneut und meldet `Address N deleted`, `Address N still answers`, `No gear answers on address N` oder `Not confirmed`. - **Change short address** — Parameter *Old short address* und *New short address* (0–63). Prüft mit `QUERY CONTROL GEAR PRESENT`, ob die neue Adresse frei ist und an der alten genau ein Gerät antwortet, verschiebt das Gerät (`DTR0` = neue Adresse, `SET SHORT ADDRESS` an die alte Adresse) und bestätigt es an der neuen Adresse. Teilen sich mehrere Geräte die alte Adresse, bricht die Aktion ab und fordert dazu auf, die Adresse zu löschen und den Adressierungsassistenten auszuführen. Das Service-Attribut **Slave ID** am Modul liest die aktuelle Unit ID aus FLASH-Register `H:65221` zurück, sodass die aktuell programmierte Adresse vor dem Senden von *Set Slave ID* überprüft werden kann. Sechs weitere Service-Attribute des Moduls zeigen Gateway-Informationen: **Gateway firmware** (`H:65202`, als Version und roher Hex-Wert), **Gateway software group** (`H:65201`), **Gateway hardware group** (`H:65200`), **Gateway firmware author** (`H:65203`), **Gateway DIP switches** (`H:10009`, der Zustand von DIP 1–4 als `1:… 2:… 3:… 4:…`) und **Gateway converter status** (`H:5050`); die Gruppen-, Autor- und Statuswerte werden hexadezimal angezeigt. > [!TIP] > Führen Sie **Turn On All Lamps** direkt nach der Verdrahtung aus, *bevor* Sie den Adressierungsassistenten starten. Jedes eingeschaltete und korrekt angeschlossene Gerät am Bus geht auf 100 %, was eine sehr schnelle Möglichkeit ist, fehlende oder fehlverdrahtete Leuchten zu erkennen, bevor Zeit mit Kurzadress-Programmierung verbracht wird. ## Fehlerbehebung ### Assistent läuft bei jedem Schritt in Timeout 1. Überprüfen Sie die DALI-Busspannung an den Netzteilklemmen — sie muss 11,5–22,5 V betragen (typisch 14–16 V). Ein signifikant niedrigerer Wert deutet meist auf einen DALI-Kurzschluss hin. 2. Prüfen Sie die **ERR**-LED am RESI-DALI-PS — leuchtet sie, ist der Bus kurzgeschlossen, überlastet oder das Netzteil selbst defekt. 3. Prüfen Sie die **STATE**-LED am Gateway — ein langsamer 1-s-Rhythmus bedeutet gesunder DALI-Bus, ein schneller ~250 ms Rhythmus deutet auf Busfehler, Kurzschluss oder fehlende DALI-Versorgung hin. 4. Stellen Sie sicher, dass kein anderer Modbus-Master (MODBUSConfigurator, BMS, SPS) gleichzeitig mit dem Gateway spricht. ### Gear 0–63 melden nach der Inbetriebnahme alle `--` 1. Messen Sie die DALI-Spannung am Gerät am weitesten vom Netzteil entfernt — sie muss über 9,5 V liegen. Ist sie niedriger, ist der Bus zu lang für den Leiterquerschnitt (siehe DALI-Kabellängen-Tabelle oben). Teilen Sie den Bus mit einem zweiten Netzteil in zwei Segmente auf. 2. Starten Sie den Assistenten nach der Modulaktion **Kurzadressen zurücksetzen** (*Confirm* = *Yes*) erneut. Die Suche findet nur Geräte *ohne* Kurzadresse, daher werden Geräte, die noch eine zuvor programmierte Adresse haben, nicht neu adressiert, sofern Sie nicht vorher zurücksetzen. 3. Suchen Sie nach Schleifen in der Verdrahtung. DALI toleriert keine Ringe; durchtrennen Sie jede Schleife und terminieren Sie beide offenen Enden neu. ### Set Slave ID ändert die Adresse nicht 1. Bestätigen Sie `DIP4 = OFF` am Gateway. Bei `DIP4 = ON` erzwingt die Hardware unabhängig vom FLASH-Wert die Unit ID 255. 2. Bestätigen Sie, dass das Gateway nach der Aktion tatsächlich neu gestartet ist (Gateway-LEDs werden kurz dunkel). Ist das nicht der Fall, lösen Sie **Reset Gateway** manuell aus. 3. Importieren Sie die Vorlage mit dem neuen `SlaveId` Importparameter erneut — das zuvor importierte Modul pollt weiterhin an der alten Adresse. ### Kommunikation funktioniert kurz, dann scheitert sie 1. Prüfen Sie, dass `RS485 GND` zwischen Gateway und dem gemeinsamen Bezugspotenzial des TapHome-Netzteils verbunden ist. Fehlendes GND ist der häufigste RS-485-Fehler. 2. Überprüfen Sie die Terminierung — 120 Ω an beiden Enden des RS-485-Busses. Für RTU-over-TCP über eine Serial-Bridge stellen Sie sicher, dass die Bridge im Frame-RTU-Modus läuft, nicht im Raw-TCP, und dass der Zeichen-Zwischenraum auf der seriellen Seite dem Timing von 9600 Baud 8N1 entspricht. 3. Reduzieren Sie die Anzahl paralleler DALI-Abfragen — das Gateway serialisiert DALI-Transaktionen und arbitriert nicht zwischen mehreren Modbus-Mastern. ## Verfügbare Geräte 1 Diese Geräte erscheinen nach dem Import in TapHome. Resi Dali - Konfiguration Modul Serviceattribute | | | |----------|-------------------------------------------------------------------------------------------------------------------------------| | Slave-ID | Liest die im FLASH-Register H:65221 gespeicherte Modbus Unit ID — dient zur Überprüfung der aktuellen Gateway-Adresse | | Gear 0 | DALI-Gerätetyp-Sonde an Kurzadresse 0 — gibt DT{n} zurück, wenn ein Steuergerät antwortet, oder --, wenn die Adresse frei ist | | Gear 1 | DALI-Gerätetyp-Sonde an Kurzadresse 1 — gibt DT{n} oder -- zurück | | Gear 2 | DALI-Gerätetyp-Sonde an Kurzadresse 2 — gibt DT{n} oder -- zurück | | Gear 3 | DALI-Gerätetyp-Sonde an Kurzadresse 3 — gibt DT{n} oder -- zurück | | Gear 4 | DALI-Gerätetyp-Sonde an Kurzadresse 4 — gibt DT{n} oder -- zurück | | Gear 5 | DALI-Gerätetyp-Sonde an Kurzadresse 5 — gibt DT{n} oder -- zurück | | Gear 6 | DALI-Gerätetyp-Sonde an Kurzadresse 6 — gibt DT{n} oder -- zurück | | Gear 7 | DALI-Gerätetyp-Sonde an Kurzadresse 7 — gibt DT{n} oder -- zurück | | Gear 8 | DALI-Gerätetyp-Sonde an Kurzadresse 8 — gibt DT{n} oder -- zurück | | Gear 9 | DALI-Gerätetyp-Sonde an Kurzadresse 9 — gibt DT{n} oder -- zurück | | Gear 10 | DALI-Gerätetyp-Sonde an Kurzadresse 10 — gibt DT{n} oder -- zurück | | Gear 11 | DALI-Gerätetyp-Sonde an Kurzadresse 11 — gibt DT{n} oder -- zurück | | Gear 12 | DALI-Gerätetyp-Sonde an Kurzadresse 12 — gibt DT{n} oder -- zurück | | Gear 13 | DALI-Gerätetyp-Sonde an Kurzadresse 13 — gibt DT{n} oder -- zurück | | Gear 14 | DALI-Gerätetyp-Sonde an Kurzadresse 14 — gibt DT{n} oder -- zurück | | Gear 15 | DALI-Gerätetyp-Sonde an Kurzadresse 15 — gibt DT{n} oder -- zurück | | Gear 16 | DALI-Gerätetyp-Sonde an Kurzadresse 16 — gibt DT{n} oder -- zurück | | Gear 17 | DALI-Gerätetyp-Sonde an Kurzadresse 17 — gibt DT{n} oder -- zurück | | Gear 18 | DALI-Gerätetyp-Sonde an Kurzadresse 18 — gibt DT{n} oder -- zurück | | Gear 19 | DALI-Gerätetyp-Sonde an Kurzadresse 19 — gibt DT{n} oder -- zurück | | Gear 20 | DALI-Gerätetyp-Sonde an Kurzadresse 20 — gibt DT{n} oder -- zurück | | Gear 21 | DALI-Gerätetyp-Sonde an Kurzadresse 21 — gibt DT{n} oder -- zurück | | Gear 22 | DALI-Gerätetyp-Sonde an Kurzadresse 22 — gibt DT{n} oder -- zurück | | Gear 23 | DALI-Gerätetyp-Sonde an Kurzadresse 23 — gibt DT{n} oder -- zurück | | Gear 24 | DALI-Gerätetyp-Sonde an Kurzadresse 24 — gibt DT{n} oder -- zurück | | Gear 25 | DALI-Gerätetyp-Sonde an Kurzadresse 25 — gibt DT{n} oder -- zurück | | Gear 26 | DALI-Gerätetyp-Sonde an Kurzadresse 26 — gibt DT{n} oder -- zurück | | Gear 27 | DALI-Gerätetyp-Sonde an Kurzadresse 27 — gibt DT{n} oder -- zurück | | Gear 28 | DALI-Gerätetyp-Sonde an Kurzadresse 28 — gibt DT{n} oder -- zurück | | Gear 29 | DALI-Gerätetyp-Sonde an Kurzadresse 29 — gibt DT{n} oder -- zurück | | Gear 30 | DALI-Gerätetyp-Sonde an Kurzadresse 30 — gibt DT{n} oder -- zurück | | Gear 31 | DALI-Gerätetyp-Sonde an Kurzadresse 31 — gibt DT{n} oder -- zurück | | Gear 32 | DALI-Gerätetyp-Sonde an Kurzadresse 32 — gibt DT{n} oder -- zurück | | Gear 33 | DALI-Gerätetyp-Sonde an Kurzadresse 33 — gibt DT{n} oder -- zurück | | Gear 34 | DALI-Gerätetyp-Sonde an Kurzadresse 34 — gibt DT{n} oder -- zurück | | Gear 35 | DALI-Gerätetyp-Sonde an Kurzadresse 35 — gibt DT{n} oder -- zurück | | Gear 36 | DALI-Gerätetyp-Sonde an Kurzadresse 36 — gibt DT{n} oder -- zurück | | Gear 37 | DALI-Gerätetyp-Sonde an Kurzadresse 37 — gibt DT{n} oder -- zurück | | Gear 38 | DALI-Gerätetyp-Sonde an Kurzadresse 38 — gibt DT{n} oder -- zurück | | Gear 39 | DALI-Gerätetyp-Sonde an Kurzadresse 39 — gibt DT{n} oder -- zurück | | Gear 40 | DALI-Gerätetyp-Sonde an Kurzadresse 40 — gibt DT{n} oder -- zurück | | Gear 41 | DALI-Gerätetyp-Sonde an Kurzadresse 41 — gibt DT{n} oder -- zurück | | Gear 42 | DALI-Gerätetyp-Sonde an Kurzadresse 42 — gibt DT{n} oder -- zurück | | Gear 43 | DALI-Gerätetyp-Sonde an Kurzadresse 43 — gibt DT{n} oder -- zurück | | Gear 44 | DALI-Gerätetyp-Sonde an Kurzadresse 44 — gibt DT{n} oder -- zurück | | Gear 45 | DALI-Gerätetyp-Sonde an Kurzadresse 45 — gibt DT{n} oder -- zurück | | Gear 46 | DALI-Gerätetyp-Sonde an Kurzadresse 46 — gibt DT{n} oder -- zurück | | Gear 47 | DALI-Gerätetyp-Sonde an Kurzadresse 47 — gibt DT{n} oder -- zurück | | Gear 48 | DALI-Gerätetyp-Sonde an Kurzadresse 48 — gibt DT{n} oder -- zurück | | Gear 49 | DALI-Gerätetyp-Sonde an Kurzadresse 49 — gibt DT{n} oder -- zurück | | Gear 50 | DALI-Gerätetyp-Sonde an Kurzadresse 50 — gibt DT{n} oder -- zurück | | Gear 51 | DALI-Gerätetyp-Sonde an Kurzadresse 51 — gibt DT{n} oder -- zurück | | Gear 52 | DALI-Gerätetyp-Sonde an Kurzadresse 52 — gibt DT{n} oder -- zurück | | Gear 53 | DALI-Gerätetyp-Sonde an Kurzadresse 53 — gibt DT{n} oder -- zurück | | Gear 54 | DALI-Gerätetyp-Sonde an Kurzadresse 54 — gibt DT{n} oder -- zurück | | Gear 55 | DALI-Gerätetyp-Sonde an Kurzadresse 55 — gibt DT{n} oder -- zurück | | Gear 56 | DALI-Gerätetyp-Sonde an Kurzadresse 56 — gibt DT{n} oder -- zurück | | Gear 57 | DALI-Gerätetyp-Sonde an Kurzadresse 57 — gibt DT{n} oder -- zurück | | Gear 58 | DALI-Gerätetyp-Sonde an Kurzadresse 58 — gibt DT{n} oder -- zurück | | Gear 59 | DALI-Gerätetyp-Sonde an Kurzadresse 59 — gibt DT{n} oder -- zurück | | Gear 60 | DALI-Gerätetyp-Sonde an Kurzadresse 60 — gibt DT{n} oder -- zurück | | Gear 61 | DALI-Gerätetyp-Sonde an Kurzadresse 61 — gibt DT{n} oder -- zurück | | Gear 62 | DALI-Gerätetyp-Sonde an Kurzadresse 62 — gibt DT{n} oder -- zurück | | Gear 63 | DALI-Gerätetyp-Sonde an Kurzadresse 63 — gibt DT{n} oder -- zurück | | Gear 58 | | | Gear 59 | | | Gear 60 | | | Gear 61 | | | Gear 62 | | | Gear 63 | | Serviceaktionen | | | |---------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | Reset Gateway | Schreibt 1 in Register H:6000, um das RESI-DALI-Gateway neu zu starten — erforderlich nach Änderung der Slave ID oder zur Wiederherstellung der DALI-Engine nach einem Buskurzschluss | | Set Slave ID | Schreibt die neue Modbus Unit ID in FLASH-Register H:65221 und löst einen Reset aus, damit das Gateway mit der neuen Adresse neu startet (1–255, DIP4 muss OFF sein) | | Turn On All Lamps | Schreibt 0xFE in das DALI-Broadcast-Level-Register H:530 — schaltet jedes Steuergerät am Bus auf maximale Helligkeit (schneller Inbetriebnahme-Sanity-Test) | | Turn Off All Lamps | Schreibt 0x00 in das DALI-Broadcast-Level-Register H:530 — schaltet jedes Steuergerät am Bus aus | | ${xml\_reset\_short\_addresses} | | | Delete short address | | | Change short address | | Serviceattribute ${xml\_slave\_id} ```taphome modbusr(H,65221,uint16) ``` Gateway firmware ```taphome var x := modbusr(H, 65202, uint16); return(getbits(x, 12, 4) + "." + getbits(x, 8, 4) + "." + getbits(x, 0, 8) + " (" + "0x" + tostring(x, "X4") + ")"); ``` Gateway software group ```taphome var x := modbusr(H, 65201, uint16); return("0x" + tostring(x, "X4")); ``` Gateway hardware group ```taphome var x := modbusr(H, 65200, uint16); return("0x" + tostring(x, "X4")); ``` Gateway firmware author ```taphome var x := modbusr(H, 65203, uint16); return("0x" + tostring(x, "X4")); ``` Gateway DIP switches ```taphome var x := modbusr(H, 10009, uint16); return("1:" + getbit(x, 0) + " 2:" + getbit(x, 1) + " 3:" + getbit(x, 2) + " 4:" + getbit(x, 3)); ``` Gateway converter status ```taphome var x := modbusr(H, 5050, uint16); return("0x" + tostring(x, "X4")); ``` Gear 0 ```taphome var ShortAddress := 0; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 1 ```taphome var ShortAddress := 1; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 2 ```taphome var ShortAddress := 2; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 3 ```taphome var ShortAddress := 3; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 4 ```taphome var ShortAddress := 4; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 5 ```taphome var ShortAddress := 5; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 6 ```taphome var ShortAddress := 6; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 7 ```taphome var ShortAddress := 7; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 8 ```taphome var ShortAddress := 8; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 9 ```taphome var ShortAddress := 9; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 10 ```taphome var ShortAddress := 10; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 11 ```taphome var ShortAddress := 11; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 12 ```taphome var ShortAddress := 12; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 13 ```taphome var ShortAddress := 13; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 14 ```taphome var ShortAddress := 14; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 15 ```taphome var ShortAddress := 15; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 16 ```taphome var ShortAddress := 16; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 17 ```taphome var ShortAddress := 17; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 18 ```taphome var ShortAddress := 18; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 19 ```taphome var ShortAddress := 19; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 20 ```taphome var ShortAddress := 20; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 21 ```taphome var ShortAddress := 21; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 22 ```taphome var ShortAddress := 22; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 23 ```taphome var ShortAddress := 23; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 24 ```taphome var ShortAddress := 24; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 25 ```taphome var ShortAddress := 25; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 26 ```taphome var ShortAddress := 26; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 27 ```taphome var ShortAddress := 27; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 28 ```taphome var ShortAddress := 28; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 29 ```taphome var ShortAddress := 29; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 30 ```taphome var ShortAddress := 30; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 31 ```taphome var ShortAddress := 31; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 32 ```taphome var ShortAddress := 32; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 33 ```taphome var ShortAddress := 33; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 34 ```taphome var ShortAddress := 34; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 35 ```taphome var ShortAddress := 35; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 36 ```taphome var ShortAddress := 36; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 37 ```taphome var ShortAddress := 37; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 38 ```taphome var ShortAddress := 38; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 39 ```taphome var ShortAddress := 39; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 40 ```taphome var ShortAddress := 40; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 41 ```taphome var ShortAddress := 41; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 42 ```taphome var ShortAddress := 42; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 43 ```taphome var ShortAddress := 43; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 44 ```taphome var ShortAddress := 44; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 45 ```taphome var ShortAddress := 45; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 46 ```taphome var ShortAddress := 46; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 47 ```taphome var ShortAddress := 47; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 48 ```taphome var ShortAddress := 48; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 49 ```taphome var ShortAddress := 49; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 50 ```taphome var ShortAddress := 50; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 51 ```taphome var ShortAddress := 51; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 52 ```taphome var ShortAddress := 52; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 53 ```taphome var ShortAddress := 53; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 54 ```taphome var ShortAddress := 54; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 55 ```taphome var ShortAddress := 55; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 56 ```taphome var ShortAddress := 56; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 57 ```taphome var ShortAddress := 57; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 58 ```taphome var ShortAddress := 58; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 59 ```taphome var ShortAddress := 59; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 60 ```taphome var ShortAddress := 60; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 61 ```taphome var ShortAddress := 61; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 62 ```taphome var ShortAddress := 62; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Gear 63 ```taphome var ShortAddress := 63; modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99); sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); var x := modbusr(SH, 511, uint16); if (x != 0x8000, return("DT" + x), return("--")); ``` Serviceaktionen ${xml\_reset\_gateway} ```taphome modbusw(SH,6000,uint16,1) ``` ${xml\_set\_slave\_id} Parameter: ${xml\_slave\_id} (1–255 SID) ```taphome modbusw(SH, 65221, uint16, SID); modbusw(SH,6000, uint16, 1); ``` ${xml\_turn\_on\_all\_lamps} ```taphome modbusw(SH, 530, uint16, 0xFE) ``` ${xml\_turn\_off\_all\_lamps} ```taphome modbusw(SH, 530, uint16, 0x00) ``` ${xml\_reset\_short\_addresses} Parameter: Confirm (Yes / No) ```taphome if CONF # DTR0 = 0xFF, then SET SHORT ADDRESS to all gear (sent twice): every gear loses its short address modbusw(SH, 541, uint16, 0xA3FF); sleep(100); modbusw(SH, 532, uint16, 0x80); SHORTADDR := -1; iterator := 64; end ``` Delete short address Parameter: Short address (0–63 ADDR), Confirm (Yes / No) ```taphome if CONF # QUERY CONTROL GEAR PRESENT first: nothing to delete when no gear answers var x := 0; modbusr(SH, 511, uint16); modbusw(SH, 511, uint16, (ADDR << 8) + 0x91); sleep(60); x := modbusr(SH, 511, uint16); if x = 0x8000 return("No gear answers on address " + ADDR); end # DTR0 = 0xFF (MASK), then SET SHORT ADDRESS to that address (sent twice by the gateway): every gear on it loses the address modbusw(SH, 541, uint16, 0xA3FF); sleep(100); modbusw(SH, 512, uint16, (ADDR << 8) + 0x80); sleep(300); modbusr(SH, 511, uint16); modbusw(SH, 511, uint16, (ADDR << 8) + 0x91); sleep(60); x := modbusr(SH, 511, uint16); if x = 0x8000 return("Address " + ADDR + " deleted"); end return("Address " + ADDR + " still answers (0x" + tostring(x, "X4") + ")"); end return("Not confirmed"); ``` Change short address Parameter: Old short address (0–63 FROM), New short address (0–63 TO) ```taphome if FROM = TO return("Old and new address are the same"); end var x := 0; # the new address must be free modbusr(SH, 511, uint16); modbusw(SH, 511, uint16, (TO << 8) + 0x91); sleep(60); x := modbusr(SH, 511, uint16); if x != 0x8000 return("Address " + TO + " is already in use"); end # a gear must answer on the old address; a collision means more gears share it modbusr(SH, 511, uint16); modbusw(SH, 511, uint16, (FROM << 8) + 0x91); sleep(60); x := modbusr(SH, 511, uint16); if x = 0x8000 return("No gear answers on address " + FROM); end if x = 0x20FF return("More gears answer on address " + FROM + ", delete the address and run the addressing wizard"); end # DTR0 = new address in the DALI format (2*TO + 1), then SET SHORT ADDRESS to the old address (sent twice by the gateway) modbusw(SH, 541, uint16, 0xA300 + (TO << 1) + 1); sleep(100); modbusw(SH, 512, uint16, (FROM << 8) + 0x80); sleep(300); modbusr(SH, 511, uint16); modbusw(SH, 511, uint16, (TO << 8) + 0x91); sleep(60); x := modbusr(SH, 511, uint16); if x = 0x8000 return("Change failed, no gear answers on address " + TO); end return("Gear moved from address " + FROM + " to " + TO); ``` Neue Geräte finden Mehrwertschalter Lesen und Schreiben Inbetriebnahme-Assistent, der den DALI 2.0 Random-Addressing-Algorithmus durchläuft, um Steuergeräten Kurzadressen 0–63 zuzuweisen Register: H:541 → H:542 UInt16 numeric Werte / Zustände: TERMINATE · ${xml\_start} · ${xml\_scan\_short\_address} · Set SEARCHADDR · COMPARE · PROGRAM SHORT ADDRESS · Check · Try again · ${xml\_finish} Schaltzustand lesen ```taphome var x := 0x8000; var rx := 0; if Mu = 1 if exit <= 0 status := 255; return(8); end # check SEARCHADDRH modbusw(SH, 541, uint16, 0xB500 + getbyte(SEARCHADDRH,0)); sleep(500); modbusw(SH, 541, uint16, 0xB300 + getbyte(SEARCHADDRH,1)); sleep(500); modbusw(SH, 541, uint16, 0xB100 + getbyte(SEARCHADDRH,2)); sleep(500); modbusw(SH, 541, uint16, 0xA900); sleep(5); rx := getbits(modbusr(SH, 550, uint16), 0, 2); if !rx sleep(50); rx := getbits(modbusr(SH, 550, uint16), 0, 2); end if rx x := modbusr(SH, 541, uint16); if getbyte(x, 0) = 0xFF #match: lets check return(2); else return(7); end else return(7); end end if Mu = 2 # find max short address if SHORTADDR >= 63 status := 254; return(8); end if iterator >= 64 status := 10; return(3); end modbusw(SH, 511, uint16, (iterator << 8) + 0x91); sleep(5); rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); x := modbusr(SH, 511, uint16); if (x = 0xFF, SHORTADDR := iterator); iterator := iterator + 1; end if Mu = 3 # bisection of SEARCHADDR in one run: SET SEARCHADDR to the middle, COMPARE, keep the half with an answer SEARCHADDRM := SEARCHADDRH - ((SEARCHADDRH - SEARCHADDRL) >> 1); while SEARCHADDRM != SEARCHADDRH and SEARCHADDRM != SEARCHADDRL modbusw(SH, 541, uint16, 0xB500 + getbyte(SEARCHADDRM,0)); sleep(50); modbusw(SH, 541, uint16, 0xB300 + getbyte(SEARCHADDRM,1)); sleep(50); modbusw(SH, 541, uint16, 0xB100 + getbyte(SEARCHADDRM,2)); sleep(50); modbusw(SH, 541, uint16, 0xA900); sleep(5); rx := getbits(modbusr(SH, 550, uint16), 0, 2); if !rx sleep(50); rx := getbits(modbusr(SH, 550, uint16), 0, 2); end if rx x := modbusr(SH, 541, uint16); # collision or match: the gear is in the lower segment SEARCHADDRH := SEARCHADDRM; else # no response: look in the higher segment SEARCHADDRL := SEARCHADDRM; end SEARCHADDRM := SEARCHADDRH - ((SEARCHADDRH - SEARCHADDRL) >> 1); loop return(6); end if Mu = 4 # COMPARE modbusw(SH, 541, uint16, 0xA900); sleep(5); rx := getbits(modbusr(SH, 550, uint16), 0, 2); if !rx sleep(50); rx := getbits(modbusr(SH, 550, uint16), 0, 2); end if rx x := modbusr(SH, 541, uint16); #collision or match: lets search the lower segment SEARCHADDRH := SEARCHADDRM; else #no response: lets look up in the higher segment SEARCHADDRL := SEARCHADDRM; end return(3); end if Mu = 6 # check SEARCHADDRL modbusw(SH, 541, uint16, 0xB500 + getbyte(SEARCHADDRL,0)); sleep(50); modbusw(SH, 541, uint16, 0xB300 + getbyte(SEARCHADDRL,1)); sleep(50); modbusw(SH, 541, uint16, 0xB100 + getbyte(SEARCHADDRL,2)); sleep(50); modbusw(SH, 541, uint16, 0xA900); sleep(5); rx := getbits(modbusr(SH, 550, uint16), 0, 2); if !rx sleep(50); rx := getbits(modbusr(SH, 550, uint16), 0, 2); end if rx x := modbusr(SH, 541, uint16); if getbyte(x, 0) = 0xFF #exact match: we have it, lets finish return(5); else #collision: 2 gear with same SEARCHADDR or something went wrong, start over return(7); end end # check SEARCHADDRH modbusw(SH, 541, uint16, 0xB500 + getbyte(SEARCHADDRH,0)); sleep(50); modbusw(SH, 541, uint16, 0xB300 + getbyte(SEARCHADDRH,1)); sleep(50); modbusw(SH, 541, uint16, 0xB100 + getbyte(SEARCHADDRH,2)); sleep(50); modbusw(SH, 541, uint16, 0xA900); sleep(5); rx := getbits(modbusr(SH, 550, uint16), 0, 2); if !rx sleep(50); rx := getbits(modbusr(SH, 550, uint16), 0, 2); end if rx x := modbusr(SH, 541, uint16); if getbyte(x, 0) = 0xFF #exact match: we have it, lets finish return(5); else #collision: 2 gear with same SEARCHADDR or something went wrong, start over return(7); end else #no response: something went wrong, finish with error status := 220; #return(8); return(7); end end if Mu = 5 exit := 3; # PROGRAM SHORT ADDRESS SHORTADDR := SHORTADDR + 1; #program modbusw(SH, 542, uint16, 0xB701 + (SHORTADDR << 1)); sleep(100); #verify modbusw(SH, 541, uint16, 0xB901 + (SHORTADDR << 1)); sleep(5); rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); x := modbusr(SH, 541, uint16); if getbyte(x, 0) = 0xFF status := 0; else status := 230; #return(8); SHORTADDR := SHORTADDR - 1; return(7); end #blink # blink the new address: RECALL MIN, RECALL MAX, RECALL MIN (short address in the upper byte) modbusw(SH, 511, uint16, (SHORTADDR << 8) + 0x06); sleep(500); modbusw(SH, 511, uint16, (SHORTADDR << 8) + 0x05); sleep(500); modbusw(SH, 511, uint16, (SHORTADDR << 8) + 0x06); #WITHDRAW modbusw(SH, 541, uint16, 0xAB00); sleep(100); SEARCHADDRH := 0xFFFFFF; SEARCHADDRL := 0; # a new search round needs a fresh 15-minute DALI window: INITIALISE (gear without short address) and RANDOMISE again modbusw(SH, 542, uint16, 0xA5FF); sleep(100); modbusw(SH, 542, uint16, 0xA700); sleep(100); return(1); end if Mu = 8 # finish (state 8 since the short address reset moved to a module service action) # finish if(status = 99, adderror("Timeout!")); if(status = 220, adderror("Check failed! (" + tostring(SEARCHADDRH, "X2") + " | " + tostring(SEARCHADDRL, "X2") + " )")); if(status = 230, adderror("Verify short address failed! (" + tostring(SHORTADDR, "X2") + " | " + tostring(x, "X2") + " | " + tostring(SEARCHADDRH, "X2") + " | " + tostring(SEARCHADDRM, "X2") + " | " + tostring(SEARCHADDRL, "X2") + " )")); if(status = 231, adderror("Short address mismatch! (" + tostring(SHORTADDR, "X2") + " | " + tostring(x, "X2") + " )")); if(status = 254, adderror("All short addresses are in use!")); if status = 255 modbusw(SH, 531, uint16, 0x96); sleep(5); rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50)); x := modbusr(SH, 531, uint16); if getbyte(x, 0) = 0xFF adderror("Some gear is still missing short address, but no response from SEARCHADDRH! ( " + tostring(SEARCHADDRH, "X2") + " )"); else status := 1; end end if(status = 1, addinfo("Search finished")); if(status = 200 or status = 230 or status = 231 or status = 254, iterator := 0); end #debug #if(Mu = 7, addinfo("Debug:" + tostring(x, "X2") + " | " + status),0); #if(Mu = 1, status := "rx:" + getbits(y, 0, 2) + "|" + getbits(y, 4, 1) + "|" + getbits(y, 5, 1), 0); #if(Mu = 1, return(7),0); if Mu = 7 if SEARCHADDRH = SEARCHADDRL SEARCHADDRH := 0xFFFFFF; SEARCHADDRL := 0; exit := exit -1; # a new search round needs a fresh 15-minute DALI window: INITIALISE (gear without short address) and RANDOMISE again modbusw(SH, 542, uint16, 0xA5FF); sleep(100); modbusw(SH, 542, uint16, 0xA700); sleep(100); return(1); end SEARCHADDRH := SEARCHADDRH >> 1; SEARCHADDRL := 0; if(iterator < 64, SHORTADDR := -1); if(iterator < 64, iterator := 0); # check SEARCHADDRH modbusw(SH, 541, uint16, 0xB500 + getbyte(SEARCHADDRH,0)); sleep(500); modbusw(SH, 541, uint16, 0xB300 + getbyte(SEARCHADDRH,1)); sleep(500); modbusw(SH, 541, uint16, 0xB100 + getbyte(SEARCHADDRH,2)); sleep(500); modbusw(SH, 541, uint16, 0xA900); sleep(5); rx := getbits(modbusr(SH, 550, uint16), 0, 2); if !rx sleep(50); rx := getbits(modbusr(SH, 550, uint16), 0, 2); end if rx x := modbusr(SH, 541, uint16); if getbyte(x, 0) = 0xFF #match: lets check return(2); else return(6); end else return(6); end end return(Mu); ``` Schaltzustand schreiben ```taphome # TERMINATE if(Mu = 0, modbusw(SH, 542, uint16, 0xA100), 0); # INITIALIZE:CONTROL GEARS WITHOUT SHORT ADDRESS if(Mu = 1, modbusw(SH, 542, uint16, 0xA5FF), 0); if(Mu = 1, sleep(100)); # RANDOMIZE if(Mu = 1, modbusw(SH, 542, uint16, 0xA700), 0); if(Mu = 1, sleep(100)); # Init SEARCHADDR variables if(Mu = 1, SEARCHADDRH := 0xFFFFFF, 0); #if(Mu = 1, SEARCHADDRM := SEARCHADDRH / 2, 0); if(Mu = 1, SEARCHADDRL := 0, 0); if(Mu = 1, if(iterator < 64, SHORTADDR := -1, 0), 0); if(Mu = 1, if(iterator < 64, iterator := 0, 0), 0); if(Mu = 1, exit := 3, 0); # Reset All to Defaults #if(Mu = 7, modbusw(SH, 532, uint16, 0x20), 0); #if(Mu = 7, sleep(100)); #collision: halve interval sleep(100); ``` **Verbindung:** Modbus RTU • 9600 baud• 8N1 • Slave ID: $\[SlaveId] Mögliche Verbesserungen (9) - H:510 Lamp Level (per short address) — Daily operational dimming (upper 8b = short addr, lower 8b = arc power 0–254). Covered by the sibling operational template (Resi Dali, Dali.xml) — this commissioning template is intentionally addressing-only - H:520 Group Level — Group 0–15 arc power for daily group control — handled by the operational Resi Dali template - H:521 Group Command — Group commands (ON/OFF/scenes/recall) — not needed for addressing - H:531 Broadcast Command — The Finish state uses H:531=0x96 internally to poll QUERY MISSING SHORT ADDRESS, but the register is not exposed as a user action - H:551 DALI Bus Error (word) — 1 = DALI bus fault / short — useful diagnostic during commissioning, could be added as a module-level service attribute - H:100 DALI Priority Slot — 0–4 → 12–16 ms forward-frame slots, default 2. Bus-tuning parameter; safe to leave at default - H:65222 Baud Rate (FLASH) — Only honored when DIP1=DIP2=ON. Template pins 9600 baud via connection\_details, so this register is out of scope - H:65224 Parity (FLASH) — 0=None, 1=Even, 2=Odd. Template hard-codes None (8N1) - H:65225 Stop Bits (FLASH) — 1 or 2. Template hard-codes 1 ## Importparameter Diese Werte geben Sie beim Import des XML ein. | In der App abgefragt | Standard | |----------------------|---------------| | Slave-ID | `255` | | IP-Adresse | `192.168.1.0` | ## Quellen - RESI-DALI-SIO/ETH Modbus & ASCII protocol reference [www.resi.cc](https://www.resi.cc/resi/docs/RESI-L-DALI-SIO,ETH-MODBUS+ASCII-EN.pdf) 2026-04-15 [PDF](https://taphome.com/compatibility/devices/resi-dali-daliconfig/manufacturer/RESI-L-DALI-SIO,ETH-MODBUS+ASCII-EN.pdf) - RESI-xxx-SIO, RESI-xxx-ETH hardware & software manual (DALI chapter) [www.resi.cc](https://www.resi.cc/resi/docs/RESI-M-xxx-SIO-ETH-EN.pdf) 2026-04-15 [PDF](https://taphome.com/compatibility/devices/resi-dali-daliconfig/manufacturer/RESI-M-xxx-SIO-ETH-EN.pdf) - RESI-DALI-SIO datasheet (GW-28) [www.resi.cc](https://www.resi.cc/resi/catalog/files/RESI-CATALOG-GATEWAYS-EN-Pages/RESI-CATALOG-GATEWAYS-EN-GW-28-RESI-DALI-SIO.pdf) 2026-04-15 [PDF](https://taphome.com/compatibility/devices/resi-dali-daliconfig/manufacturer/RESI-CATALOG-GATEWAYS-EN-GW-28-RESI-DALI-SIO.pdf) - RESI-DALI-ETH datasheet (GW-29) [www.resi.cc](https://www.resi.cc/resi/catalog/files/RESI-CATALOG-GATEWAYS-EN-Pages/RESI-CATALOG-GATEWAYS-EN-GW-29-RESI-DALI-ETH.pdf) 2026-04-15 [PDF](https://taphome.com/compatibility/devices/resi-dali-daliconfig/manufacturer/RESI-CATALOG-GATEWAYS-EN-GW-29-RESI-DALI-ETH.pdf) - RESI-DALI-PS datasheet (GW-30) [www.resi.cc](https://www.resi.cc/resi/catalog/files/RESI-CATALOG-GATEWAYS-EN-Pages/RESI-CATALOG-GATEWAYS-EN-GW-30-RESI-DALI-PS.pdf) 2026-04-15 [PDF](https://taphome.com/compatibility/devices/resi-dali-daliconfig/manufacturer/RESI-CATALOG-GATEWAYS-EN-GW-30-RESI-DALI-PS.pdf) - RESI-DALI-SIO,ETH,PS product page [www.resi.cc](https://www.resi.cc/prestashop/en/home/1-resi-dali-sioethps.html) 2026-04-15 Herstellerdokumente sind © ihrer jeweiligen Eigentümer. Sie werden so bereitgestellt, wie der Hersteller sie veröffentlicht hat, nur zur Information. ## Verwandte Dokumentation - [Modbus Integration](https://taphome.com/de/compatibility/modbus-guide/) - [Modbus](https://taphome.com/de/docs/integration/modbus/) - [Einfache Konfiguration mit Vorlagen](https://taphome.com/de/docs/integration/modbus/templates/) - [Modbus-Skripte und Prefetch](https://taphome.com/de/docs/script/modbus-scripts/) - [Modbus-Funktionen](https://taphome.com/de/docs/script/modbus/) - [Modbus-Datentypen](https://taphome.com/de/docs/script/modbus-data-types/)