RESI-DALI-SIO — DALI Inbetriebnahme

Resi Dali - Konfiguration

Modbus RTU

Eingereicht von

Zuletzt aktualisiert: 04. 2026

Erfordert externes Gateway
Resi RESI-DALI-PS — Produktseite

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.

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, Gruppen, Szenen und DT6/DT8 RGB-/Tunable-White-Farbsteuerung. 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)

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)

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 über Modbus TCP oder 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)

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).

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:

Setzen Sie am Gateway DIP4 = OFF, damit die FLASH Unit ID berücksichtigt wird.
Importieren Sie die Vorlage in TapHome mit SlaveId = 255 (aktuelle Adresse).
Ö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.
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.

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 und vier Aktionen auf Gateway-Ebene bündelt.

Konfigurationsassistent — Find New Devices

Find New Devices ist ein zehnstufiger Multi-Value-Schalter, der den DALI 2.0 Random-Addressing-Algorithmus in diskreten Schritten steuert. Jeder Zustandsname entspricht einer Phase der DALI 2.0 Konfigurationssequenz; die Auswahl eines Zustands veranlasst die Vorlage, den richtigen rohen 16-Bit-DALI-Frame an H:541 / H:542 zu senden und dann den DALI-RX-Status an H:550 auf die Antwort des Gateways abzufragen.

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
2	Kurzadresse scannen	Sondiert den nächsten Kurzadress-Slot; gibt Statuscode 7 zurück, wenn kein Gerät antwortet
3	Set SEARCHADDR	Lädt die oberen/mittleren/unteren SEARCHADDR-Bytes (`0xB500/0xB300/0xB100`) für die binäre Suche
4	COMPARE	Sendet `COMPARE` (`0xA900`) und engt das 24-Bit-Suchfenster basierend auf der Antwort ein
5	PROGRAM SHORT ADDRESS	Schreibt die verifizierte Kurzadresse über `0xB7xx` — das Gerät ist nun dauerhaft adressiert
6	Prüfen	Verifiziert die programmierte Adresse mit einem zweiten `COMPARE` am finalen `SEARCHADDRL`
7	Erneut versuchen	Kollisions-/Timeout-Wiederherstellung — halbiert das aktuelle Suchintervall und versucht es erneut
8	Kurzadressen zurücksetzen	DALI `DTR = 0xFF` (`0xA3FF`) + Broadcast `REMOVE SHORT ADDRESS` — löscht alle bestehenden Kurzadressen, bereit für eine vollständige Neuadressierung
9	Fertigstellen	Liest das DALI-Ergebnisbyte, gibt eine TapHome-Info-/Fehlermeldung aus und verlässt den Assistenten

Typischer Inbetriebnahme-Ablauf:

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.
(Optional, aber empfohlen) Führen Sie zunächst Kurzadressen zurücksetzen aus, um von einem sauberen Zustand ohne adressierte Geräte zu starten.
Führen Sie Start aus — sendet INITIALISE + RANDOMISE, sodass jedes Gerät eine neue 24-Bit-Zufallsadresse wählt.
Führen Sie Kurzadresse scannen → Set SEARCHADDR → COMPARE → PROGRAM SHORT ADDRESS → Prüfen in dieser Reihenfolge aus. Die Zustände kapseln die binäre Suche von DALI 2.0; jeder Schritt bringt den Algorithmus um eine Phase weiter.
Meldet ein Schritt eine Kollision oder einen Timeout, rufen Sie Erneut versuchen auf und wiederholen Sie die Compare/Program-Sequenz.
Wenn alle sichtbaren Geräte programmiert sind, führen Sie TERMINATE und dann Fertigstellen aus, um den Assistenten sauber zu beenden.
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 Assistent ist so konzipiert, dass er Zustand für Zustand durchlaufen wird — die Vorlage automatisiert die gesamte Schleife nicht, weil der Installateur das DALI-Busverhalten beobachten muss (pulsierende Leuchten, 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

Vier 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.

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.

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

Ü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.
Prüfen Sie die ERR-LED am RESI-DALI-PS — leuchtet sie, ist der Bus kurzgeschlossen, überlastet oder das Netzteil selbst defekt.
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.
Stellen Sie sicher, dass kein anderer Modbus-Master (MODBUSConfigurator, BMS, SPS) gleichzeitig mit dem Gateway spricht.

Gear 0–63 melden nach der Inbetriebnahme alle `--`

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.
Starten Sie den Assistenten erneut ab Kurzadressen zurücksetzen. Führen Sie Start nicht auf einem Bus aus, der noch zuvor programmierte Geräte enthält, ohne vorher zurückzusetzen — der Algorithmus findet nur Geräte ohne Kurzadresse.
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

Bestätigen Sie DIP4 = OFF am Gateway. Bei DIP4 = ON erzwingt die Hardware unabhängig vom FLASH-Wert die Unit ID 255.
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.
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

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.
Ü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.
Reduzieren Sie die Anzahl paralleler DALI-Abfragen — das Gateway serialisiert DALI-Transaktionen und arbitriert nicht zwischen mehreren Modbus-Mastern.

Verfügbare Geräte

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

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

${resi_dali_configuration}

Serviceattribute

${xml_slave_id}

modbusr(H,65221,uint16)

Gear 0

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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}

