RESI-DALI-SIO — DALI Üzembe Helyezés

Resi Dali - Konfiguráció

Modbus RTU

Beküldő

Utoljára frissítve: 04. 2026

Külső átjáró szükséges
Resi RESI-DALI-PS — termékoldal

A Resi Dali - Konfiguráció sablon egy egyszeri üzembe helyezési és címzési eszköz a RESI Informatik & Automation GmbH Modbus-DALI átjáróihoz (RESI-DALI-SIO és RESI-DALI-ETH). Közvetlenül a TapHome-ból vezérli a DALI 2.0 véletlen címzési algoritmust, rövid címeket (0–63) rendel az újonnan bekötött DALI buszon lévő vezérlőkhöz, minden címen lekérdezi a DALI eszköztípust, és gyors broadcast ON/OFF teszteket kínál — minden, ami egy új telepítés olyan állapotba hozásához szükséges, amikor a lámpákat egyénileg lehet vezérelni.

Az átjáróval a kommunikáció Modbus RTU-n keresztül történik 9600 baud 8N1 sebességgel. A sablon egy IpAddress importparamétert is kínál, így ugyanez a folyamat serial-to-IP híd (Moxa NPort, USR-TCP232) vagy transzparens RTU-over-Ethernet módba konfigurált RESI-DALI-ETH segítségével is működik.

Ez a sablon szándékosan csak címzésre való. A rövid címek kiosztása után távolítsa el a Resi Dali - Konfiguráció modult a projektből, és a mindennapi vezérléshez használja a testvér operatív Resi Dali sablont (Dali.xml) — egyedi lámpa tompítás, csoportok, jelenetek és DT6/DT8 RGB / tunable-white színvezérlés. A konfigurációs modul nem arra lett tervezve, hogy a kezdeti beállítás után a projektben maradjon.

Hardveres bekötés

A RESI-DALI-SIO egy DIN-sínes master átjáró (17,5 × 90 × 56,4 mm, CEM17), amely egy soros/ethernet hoszt és egy DALI világítási busz között helyezkedik el. Az átjáró nem táplálja a DALI buszt — kompatibilis DALI tápegység (RESI-DALI-PS vagy bármilyen szabványnak megfelelő 200 mA-es DALI tápegység) kötelező.

A RESI-DALI-SIO csatlakoztatása (RS-485)

RESI-DALI-SIO bekötési rajz — külső DALI tápegység (fent) és RESI-DALI-PS-sel (lent)

A RESI-DALI-SIO bal oldalán lévő csatlakozók (fentről lefelé): GND, +12..48V=, RS485 DATA+ (A+), RS485 DATA- (B-), RS485 GND, RS232 TX, RS232 RX, RS232 GND. A DALI busz csatlakozói a szemközti oldalon D+ / N/C / D- (3 pólusú USLIM blokk, N/C bekötetlen marad).

Egy TapHome telepítéshez használja az RS-485 interfészt:

RS485 DATA+ (A+) → A+/D+ a TapHome RS-485 buszon
RS485 DATA- (B-) → B-/D- a TapHome RS-485 buszon
RS485 GND → GND a TapHome tápegységen (stabil kommunikációhoz ajánlott)
+12..48V= / GND → 12–48 V DC elsődleges tápfeszültség

A RESI-DALI-ETH csatlakoztatása (Ethernet)

RESI-DALI-ETH bekötési rajz — külső DALI tápegység (fent) és RESI-DALI-PS-sel (lent)

Az Ethernet változat ugyanazokkal a DALI busz csatlakozókkal (D+ / N/C / D-) és elsődleges táppal (GND, +12..48V=) rendelkezik, valamint egy RJ45 csatlakozóval 10/100 Mbit Ethernethez. A gyári alapértelmezett IP beállítások 192.168.0.191 / 255.255.255.0 / 192.168.0.1 Modbus Unit ID 255-tel; a web UI belépési adatok RESI / RESI. A TapHome Modbus TCP-n keresztül kommunikál az ETH változattal, vagy a transzparens RTU-over-Ethernet módban, amelyet ez a konfigurációs sablon vár (lásd Konfiguráció lent).

DALI busz tápegység

RESI-DALI-PS — önállóan a DALI busz táplálása (fent) és SIO/ETH átjáróval kombinálva (lent)

