RESI-DALI-SIO — Punere în funcțiune DALI

Resi Dali - Configuration

Modbus RTU

Trimis de

Ultima actualizare: 10. 2026

Necesită gateway extern
Resi RESI-DALI-PS — pagina produsului

Șablonul Resi Dali - Configurare este un instrument de punere în funcțiune și adresare, folosit o singură dată la configurarea inițială a gateway-ului Modbus-DALI RESI-DALI-SIO și RESI-DALI-ETH de la RESI Informatik & Automation GmbH. Din TapHome, el rulează algoritmul de adresare aleatorie DALI 2.0, care atribuie adresele scurte 0–63 dispozitivelor de comandă de pe o magistrală DALI nou cablată, interoghează fiecare adresă pentru tipul de dispozitiv DALI și oferă teste de verificare broadcast ON/OFF — tot ce este necesar pentru a aduce o instalație nouă în starea în care lămpile pot fi controlate individual.

Comunicația cu gateway-ul folosește Modbus RTU la 9600 baud 8N1. Șablonul oferă și parametrul de import IpAddress, astfel încât același proces funcționează și printr-un convertor serial-IP (Moxa NPort, USR-TCP232) sau printr-un RESI-DALI-ETH configurat în modul transparent RTU-over-Ethernet.

Acest șablon este conceput exclusiv pentru adresare. După atribuirea adreselor scurte, eliminați modulul Resi Dali - Configurare și folosiți pentru controlul de zi cu zi șablonul operațional înrudit Resi DALI (Dali.xml) — reglarea individuală a intensității lămpilor, reglarea intensității grupurilor și diagnosticarea fiecărui dispozitiv de comandă. Modulul de punere în funcțiune nu este conceput să rămână în proiect după configurarea inițială.

Conectarea hardware

RESI-DALI-SIO este un gateway master pe șină DIN (17,5 × 90 × 56,4 mm, CEM17), care se află între un host serial/Ethernet și o magistrală de iluminat DALI. Gateway-ul nu alimentează magistrala DALI — este obligatorie o sursă de alimentare DALI separată (RESI-DALI-PS sau orice sursă DALI conformă de 200 mA).

Conectarea RESI-DALI-SIO (RS-485)

Schema de conectare RESI-DALI-SIO — cu sursă DALI externă (sus) și cu RESI-DALI-PS (jos)

Bornele de pe partea stângă a RESI-DALI-SIO (de sus în jos): GND, +12..48V=, RS485 DATA+ (A+), RS485 DATA- (B-), RS485 GND, RS232 TX, RS232 RX, RS232 GND. Bornele magistralei DALI de pe partea opusă sunt D+ / N/C / D- (bloc USLIM cu 3 pini, N/C rămâne neconectat).

Pentru o instalație TapHome folosiți interfața RS-485:

RS485 DATA+ (A+) → A+/D+ pe magistrala RS-485 TapHome
RS485 DATA- (B-) → B-/D- pe magistrala RS-485 TapHome
RS485 GND → GND pe sursa de alimentare TapHome (recomandat pentru o comunicație stabilă)
+12..48V= / GND → alimentare principală 12–48 V DC

Conectarea RESI-DALI-ETH (Ethernet)

Schema de conectare RESI-DALI-ETH — cu sursă DALI externă (sus) și cu RESI-DALI-PS (jos)

Varianta Ethernet are aceleași borne pentru magistrala DALI (D+ / N/C / D-) și pentru alimentarea principală (GND, +12..48V=), plus un singur conector RJ45 pentru Ethernet 10/100 Mbit. Setările IP implicite din fabrică sunt 192.168.0.191 / 255.255.255.0 / 192.168.0.1, cu Modbus Unit ID 255; datele de autentificare pentru interfața web sunt RESI / RESI. TapHome comunică cu varianta ETH în modul transparent RTU-over-Ethernet, pe care îl așteaptă acest șablon de punere în funcțiune (consultați Configurare mai jos).

Sursa de alimentare a magistralei DALI

RESI-DALI-PS — alimentarea independentă a magistralei DALI (sus) și în combinație cu un gateway SIO/ETH (jos)