modbusw(SH,6000,uint16,1)

${xml_set_slave_id}

Parameter: ${xml_slave_id} (1–255 SID)

modbusw(SH, 65221, uint16, SID);

modbusw(SH,6000, uint16, 1);

${xml_turn_on_all_lamps}

modbusw(SH, 530, uint16, 0xFE)

${xml_turn_off_all_lamps}

modbusw(SH, 530, uint16, 0x00)

Neue Geräte finden Mehrwertschalter

Inbetriebnahme-Assistent, der den DALI 2.0 Random-Addressing-Algorithmus durchläuft, um Steuergeräten Kurzadressen 0–63 zuzuweisen

Werte / Zustände: TERMINATE · ${xml_start} · ${xml_scan_short_address} · Set SEARCHADDR · COMPARE · PROGRAM SHORT ADDRESS · Check · Try again · ${xml_reset_short_addresses} · ${xml_finish}

Neue Geräte finden

Schaltzustand lesen

var x := 0x8000; var rx := 0;

if Mu = 1
	if exit <= 0
		status := 255;
        return(9);
    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(9);
    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
    # set SEARCHADDR
    SEARCHADDRM := SEARCHADDRH - ((SEARCHADDRH - SEARCHADDRL) >> 1);
    if(SEARCHADDRM = SEARCHADDRH or SEARCHADDRM = SEARCHADDRL, return(6));
    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);
    return(4);
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(9);
        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(9);
        SHORTADDR := SHORTADDR - 1;
        return(7);
    end
    #blink
    modbusw(SH, 511, uint16, SHORTADDR + 0x06);
    sleep(500);
    modbusw(SH, 511, uint16, SHORTADDR + 0x05);
    sleep(500);
    modbusw(SH, 511, uint16, SHORTADDR + 0x06);
    #WITHDRAW
    modbusw(SH, 541, uint16, 0xAB00);
    sleep(100);
    SEARCHADDRH := 0xFFFFFF;
    SEARCHADDRL := 0;
    return(1);
end
if Mu = 9
    # 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;
        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

# 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 Short Addresses 
if(Mu = 8, modbusw(h, 541, uint16, 0xA3FF), 0);
if(Mu = 8, sleep(100));
if(Mu = 8, modbusw(h, 532, uint16, 0x80), 0);
if(Mu = 8, SHORTADDR := -1, 0);
if(Mu = 8, iterator := 64, 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

Vorlage herunterladen

Quellen

RESI-DALI-SIO/ETH Modbus & ASCII protocol reference
www.resi.cc 2026-04-15
PDF
RESI-xxx-SIO, RESI-xxx-ETH hardware & software manual (DALI chapter)
www.resi.cc 2026-04-15
PDF
RESI-DALI-SIO datasheet (GW-28)
www.resi.cc 2026-04-15
PDF
RESI-DALI-ETH datasheet (GW-29)
www.resi.cc 2026-04-15
PDF
RESI-DALI-PS datasheet (GW-30)
www.resi.cc 2026-04-15
PDF
RESI-DALI-SIO,ETH,PS product page
www.resi.cc 2026-04-15