A RESI-DALI-PS akár 200 mA-t is képes leadni a DALI buszra (rövidzárlati áram ~225 mA, tipikus buszfeszültség 14–18 V), és egyetlen vonalon akár 64 DALI 1.0 előtétet vagy DALI 2.0 vezérlőt támogat. Az elsődleges oldal ugyanazt a 12–48 V DC tápellátást fogadja, mint a SIO/ETH egység. Az átjáró és a tápegység ugyanazt a D+ / D- párt használja — a tápegység energiával látja el a buszt, míg az átjáró olvassa és írja a DALI kereteket.

Három LED a tápegységen segít az üzembe helyezés során: POWER (elsődleges 12–48 V OK, mindig világít), DALI (röviden villog buszforgalom közben), ERR (folyamatosan világít tápegység hibánál, DALI rövidzárnál vagy busz túlterhelésnél — normál működés során ki kell, hogy legyen).

DALI busz szabályok

A DALI vonalnak van néhány szigorú korlátozása, amelyek közvetlenül befolyásolják az üzembe helyezés sikerét:

Vezető keresztmetszet	Max DALI kábelhossz
1,5 mm²	300 m
1,0 mm²	238 m
0,75 mm²	174 m
0,5 mm²	116 m

A határ a maximálisan megengedett 2 V feszültségesésből adódik a DALI kábelen. További szabályok:

Maximum 64 DALI 1.0 előtét és akár 64 DALI 2.0 vezérlő buszonként (külön rövid cím terek).
Csak fa topológia — nincsenek gyűrűk, nincsenek hurkok.
A tényleges eszközszám a tápegység áramértékétől is függ (jellemzően 200 mA a RESI-DALI-PS-en, számoljon ~2 mA-t eszközönként plusz tartalékot).

A RESI-DALI-PS (vagy azonos értékű DALI tápegység) kötelező. Enélkül a RESI-DALI-SIO/ETH nem tudja hajtani a buszt, és az üzembe helyezési varázsló minden lépésnél timeoutra fut. Ha hosszú vonalon második tápegységet használnak, illesszen be DALI fojtót vagy ossza a buszt galvanikusan elválasztott szegmensekre.

Konfiguráció

Modbus kommunikáció engedélyezése

A RESI-DALI-SIO minden hoszt soros paraméterét a modul 4 pozíciós DIP kapcsolójával kell kiválasztani. A TapHome sablon 9600 baud 8N1 fixre van állítva, így a DIP kapcsolókat ennek megfelelően kell beállítani.

DIP1	DIP2	Átviteli sebesség
OFF	OFF	9600 bd (a TapHome által megkövetelt)
ON	OFF	19200 bd
OFF	ON	38400 bd
ON	ON	A FLASH-be programozott baud rate-et használja (gyári alapérték 57600 bd)

DIP4	Modbus Unit ID forrás
OFF	FLASH regiszter `H:65221` — szükséges ahhoz, hogy a Set Slave ID művelet hatályba lépjen
ON	Kényszerítve `255`-re (hardveres fallback, FLASH érték figyelmen kívül hagyva)

A DIP3 egy termékspecifikus fenntartott bit; hagyja gyári pozícióban, hacsak a RESI szervizkézikönyv kifejezetten nem ír elő mást. A paritás a FLASH alapértelmezésben fixen None (8N1) — a sablon nem teszi elérhetővé a paritás/stop bit regisztereket.

RS-485 lezárás: zárja le a buszt 120 Ω-mal mindkét végén. A TapHome Core egy lezárást biztosít a BUS csatlakozóin; ha a RESI átjáró az utolsó eszköz a vonalon, adjon hozzá egy diszkrét 120 Ω-os ellenállást az RS-485 csatlakozóin A+/B- között.

RTU-over-TCP beállítás: a sablon mind a SlaveId, mind az IpAddress importparaméterekkel rendelkezik, mert ugyanaz a DALI konfigurációs folyamat működik serial-to-IP hídon (Moxa NPort, USR-TCP232) vagy RESI-DALI-ETH-n transzparens RTU-over-Ethernet módban is. Ebben az esetben irányítsa az IpAddress-t a híd / ETH egység IP-jére, és a többi beállítást hagyja azonosan az RS-485 változattal. Tiszta Modbus/TCP esetén a RESI-DALI-ETH-hez természetesebb lenne egy TCP alapú sablon — a DaliConfig sablon kifejezetten keretezett RTU forgalmat feltételez.