RESI-DALI-PS livrează până la 200 mA pe magistrala DALI (curent de scurtcircuit ~225 mA, tensiunea tipică a magistralei 14–18 V) și acceptă până la 64 de balasturi DALI 1.0 sau dispozitive de comandă DALI 2.0 pe o singură linie. Partea primară acceptă aceeași alimentare de 12–48 V DC ca unitatea SIO/ETH. Gateway-ul și sursa de alimentare se conectează la aceeași pereche D+ / D- — sursa alimentează magistrala, iar gateway-ul citește și scrie cadrele DALI.

Trei LED-uri de pe sursa de alimentare ajută la punerea în funcțiune: POWER (alimentarea primară de 12–48 V este în regulă, aprins permanent), DALI (clipește scurt în timpul traficului pe magistrală), ERR (aprins continuu la defectarea sursei, la scurtcircuit DALI sau la suprasarcina magistralei — în funcționare normală trebuie să fie stins).

Regulile magistralei DALI

O linie DALI impune câteva constrângeri stricte, care influențează direct reușita punerii în funcțiune:

Secțiunea conductorului	Lungimea maximă a cablului DALI
1,5 mm²	300 m
1,0 mm²	238 m
0,75 mm²	174 m
0,5 mm²	116 m

Limita rezultă din căderea de tensiune maximă admisă de 2 V pe cablul DALI. Alte reguli:

Maximum 64 de balasturi DALI 1.0 și până la 64 de dispozitive de comandă DALI 2.0 pe o magistrală (spații de adrese scurte separate).
Doar topologie arborescentă — fără inele, fără bucle.
Numărul real de dispozitive depinde și de curentul nominal al sursei de alimentare (de obicei 200 mA la RESI-DALI-PS, aproximativ 2 mA pentru fiecare dispozitiv plus rezervă).

RESI-DALI-PS (sau o sursă DALI echivalentă) este obligatorie. Fără ea, RESI-DALI-SIO/ETH nu poate comanda magistrala, iar asistentul de punere în funcțiune va depăși timpul de așteptare la fiecare pas. Dacă pe o linie lungă se folosește o a doua sursă de alimentare, introduceți o bobină DALI sau împărțiți magistrala în segmente separate galvanic.

Configurare

Activarea comunicației Modbus

Toți parametrii comunicației seriale cu hostul se selectează pe RESI-DALI-SIO cu un comutator DIP cu 4 poziții. Șablonul TapHome folosește valorile fixe 9600 baud 8N1, așa că comutatoarele DIP trebuie setate corespunzător.

DIP1	DIP2	Viteza de transmisie
OFF	OFF	9600 bd (necesar pentru TapHome)
ON	OFF	19200 bd
OFF	ON	38400 bd
ON	ON	Folosește viteza de transmisie programată în FLASH (implicit din fabrică 57600 bd)

DIP4	Sursa pentru Modbus Unit ID
OFF	Registrul FLASH `H:65221` — necesar pentru ca acțiunea Setare Slave ID să aibă efect
ON	Forțat la `255` (valoare de rezervă hardware, valoarea din FLASH este ignorată)

DIP3 este un bit rezervat specific produsului; lăsați-l în poziția din fabrică, cu excepția cazului în care manualul de service RESI indică explicit altfel. Paritatea este fixată la None (8N1) în valorile implicite din FLASH — șablonul nu oferă registrele pentru paritate / biți de stop.

Terminarea RS-485: terminați magistrala cu 120 Ω la ambele capete. TapHome Core asigură o terminare pe bornele sale BUS; dacă gateway-ul RESI este ultimul dispozitiv de pe linie, adăugați un rezistor separat de 120 Ω între A+/B- pe bornele sale RS-485.

Configurarea RTU-over-TCP: șablonul are ambii parametri de import SlaveId și IpAddress, deoarece același proces de punere în funcțiune DALI funcționează și printr-un convertor serial-IP (Moxa NPort, USR-TCP232) sau prin RESI-DALI-ETH în modul transparent RTU-over-Ethernet. În acest caz, setați în IpAddress adresa IP a convertorului / unității ETH și păstrați celelalte setări identice cu varianta RS-485. Pentru Modbus/TCP pur pe RESI-DALI-ETH ar fi mai potrivit un șablon bazat pe TCP — șablonul DaliConfig presupune în mod specific cadre Modbus RTU.

Setarea Slave ID-ului gateway-ului

Unit ID-ul implicit din fabrică este 255. Pentru a-l schimba:

Setați DIP4 = OFF pe gateway, ca să fie folosit Unit ID-ul din FLASH.
Importați șablonul în TapHome cu SlaveId = 255 (adresa curentă).
Deschideți setările de service ale modulului „Resi Dali - Configurare” și declanșați acțiunea Setare Slave ID cu noul ID dorit (interval 1–255). Acțiunea scrie valoarea în registrul H:65221 și declanșează imediat o resetare software prin H:6000 = 1, astfel încât gateway-ul repornește cu noua adresă.
Eliminați șablonul și importați-l din nou, cu SlaveId setat la noua valoare. Modulul poate fi apoi folosit pentru punerea în funcțiune.

Acțiunea Resetare gateway (scrie 1 în H:6000) este disponibilă și ca pas de recuperare independent — util după un scurtcircuit pe magistrala DALI, care a lăsat modulul DALI al gateway-ului într-o stare degradată.

Un singur master Modbus în același timp. Nici DALI, nici magistrala Modbus RTU nu arbitrează între mai mulți masteri simultani. Dacă în timpul punerii în funcțiune gateway-ul este interogat și de un PLC, de un sistem BMS sau de un instrument pe PC (de exemplu MODBUSConfigurator), programarea adreselor scurte va intra în coliziune, iar asistentul va raporta erori.

Funcțiile dispozitivului

Șablonul este construit în jurul unui singur modul Modbus — Resi Dali - Configurare — care reunește asistentul de punere în funcțiune, interogarea tipului de dispozitiv DALI pentru fiecare adresă scurtă 0–63 și patru acțiuni la nivelul gateway-ului.

Asistentul de punere în funcțiune — Găsire dispozitive noi

Găsire dispozitive noi este un comutator cu zece stări (multi-value switch), care rulează în pași separați algoritmul de adresare aleatorie DALI 2.0. Fiecare nume de stare corespunde unei faze a secvenței de punere în funcțiune DALI 2.0; la selectarea unei stări, șablonul trimite cadrul DALI brut corect de 16 biți pe H:541 / H:542, apoi interoghează starea DALI RX pe H:550 pentru răspunsul gateway-ului.

Pas	Stare	Ce face
0	TERMINATE	Cadrul DALI `TERMINATE` (`0xA100`) — întrerupe sesiunea de adresare curentă și resetează starea gateway-ului. Poate fi apelat oricând în siguranță
1	Start	`INITIALISE` (`0xA5FF`) + `RANDOMISE` (`0xA700`) — trece toate dispozitivele fără adresă în setul de adresare și cere fiecărui dispozitiv să-și aleagă o adresă aleatorie de 24 de biți
2	Scanare adresă scurtă	Interoghează următoarea poziție de adresă scurtă; returnează codul de stare 7 când nu răspunde niciun dispozitiv
3	Set SEARCHADDR	Încarcă octeții superior/mijlociu/inferior SEARCHADDR (`0xB500/0xB300/0xB100`) pentru căutarea binară
4	COMPARE	Trimite `COMPARE` (`0xA900`) și restrânge fereastra de căutare de 24 de biți în funcție de răspuns
5	PROGRAM SHORT ADDRESS	Scrie adresa scurtă verificată prin `0xB7xx` — dispozitivul are acum o adresă permanentă
6	Verificare	Verifică adresa programată cu un al doilea `COMPARE` la valoarea finală `SEARCHADDRL`
7	Reîncercare	Recuperare după coliziune / depășirea timpului de așteptare — înjumătățește intervalul de căutare curent și reîncearcă
8	Resetare adrese scurte	DALI `DTR = 0xFF` (`0xA3FF`) + broadcast `REMOVE SHORT ADDRESS` — șterge toate adresele scurte existente, pregătind o readresare completă
9	Finalizare	Citește octetul de rezultat DALI, afișează un mesaj TapHome de informare / eroare și închide asistentul

Procesul tipic de punere în funcțiune:

Alimentați magistrala DALI (RESI-DALI-PS), conectați dispozitivele în topologie arborescentă și asigurați-vă că nimic altceva nu comandă magistrala.
(Opțional, dar recomandat) rulați mai întâi Resetare adrese scurte, pentru a porni de la o stare curată, cu toate dispozitivele fără adresă.
Rulați Start — acesta trimite INITIALISE + RANDOMISE, astfel încât fiecare dispozitiv își alege o nouă adresă aleatorie de 24 de biți.
Rulați în ordine Scanare adresă scurtă → Set SEARCHADDR → COMPARE → PROGRAM SHORT ADDRESS → Verificare. Stările încapsulează căutarea binară DALI 2.0; fiecare pas avansează algoritmul cu o fază.
Dacă un pas raportează o coliziune sau depășirea timpului de așteptare, apelați Reîncercare și rulați din nou secvența de comparare/programare.
După ce toate dispozitivele vizibile au fost programate, rulați TERMINATE și apoi Finalizare, pentru a închide corect asistentul.
Folosiți atributele de service Gear 0 … Gear 63 și acțiunile Aprinderea / Stingerea tuturor lămpilor pentru a verifica dacă adresele scurte 0–N sunt acum ocupate (consultați mai jos).

Asistentul este conceput să fie parcurs câte o stare pe rând — șablonul nu automatizează întreaga buclă, deoarece instalatorul trebuie să urmărească comportamentul magistralei DALI (lămpi care pulsează, ritmul LED-ului STATE de pe gateway), pentru a depista dispozitivele conectate greșit sau lipsă.

Interogarea dispozitivelor DALI — Gear 0 … Gear 63

Fiecare dintre cele 64 de atribute de service Gear 0, Gear 1, … Gear 63 interoghează o adresă scurtă DALI cu comanda DALI 2.0 QUERY DEVICE TYPE (0x99). Intern, șablonul scrie (SA << 8) | 0x99 în H:511, interoghează biții 0–2 din H:550 până sosește un răspuns, apoi citește octetul de răspuns înapoi din H:511.

Valori posibile returnate în interfața de service TapHome:

DT{n} — la această adresă este programat un dispozitiv de comandă, care a răspuns cu tipul de dispozitiv n. Valori tipice: DT0 (fluorescent), DT1 (iluminat de urgență), DT2 (HID), DT5 (0–10 V), DT6 (driver LED), DT7 (releu), DT8 (culoare / alb reglabil), DT9 (secvențiator).
-- — fie la această adresă nu este programat niciun dispozitiv, fie gateway-ul a returnat valoarea de semnalizare 0x8000 „no answer / already consumed”.

Interogarea arată rapid, cu rezultat reușit/eșuat, ce adrese scurte sunt ocupate după punerea în funcțiune și ce tipuri de dispozitive au fost descoperite — acesta este pasul principal de verificare înainte de trecerea proiectului la șablonul operațional Resi Dali.

Acțiuni la nivelul gateway-ului

Patru acțiuni de service ale modulului comandă direct gateway-ul:

Resetare gateway — scrie 1 în H:6000 (DIP SWITCH / SOFTWARE RESET). Repornește gateway-ul; util după un scurtcircuit pe magistrală, pentru a reface funcționarea modulului DALI.
Setare Slave ID — scrie noul Unit ID (1–255) în registrul FLASH H:65221, apoi resetează prin H:6000. Pentru a avea efect necesită DIP4 = OFF.
Aprinderea tuturor lămpilor — scrie 0xFE (putere arc 254 = 100 %) în registrul de nivel broadcast DALI H:530. Aprinde fiecare dispozitiv de pe magistrală, indiferent de adresa scurtă — o confirmare vizuală rapidă că magistrala și sursa de alimentare sunt în regulă.
Stingerea tuturor lămpilor — scrie 0x00 în H:530 și stinge fiecare dispozitiv. Aceeași cale broadcast, valoare opusă.

Atributul de service Slave ID al modulului citește Unit ID-ul curent din registrul FLASH H:65221, astfel încât adresa programată în prezent poate fi verificată înainte de a trimite Setare Slave ID.

Rulați Aprinderea tuturor lămpilor imediat după cablare, înainte de a porni asistentul de adresare. Fiecare dispozitiv alimentat și conectat corect pe magistrală se va aprinde la 100 %, ceea ce este o metodă foarte rapidă de a depista corpurile de iluminat lipsă sau conectate greșit, înainte de a pierde timp cu programarea adreselor scurte.

Depanare

Asistentul depășește timpul de așteptare la fiecare pas

