Deutsch

Offiziell · TapHome Beleuchtung

Resi Dali - Konfiguration

DALI 2.0 Inbetriebnahme-Tool für das Modbus-DALI-Gateway RESI-DALI-SIO und RESI-DALI-ETH. Weist Steuergeräten direkt aus TapHome Kurzadressen 0–63 zu, prüft deren Anwesenheit und führt schnelle Broadcast-ON/OFF-Tests durch.

ResiModbus RTU1 GerätRevision 1.3 Zuletzt aktualisiert: 15. November 2026

Import in die TapHome AppHardware › Modbus › Aus Vorlage hinzufügen

Vorlage herunterladen

Auf dieser Seite

Erfordert externes Gateway
Resi RESI-DALI-PS — Produktseite

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.

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)

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 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, 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:

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 die Modulaktion Kurzadressen zurücksetzen mit Confirm = Yes aus, um von einem sauberen Zustand ohne adressierte Geräte zu starten.
Wählen Sie Start — sendet INITIALISE + RANDOMISE, sodass jedes Gerät eine neue 24-Bit-Zufallsadresse wählt.
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.
Kollisionen und Timeouts behandelt Erneut versuchen automatisch, ohne Eingriff des Installateurs.
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.
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.

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

${resi_dali_configuration}

Serviceattribute

${xml_slave_id}

modbusr(H,65221,uint16)

Gateway firmware

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

var x := modbusr(H, 65201, uint16);
return("0x" + tostring(x, "X4"));

Gateway hardware group

var x := modbusr(H, 65200, uint16);
return("0x" + tostring(x, "X4"));

Gateway firmware author

var x := modbusr(H, 65203, uint16);
return("0x" + tostring(x, "X4"));

Gateway DIP switches

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

var x := modbusr(H, 5050, uint16);
return("0x" + tostring(x, "X4"));

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)

${xml_reset_short_addresses}

Parameter: Confirm (Yes / No)

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)

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)

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

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

Neue Geräte finden

Schaltzustand lesen

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

# 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 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

Herstellerdokumente sind © ihrer jeweiligen Eigentümer. Sie werden so bereitgestellt, wie der Hersteller sie veröffentlicht hat, nur zur Information.

Haben Sie ein Problem mit dieser Gerätevorlage gefunden?

Sagen Sie uns, was nicht funktioniert, was fehlt oder wie sich die Vorlage verhalten sollte. Ihr Feedback hilft uns, den Katalog genau zu halten.

Vorlage · TapHome-Portal Resi Dali - Konfiguration Öffne diese Vorlage im Kundenportal, um sie auf eine deiner Wohnungen anzuwenden, oder entwirf eine Anpassung und reiche sie an den Katalog ein. Modbus RTU Im TapHome-Portal ansehen

Resi Dali - Konfiguration

Integrationsanleitung

Hardware-Anschluss

Anschluss des RESI-DALI-SIO (RS-485)

Anschluss des RESI-DALI-ETH (Ethernet)

DALI-Bus-Netzteil

DALI-Bus-Regeln

Konfiguration

Modbus-Kommunikation aktivieren

Slave ID des Gateways einstellen

Gerätefunktionen

Konfigurationsassistent — Find New Devices

DALI-Gerätesonde — Gear 0 … Gear 63

Gateway-Aktionen

Fehlerbehebung

Assistent läuft bei jedem Schritt in Timeout

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

Set Slave ID ändert die Adresse nicht

Kommunikation funktioniert kurz, dann scheitert sie

Verfügbare Geräte 1

Importparameter

Quellen

Haben Sie ein Problem mit dieser Gerätevorlage gefunden?

Hinterlassen Sie uns Ihre Kontaktdaten — wir senden Ihnen die Antwort

Weiter zu WhatsApp

Die Nachricht ist angekommen

Der Code ist abgelaufen

Die Anfrage ist beim Support

Wir suchen Tester für die neue Version

Danke, wir melden uns in Kürze

Integrationsanleitung

Hardware-Anschluss#

Anschluss des RESI-DALI-SIO (RS-485)

Anschluss des RESI-DALI-ETH (Ethernet)

DALI-Bus-Netzteil

DALI-Bus-Regeln

Konfiguration#

Modbus-Kommunikation aktivieren

Slave ID des Gateways einstellen

Gerätefunktionen#

Konfigurationsassistent — Find New Devices

DALI-Gerätesonde — Gear 0 … Gear 63

Gateway-Aktionen

Fehlerbehebung#

Assistent läuft bei jedem Schritt in Timeout

Gear 0–63 melden nach der Inbetriebnahme alle --

Set Slave ID ändert die Adresse nicht

Kommunikation funktioniert kurz, dann scheitert sie

Verfügbare Geräte 1

${resi_dali_configuration}

Neue Geräte finden

Importparameter

Quellen

Verwandte Dokumentation

Haben Sie ein Problem mit dieser Gerätevorlage gefunden?

Hardware-Anschluss

Konfiguration

Gerätefunktionen

Fehlerbehebung

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