Átjáró Slave ID beállítása

A gyári alapértelmezett Unit ID 255. Megváltoztatásához:

Állítsa az átjárón DIP4 = OFF-ra, hogy a FLASH Unit ID érvényesüljön.
Importálja a sablont a TapHome-ba SlaveId = 255-tel (aktuális cím).
Nyissa meg a “Resi Dali - Konfiguráció” modul szervizbeállításait, és indítsa el a Set Slave ID műveletet a kívánt új ID-val (tartomány 1–255). A művelet beírja az értéket a H:65221 regiszterbe, és azonnal szoftveres resetet indít H:6000 = 1-en keresztül, így az átjáró az új címmel újraindul.
Távolítsa el a sablont, és importálja újra az új SlaveId értékkel. A modul ezután használható üzembe helyezésre.

A Reset Gateway művelet (1-et ír a H:6000-be) szintén elérhető önálló helyreállítási lépésként — hasznos DALI busz rövidzár után, amely degradált állapotban hagyta az átjáró DALI motorját.

Egyszerre csak egy Modbus master. Sem a DALI, sem a Modbus RTU busz nem arbitrál egyidejű masterek között. Ha üzembe helyezés közben PLC, BMS vagy PC eszköz (például MODBUSConfigurator) is lekérdezi az átjárót, a rövid cím programozás ütközni fog, és a varázsló hibákat jelent.

Eszközképességek

A sablon egyetlen Modbus modul köré épül — Resi Dali - Konfiguráció —, amely tartalmazza az üzembe helyezési varázslót, egy DALI eszköztípus szondát minden rövid címre 0–63, és négy átjáró szintű műveletet.

Üzembe helyezési varázsló — Find New Devices

A Find New Devices egy tízállapotú multi-value kapcsoló, amely diszkrét lépésekben vezérli a DALI 2.0 véletlen címzési algoritmust. Minden állapotnév egy DALI 2.0 konfigurációs sorozat fázisának felel meg; egy állapot kiválasztása arra készteti a sablont, hogy a megfelelő nyers 16 bites DALI keretet kiküldje a H:541 / H:542-re, majd lekérdezze a DALI RX státuszt a H:550-en az átjáró válaszára.

Lépés	Állapot	Mit csinál
0	TERMINATE	DALI `TERMINATE` keret (`0xA100`) — megszakítja az aktuális címzési munkamenetet és visszaállítja az átjáró állapotát. Mindig biztonságos meghívni
1	Indítás	`INITIALISE` (`0xA5FF`) + `RANDOMISE` (`0xA700`) — minden nem címzett vezérlőt a címzési poolba kapcsol, és mindegyiktől 24 bites véletlen címet kér
2	Rövid cím keresése	A következő rövid cím slot lekérdezése; 7 státuszkódot ad vissza, ha nincs válaszadó vezérlő
3	Set SEARCHADDR	Betölti a felső/középső/alsó SEARCHADDR byteokat (`0xB500/0xB300/0xB100`) a bináris kereséshez
4	COMPARE	Kiküldi a `COMPARE` (`0xA900`)-t, és a válasz alapján szűkíti a 24 bites keresési ablakot
5	PROGRAM SHORT ADDRESS	Kiírja az ellenőrzött rövid címet `0xB7xx`-en keresztül — a vezérlő most állandóan címzett
6	Ellenőrzés	Ellenőrzi a programozott címet egy második `COMPARE`-rel a végső `SEARCHADDRL`-en
7	Újra próbálás	Ütközés / timeout helyreállítás — felezi az aktuális keresési intervallumot és újrapróbál
8	Rövid címek visszaállítása	DALI `DTR = 0xFF` (`0xA3FF`) + broadcast `REMOVE SHORT ADDRESS` — törli az összes létező rövid címet, készen áll a teljes újracímzésre
9	Befejezés	Beolvassa a DALI eredményt, TapHome info/hibaüzenetet bocsát ki, és kilép a varázslóból

Tipikus üzembe helyezési munkafolyamat:

Tápellátást adjon a DALI buszra (RESI-DALI-PS), a vezérlőket fa topológiában vezetékelje, és győződjön meg róla, hogy semmi más nem vezérli a buszt.
(Opcionális, de ajánlott) először futtasson Rövid címek visszaállítása-t, hogy tiszta állapotból induljon, címzett vezérlők nélkül.
Futtasson Indítás-t — ez kiküldi az INITIALISE + RANDOMISE parancsokat, így minden vezérlő új 24 bites véletlen címet választ.
Futtasson Rövid cím keresése → Set SEARCHADDR → COMPARE → PROGRAM SHORT ADDRESS → Ellenőrzés sorozatban. Az állapotok magukba foglalják a DALI 2.0 bináris keresést; minden lépés egy fázissal viszi tovább az algoritmust.
Ha egy lépés ütközést vagy timeoutot jelent, hívja meg az Újra próbálás-t, és futtassa újra a compare/program sorozatot.
Amikor az összes látható vezérlő programozva van, futtasson TERMINATE-et, majd Befejezés-t a varázsló tiszta lezárásához.
Használja a Gear 0 … Gear 63 szervizattribútumokat és a Turn On / Off All Lamps műveleteket annak ellenőrzésére, hogy a 0–N rövid címek most foglaltak (lásd lent).

A varázsló egy állapottal egyszerre való végigjárásra lett tervezve — a sablon nem automatizálja a teljes ciklust, mert a telepítőnek figyelnie kell a DALI busz viselkedését (lámpák pulzálása, STATE LED ritmus az átjárón), hogy észlelje a rosszul bekötött vagy hiányzó vezérlőket.

DALI vezérlő szonda — Gear 0 … Gear 63

A 64 szervizattribútum Gear 0, Gear 1, … Gear 63 mindegyike egy DALI rövid címet vizsgál a DALI 2.0 QUERY DEVICE TYPE paranccsal (0x99). Belsőleg a sablon (SA << 8) | 0x99-t ír a H:511-be, lekérdezi a H:550 0–2 bitjeit válaszig, majd visszaolvassa a válasz byte-ot a H:511-ből.

Lehetséges visszatérési értékek a TapHome szerviz UI-ban:

DT{n} — egy vezérlő van programozva ezen a címen, és n eszköztípussal válaszolt. Tipikus értékek: DT0 (fénycső), DT1 (vészvilágítás), DT2 (HID), DT5 (0–10 V), DT6 (LED driver), DT7 (relé), DT8 (szín / tunable white), DT9 (szekvenszer).
-- — vagy nincs vezérlő programozva ezen a címen, vagy az átjáró a 0x8000 “no answer / already consumed” szentinelt adta vissza.

A szonda gyors pass/fail áttekintést ad arról, hogy mely rövid címek foglaltak üzembe helyezés után, és milyen eszköztípusokat fedezett fel — ez az elsődleges ellenőrzési lépés, mielőtt a projektet átkapcsolná az operatív Resi Dali sablonra.

Átjáró szintű műveletek

Négy szerviz művelet a modulon közvetlenül vezérli az átjárót:

Reset Gateway — 1-et ír a H:6000-be (DIP SWITCH / SOFTWARE RESET). Újraindítja az átjárót; hasznos busz rövidzár után a DALI motor helyreállítására.
Set Slave ID — az új Unit ID-t (1–255) a FLASH H:65221 regiszterbe írja, majd resetel H:6000-en keresztül. A hatályba lépéshez DIP4 = OFF szükséges.
Turn On All Lamps — 0xFE-t ír (arc power 254 = 100 %) a DALI broadcast szint regiszterbe H:530. Minden vezérlőt begyújt a buszon, rövid címtől függetlenül — gyors vizuális megerősítés arról, hogy a busz és a tápegység rendben van.
Turn Off All Lamps — 0x00-t ír a H:530-ba, minden vezérlőt kikapcsol. Ugyanaz a broadcast útvonal, ellentétes érték.

A Slave ID szervizattribútum a modulon visszaolvassa az aktuális Unit ID-t a FLASH H:65221 regiszterből, így a jelenleg programozott cím ellenőrizhető a Set Slave ID küldése előtt.

Futtasson Turn On All Lamps-et közvetlenül a bekötés után, mielőtt elindítaná a címzési varázslót. Minden tápellátott és helyesen csatlakoztatott vezérlő a buszon 100 %-ra megy, ami nagyon gyors módszer a hiányzó vagy rosszul kötött lámpák észlelésére, mielőtt időt fektetne a rövid címek programozásába.