Verificați tensiunea magistralei DALI la bornele sursei de alimentare — trebuie să fie 11,5–22,5 V (tipic 14–16 V). O valoare semnificativ mai mică indică de obicei un scurtcircuit DALI.
Verificați LED-ul ERR al RESI-DALI-PS — dacă este aprins, magistrala este în scurtcircuit, supraîncărcată sau sursa de alimentare este defectă.
Verificați LED-ul STATE al gateway-ului — un ritm lent de 1 s înseamnă că magistrala DALI este în regulă, un ritm rapid de ~250 ms indică o eroare de magistrală, un scurtcircuit sau lipsa alimentării DALI.
Asigurați-vă că niciun alt master Modbus (MODBUSConfigurator, BMS, PLC) nu comunică în același timp cu gateway-ul.

Toate atributele Gear 0–63 raportează `--` după punerea în funcțiune

Măsurați tensiunea DALI la dispozitivul cel mai îndepărtat de sursa de alimentare — trebuie să fie peste 9,5 V. Dacă este mai mică, magistrala este prea lungă pentru secțiunea cablului (consultați tabelul cu lungimile cablului DALI de mai sus). Împărțiți magistrala în două segmente cu o a doua sursă de alimentare.
Rulați din nou asistentul, începând cu Resetare adrese scurte. Nu rulați Start pe o magistrală care încă are dispozitive programate anterior, decât dacă resetați mai întâi — algoritmul găsește doar dispozitivele fără adresă scurtă.
Căutați bucle în cablaj. DALI nu tolerează inele; întrerupeți orice buclă găsită și refaceți terminarea ambelor capete libere.

Setare Slave ID nu schimbă adresa

Confirmați că pe gateway este DIP4 = OFF. Când DIP4 = ON, hardware-ul forțează Unit ID 255, indiferent de valoarea din FLASH.
Confirmați că gateway-ul chiar a repornit după acțiune (LED-urile gateway-ului se sting pentru scurt timp). Dacă nu a repornit, declanșați manual Resetare gateway.
Importați din nou șablonul cu noul parametru de import SlaveId — modulul importat anterior încă interoghează la adresa veche.

Comunicația funcționează scurt timp, apoi se întrerupe

Verificați că RS485 GND este conectat între gateway și comunul sursei de alimentare TapHome. GND-ul lipsă este cea mai frecventă defecțiune RS-485.
Verificați terminarea — 120 Ω la ambele capete ale magistralei RS-485. Pentru RTU-over-TCP printr-un convertor serial, asigurați-vă că acesta transmite cadre RTU nemodificate, nu în modul TCP brut, și că pauza dintre caractere pe partea serială corespunde temporizării 9600 baud 8N1.
Reduceți numărul de interogări DALI paralele — gateway-ul serializează tranzacțiile DALI și nu arbitrează între mai mulți masteri Modbus.

Dispozitive disponibile

Resi Dali - Configurare Modul

Atribute de service