Hibaelhárítás

A varázsló minden lépésnél timeoutra fut

Ellenőrizze a DALI busz feszültségét a tápegység csatlakozóin — 11,5–22,5 V-nak kell lennie (tipikusan 14–16 V). Jelentősen alacsonyabb érték általában DALI rövidzárat jelez.
Ellenőrizze a RESI-DALI-PS ERR LED-jét — ha világít, a busz rövidre van zárva, túlterhelt vagy maga a tápegység hibás.
Ellenőrizze az átjáró STATE LED-jét — lassú 1 másodperces ritmus azt jelenti, hogy a DALI busz rendben van, gyors ~250 ms ritmus busz hibát, rövidzárt vagy hiányzó DALI tápot jelez.
Győződjön meg róla, hogy nem beszél más Modbus master (MODBUSConfigurator, BMS, PLC) egyidejűleg az átjáróval.

A Gear 0–63 mindegyike `--`-t jelent üzembe helyezés után

Mérje meg a DALI feszültséget a tápegységtől legtávolabbi vezérlőn — 9,5 V felett kell lennie. Ha alacsonyabb, a busz túl hosszú a vezető keresztmetszetéhez képest (lásd a DALI kábelhossz táblázatot fent). Ossza a buszt két szegmensre egy második tápegységgel.
Indítsa újra a varázslót a Rövid címek visszaállítása-ról. Ne futtassa az Indítás-t olyan buszon, amely még korábban programozott vezérlőket tartalmaz, ha előbb nem reseteli — az algoritmus csak a rövid cím nélküli vezérlőket találja.
Keressen hurkokat a vezetékezésben. A DALI nem tűri a gyűrűket; szüntessen meg minden hurkot, és zárja le újra mindkét nyitott véget.

A Set Slave ID nem változtatja meg a címet

Erősítse meg, hogy DIP4 = OFF az átjárón. Amikor DIP4 = ON, a hardver 255 Unit ID-t kényszerít a FLASH értéktől függetlenül.
Erősítse meg, hogy az átjáró valóban újraindult a művelet után (az átjáró LED-jei röviden elsötétülnek). Ha nem, indítson manuálisan Reset Gateway-t.
Importálja újra a sablont az új SlaveId importparaméterrel — a korábban importált modul még a régi címen kérdez le.

A kommunikáció rövid ideig működik, majd megszakad

Ellenőrizze, hogy az RS485 GND csatlakozik az átjáró és a TapHome tápegység közös földelése között. A hiányzó GND a leggyakoribb RS-485 hiba.
Ellenőrizze a lezárást — 120 Ω az RS-485 busz mindkét végén. RTU-over-TCP esetén serial hídon keresztül győződjön meg róla, hogy a híd keretezett RTU módban van, nem raw TCP-ben, és hogy a soros oldalon a karakterek közötti rés megfelel a 9600 baud 8N1 időzítésnek.
Csökkentse a párhuzamos DALI lekérdezések számát — az átjáró sorosítja a DALI tranzakciókat, és nem arbitrál több Modbus master között.

Elérhető eszközök

Resi Dali - Konfiguráció Modul

Szerviz attribútumok

Slave ID	Beolvassa a FLASH H:65221 regiszterben tárolt Modbus Unit ID-t — az aktuális átjáró cím ellenőrzésére szolgál
Gear 0	DALI eszköztípus szonda a 0 rövid címen — DT{n} értéket ad vissza, ha egy vezérlő válaszol, vagy -- értéket, ha a cím szabad
Gear 1	DALI eszköztípus szonda a 1 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 2	DALI eszköztípus szonda a 2 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 3	DALI eszköztípus szonda a 3 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 4	DALI eszköztípus szonda a 4 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 5	DALI eszköztípus szonda a 5 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 6	DALI eszköztípus szonda a 6 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 7	DALI eszköztípus szonda a 7 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 8	DALI eszköztípus szonda a 8 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 9	DALI eszköztípus szonda a 9 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 10	DALI eszköztípus szonda a 10 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 11	DALI eszköztípus szonda a 11 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 12	DALI eszköztípus szonda a 12 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 13	DALI eszköztípus szonda a 13 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 14	DALI eszköztípus szonda a 14 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 15	DALI eszköztípus szonda a 15 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 16	DALI eszköztípus szonda a 16 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 17	DALI eszköztípus szonda a 17 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 18	DALI eszköztípus szonda a 18 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 19	DALI eszköztípus szonda a 19 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 20	DALI eszköztípus szonda a 20 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 21	DALI eszköztípus szonda a 21 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 22	DALI eszköztípus szonda a 22 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 23	DALI eszköztípus szonda a 23 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 24	DALI eszköztípus szonda a 24 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 25	DALI eszköztípus szonda a 25 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 26	DALI eszköztípus szonda a 26 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 27	DALI eszköztípus szonda a 27 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 28	DALI eszköztípus szonda a 28 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 29	DALI eszköztípus szonda a 29 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 30	DALI eszköztípus szonda a 30 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 31	DALI eszköztípus szonda a 31 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 32	DALI eszköztípus szonda a 32 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 33	DALI eszköztípus szonda a 33 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 34	DALI eszköztípus szonda a 34 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 35	DALI eszköztípus szonda a 35 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 36	DALI eszköztípus szonda a 36 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 37	DALI eszköztípus szonda a 37 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 38	DALI eszköztípus szonda a 38 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 39	DALI eszköztípus szonda a 39 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 40	DALI eszköztípus szonda a 40 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 41	DALI eszköztípus szonda a 41 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 42	DALI eszköztípus szonda a 42 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 43	DALI eszköztípus szonda a 43 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 44	DALI eszköztípus szonda a 44 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 45	DALI eszköztípus szonda a 45 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 46	DALI eszköztípus szonda a 46 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 47	DALI eszköztípus szonda a 47 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 48	DALI eszköztípus szonda a 48 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 49	DALI eszköztípus szonda a 49 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 50	DALI eszköztípus szonda a 50 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 51	DALI eszköztípus szonda a 51 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 52	DALI eszköztípus szonda a 52 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 53	DALI eszköztípus szonda a 53 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 54	DALI eszköztípus szonda a 54 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 55	DALI eszköztípus szonda a 55 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 56	DALI eszköztípus szonda a 56 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 57	DALI eszköztípus szonda a 57 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 58	DALI eszköztípus szonda a 58 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 59	DALI eszköztípus szonda a 59 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 60	DALI eszköztípus szonda a 60 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 61	DALI eszköztípus szonda a 61 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 62	DALI eszköztípus szonda a 62 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 63	DALI eszköztípus szonda a 63 rövid címen — DT{n} vagy -- értéket ad vissza

Szerviz műveletek

Reset Gateway	1-et ír a H:6000 regiszterbe a RESI-DALI átjáró újraindításához — szükséges a Slave ID megváltoztatása után vagy a DALI motor helyreállításához busz rövidzár után
Set Slave ID	Az új Modbus Unit ID-t a FLASH H:65221 regiszterbe írja, és resetet vált ki, hogy az átjáró az új címmel újrainduljon (1–255, DIP4-nek OFF-nak kell lennie)
Turn On All Lamps	0xFE-t ír a DALI broadcast szint regiszterbe H:530 — minden vezérlőt a buszon maximális fényerőre kapcsol (gyors üzembe helyezési ellenőrzés)
Turn Off All Lamps	0x00-t ír a DALI broadcast szint regiszterbe H:530 — kikapcsol minden vezérlőt a buszon

${resi_dali_configuration}

Szerviz attribútumok

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

Szerviz műveletek

${xml_reset_gateway}

modbusw(SH,6000,uint16,1)

${xml_set_slave_id}

Paraméterek: ${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)

Új eszközök keresése Többértékű kapcsoló

Üzembe helyezési varázsló, amely végigmegy a DALI 2.0 véletlen címzési algoritmuson, hogy rövid címeket (0–63) rendeljen a vezérlőkhöz

Regiszter: H:541 → H:542 UInt16 numeric

Értékek / Állapotok: TERMINATE · ${xml_start} · ${xml_scan_short_address} · Set SEARCHADDR · COMPARE · PROGRAM SHORT ADDRESS · Check · Try again · ${xml_reset_short_addresses} · ${xml_finish}

Új eszközök keresése

Kapcsoló állapot olvasása

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

Kapcsoló állapot írása

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

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

Lehetséges fejlesztések (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

Sablon letöltése

Források

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