Slave ID	Citește Unit ID-ul Modbus salvat în registrul FLASH H:65221 — folosit pentru verificarea adresei curente a gateway-ului
Gear 0	Interogarea tipului de dispozitiv DALI la adresa scurtă 0 — returnează DT{n} când răspunde un dispozitiv de comandă sau -- când adresa este liberă
Gear 1	Interogarea tipului de dispozitiv DALI la adresa scurtă 1 — returnează DT{n} sau --
Gear 2	Interogarea tipului de dispozitiv DALI la adresa scurtă 2 — returnează DT{n} sau --
Gear 3	Interogarea tipului de dispozitiv DALI la adresa scurtă 3 — returnează DT{n} sau --
Gear 4	Interogarea tipului de dispozitiv DALI la adresa scurtă 4 — returnează DT{n} sau --
Gear 5	Interogarea tipului de dispozitiv DALI la adresa scurtă 5 — returnează DT{n} sau --
Gear 6	Interogarea tipului de dispozitiv DALI la adresa scurtă 6 — returnează DT{n} sau --
Gear 7	Interogarea tipului de dispozitiv DALI la adresa scurtă 7 — returnează DT{n} sau --
Gear 8	Interogarea tipului de dispozitiv DALI la adresa scurtă 8 — returnează DT{n} sau --
Gear 9	Interogarea tipului de dispozitiv DALI la adresa scurtă 9 — returnează DT{n} sau --
Gear 10	Interogarea tipului de dispozitiv DALI la adresa scurtă 10 — returnează DT{n} sau --
Gear 11	Interogarea tipului de dispozitiv DALI la adresa scurtă 11 — returnează DT{n} sau --
Gear 12	Interogarea tipului de dispozitiv DALI la adresa scurtă 12 — returnează DT{n} sau --
Gear 13	Interogarea tipului de dispozitiv DALI la adresa scurtă 13 — returnează DT{n} sau --
Gear 14	Interogarea tipului de dispozitiv DALI la adresa scurtă 14 — returnează DT{n} sau --
Gear 15	Interogarea tipului de dispozitiv DALI la adresa scurtă 15 — returnează DT{n} sau --
Gear 16	Interogarea tipului de dispozitiv DALI la adresa scurtă 16 — returnează DT{n} sau --
Gear 17	Interogarea tipului de dispozitiv DALI la adresa scurtă 17 — returnează DT{n} sau --
Gear 18	Interogarea tipului de dispozitiv DALI la adresa scurtă 18 — returnează DT{n} sau --
Gear 19	Interogarea tipului de dispozitiv DALI la adresa scurtă 19 — returnează DT{n} sau --
Gear 20	Interogarea tipului de dispozitiv DALI la adresa scurtă 20 — returnează DT{n} sau --
Gear 21	Interogarea tipului de dispozitiv DALI la adresa scurtă 21 — returnează DT{n} sau --
Gear 22	Interogarea tipului de dispozitiv DALI la adresa scurtă 22 — returnează DT{n} sau --
Gear 23	Interogarea tipului de dispozitiv DALI la adresa scurtă 23 — returnează DT{n} sau --
Gear 24	Interogarea tipului de dispozitiv DALI la adresa scurtă 24 — returnează DT{n} sau --
Gear 25	Interogarea tipului de dispozitiv DALI la adresa scurtă 25 — returnează DT{n} sau --
Gear 26	Interogarea tipului de dispozitiv DALI la adresa scurtă 26 — returnează DT{n} sau --
Gear 27	Interogarea tipului de dispozitiv DALI la adresa scurtă 27 — returnează DT{n} sau --
Gear 28	Interogarea tipului de dispozitiv DALI la adresa scurtă 28 — returnează DT{n} sau --
Gear 29	Interogarea tipului de dispozitiv DALI la adresa scurtă 29 — returnează DT{n} sau --
Gear 30	Interogarea tipului de dispozitiv DALI la adresa scurtă 30 — returnează DT{n} sau --
Gear 31	Interogarea tipului de dispozitiv DALI la adresa scurtă 31 — returnează DT{n} sau --
Gear 32	Interogarea tipului de dispozitiv DALI la adresa scurtă 32 — returnează DT{n} sau --
Gear 33	Interogarea tipului de dispozitiv DALI la adresa scurtă 33 — returnează DT{n} sau --
Gear 34	Interogarea tipului de dispozitiv DALI la adresa scurtă 34 — returnează DT{n} sau --
Gear 35	Interogarea tipului de dispozitiv DALI la adresa scurtă 35 — returnează DT{n} sau --
Gear 36	Interogarea tipului de dispozitiv DALI la adresa scurtă 36 — returnează DT{n} sau --
Gear 37	Interogarea tipului de dispozitiv DALI la adresa scurtă 37 — returnează DT{n} sau --
Gear 38	Interogarea tipului de dispozitiv DALI la adresa scurtă 38 — returnează DT{n} sau --
Gear 39	Interogarea tipului de dispozitiv DALI la adresa scurtă 39 — returnează DT{n} sau --
Gear 40	Interogarea tipului de dispozitiv DALI la adresa scurtă 40 — returnează DT{n} sau --
Gear 41	Interogarea tipului de dispozitiv DALI la adresa scurtă 41 — returnează DT{n} sau --
Gear 42	Interogarea tipului de dispozitiv DALI la adresa scurtă 42 — returnează DT{n} sau --
Gear 43	Interogarea tipului de dispozitiv DALI la adresa scurtă 43 — returnează DT{n} sau --
Gear 44	Interogarea tipului de dispozitiv DALI la adresa scurtă 44 — returnează DT{n} sau --
Gear 45	Interogarea tipului de dispozitiv DALI la adresa scurtă 45 — returnează DT{n} sau --
Gear 46	Interogarea tipului de dispozitiv DALI la adresa scurtă 46 — returnează DT{n} sau --
Gear 47	Interogarea tipului de dispozitiv DALI la adresa scurtă 47 — returnează DT{n} sau --
Gear 48	Interogarea tipului de dispozitiv DALI la adresa scurtă 48 — returnează DT{n} sau --
Gear 49	Interogarea tipului de dispozitiv DALI la adresa scurtă 49 — returnează DT{n} sau --
Gear 50	Interogarea tipului de dispozitiv DALI la adresa scurtă 50 — returnează DT{n} sau --
Gear 51	Interogarea tipului de dispozitiv DALI la adresa scurtă 51 — returnează DT{n} sau --
Gear 52	Interogarea tipului de dispozitiv DALI la adresa scurtă 52 — returnează DT{n} sau --
Gear 53	Interogarea tipului de dispozitiv DALI la adresa scurtă 53 — returnează DT{n} sau --
Gear 54	Interogarea tipului de dispozitiv DALI la adresa scurtă 54 — returnează DT{n} sau --
Gear 55	Interogarea tipului de dispozitiv DALI la adresa scurtă 55 — returnează DT{n} sau --
Gear 56	Interogarea tipului de dispozitiv DALI la adresa scurtă 56 — returnează DT{n} sau --
Gear 57	Interogarea tipului de dispozitiv DALI la adresa scurtă 57 — returnează DT{n} sau --
Gear 58	Interogarea tipului de dispozitiv DALI la adresa scurtă 58 — returnează DT{n} sau --
Gear 59	Interogarea tipului de dispozitiv DALI la adresa scurtă 59 — returnează DT{n} sau --
Gear 60	Interogarea tipului de dispozitiv DALI la adresa scurtă 60 — returnează DT{n} sau --
Gear 61	Interogarea tipului de dispozitiv DALI la adresa scurtă 61 — returnează DT{n} sau --
Gear 62	Interogarea tipului de dispozitiv DALI la adresa scurtă 62 — returnează DT{n} sau --
Gear 63	Interogarea tipului de dispozitiv DALI la adresa scurtă 63 — returnează DT{n} sau --

Acțiuni de service

Resetare gateway	Scrie 1 în registrul H:6000 pentru a reporni gateway-ul RESI-DALI — necesar după schimbarea Slave ID-ului sau pentru a reface funcționarea modulului DALI după un scurtcircuit pe magistrală
Setare Slave ID	Scrie noul Modbus Unit ID în registrul FLASH H:65221 și declanșează o resetare, astfel încât gateway-ul repornește cu noua adresă (1–255, DIP4 trebuie să fie OFF)
Aprinderea tuturor lămpilor	Scrie 0xFE în registrul de nivel broadcast DALI H:530 — aduce toate dispozitivele de comandă de pe magistrală la luminozitate maximă (test rapid de verificare la punerea în funcțiune)
Stingerea tuturor lămpilor	Scrie 0x00 în registrul de nivel broadcast DALI H:530 — oprește toate dispozitivele de comandă de pe magistrală

${resi_dali_configuration}

Atribute de service

${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("--"));

Acțiuni de service

${xml_reset_gateway}

modbusw(SH,6000,uint16,1)

${xml_set_slave_id}

Parametri: ${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)

Găsire dispozitive noi Comutator cu mai multe valori

Asistent de punere în funcțiune care parcurge pas cu pas algoritmul de adresare aleatorie DALI 2.0, pentru a atribui adresele scurte 0–63 dispozitivelor de comandă

Registru: H:541 → H:542 UInt16 numeric

Valori / Stări: TERMINATE · ${xml_start} · ${xml_scan_short_address} · Set SEARCHADDR · COMPARE · PROGRAM SHORT ADDRESS · Check · Try again · ${xml_reset_short_addresses} · ${xml_finish}

Găsire dispozitive noi

Citirea stării comutatorului

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

Scrierea stării comutatorului

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

Conexiune: Modbus RTU • 9600 baud• 8N1 • Slave ID: $[SlaveId]

Îmbunătățiri posibile (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

Descărcați șablon

Surse

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

Ați găsit o problemă la acest șablon de dispozitiv?

Spuneți-ne ce nu funcționează, ce lipsește sau cum ar trebui să se comporte șablonul. Feedbackul dvs. ne ajută să păstrăm catalogul corect.

Verificat de TapHome

Doriți să folosiți acest șablon în TapHome Core?

Deschideți acest șablon în Customer Portal pentru a-l aplica într-una dintre locuințele dvs. sau pentru a propune o îmbunătățire și a o trimite înapoi în catalog.

Deschideți în portal