TapHome
Magyar
Slovenčina Čeština

Magyar

Italiano Polski Deutsch Română Hrvatski English
Hivatalos · TapHome Világítás

Resi Dali - Konfiguráció

DALI 2.0 üzembe helyezési eszköz a RESI-DALI-SIO és RESI-DALI-ETH Modbus-DALI átjárókhoz. Közvetlenül a TapHome-ból rendel rövid címeket (0–63) a vezérlőkhöz, ellenőrzi jelenlétüket és gyors broadcast ON/OFF teszteket futtat.

ResiModbus RTU1 eszközRevízió 1.3 Utoljára frissítve: 2026. november 15.
Resi Dali - Konfiguráció

Importálás a TapHome alkalmazásbaHardver › Modbus › Hozzáadás sablonból

Sablon letöltése
Ezen az oldalon

Külső átjáró szükséges

Resi RESI-DALI-PS — termékoldal

Integrációs útmutató

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, csoportos tompítás és Gear eszközönkénti diagnosztika. 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 a transzparens RTU-over-Ethernet módban kommunikál az ETH változattal, 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ő keresztmetszetMax 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.

DIP1DIP2Átviteli sebesség
OFFOFF9600 bd (a TapHome által megkövetelt)
ONOFF19200 bd
OFFON38400 bd
ONONA FLASH-be programozott baud rate-et használja (gyári alapérték 57600 bd)
DIP4Modbus Unit ID forrás
OFFFLASH regiszter H:65221 — szükséges ahhoz, hogy a Set Slave ID művelet hatályba lépjen
ONKé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:

  1. Állítsa az átjárón DIP4 = OFF-ra, hogy a FLASH Unit ID érvényesüljön.
  2. Importálja a sablont a TapHome-ba SlaveId = 255-tel (aktuális cím).
  3. 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.
  4. 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, az átjáró információs attribútumait és hét átjáró szintű műveletet.

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

A Find New Devices egy kilencállapotú multi-value kapcsoló, amely állapotgépként 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; a sablon minden állapotban kiküldi a megfelelő nyers 16 bites DALI kereteket a H:541 / H:542-re, lekérdezi a DALI RX státuszt a H:550-en az átjáró válaszára, majd magától a következő állapotba lépteti a kapcsolót.

LépésÁllapotMit csinál
0TERMINATEDALI 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
1IndításINITIALISE (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. A varázsló minden új keresési kör előtt újra kiküldi mindkét parancsot
2Rövid cím kereséseA QUERY CONTROL GEAR PRESENT (0x91) paranccsal lekérdezi a 0–63 rövid címeket, hogy megtalálja a legmagasabb már használt rövid címet, így az új vezérlők az utána következő számokat kapják. A Rövid címek visszaállítása után kimarad — a számozás ekkor 0-tól indul
3Set SEARCHADDREgy lépésben lefuttatja a teljes bináris keresést: betölti a felső/középső/alsó SEARCHADDR byteokat (0xB500/0xB300/0xB100), kiküldi a COMPARE (0xA900)-t, és addig felezi a 24 bites keresési ablakot, amíg le nem szűkül, majd az Ellenőrzés lépéssel folytatja
4COMPAREKiküldi a COMPARE (0xA900)-t, és a válasz alapján szűkíti a 24 bites keresési ablakot
5PROGRAM SHORT ADDRESSKiírja a következő rövid címet 0xB7xx-en keresztül, és ellenőrzi (0xB9xx). Ezután a vezérlő felvillan az új rövid címén (RECALL MIN, RECALL MAX, RECALL MIN), és kilép a keresésből (WITHDRAW, 0xAB00); a varázsló a következő körrel folytatja az Indítás állapottól
6EllenőrzésCOMPARE-rel megerősíti a megtalált véletlen címet a leszűkített ablak alsó és felső határán — egyetlen válasz a PROGRAM SHORT ADDRESS lépéshez vezet, ütközés vagy válasz hiánya az Újra próbálás lépéshez
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; ha az intervallum elfogy, új kör indul INITIALISE + RANDOMISE paranccsal
8BefejezésAkkor áll be, ha három keresési kör egymás után sem programozott új vezérlőt, vagy ha mind a 0–63 rövid cím foglalt. Beolvassa a DALI eredményt, TapHome info/hibaüzenetet bocsát ki (siker esetén Search finished), és kilép a varázslóból

Tipikus üzembe helyezési munkafolyamat:

  1. 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.
  2. (Opcionális, de ajánlott) először futtassa a modul Rövid címek visszaállítása műveletét Confirm = Yes értékkel, hogy tiszta állapotból induljon, címzett vezérlők nélkül.
  3. Válassza az Indítás állapotot — ez kiküldi az INITIALISE + RANDOMISE parancsokat, így minden vezérlő új 24 bites véletlen címet választ.
  4. A kapcsoló ezután magától végighalad a Rövid cím keresése → Set SEARCHADDR → Ellenőrzés → PROGRAM SHORT ADDRESS lépéseken, majd a következő vezérlőhöz visszatér az Indítás állapotba. Minden újonnan programozott vezérlő egyszer felvillan az új rövid címén, így látható, melyik lámpatest melyik címet kapta.
  5. Az ütközéseket és timeoutokat az Újra próbálás automatikusan kezeli, a telepítő beavatkozása nélkül.
  6. Amikor a kapcsoló megáll a Befejezés állapoton, olvassa el az info/hibaüzenetet, majd válassza a TERMINATE állapotot a DALI címzési munkamenet lezárásához.
  7. 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 telepítőnek futás közben továbbra is figyelnie kell a DALI busz viselkedését (a megerősítő felvillanás, 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

Hét 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.
  • Rövid címek visszaállítása — paraméter: Confirm (Yes / No). Yes esetén kiküldi a DTR0 = 0xFF (0xA3FF) parancsot és egy broadcast SET SHORT ADDRESS-t, így a buszon minden vezérlő elveszíti a rövid címét; a varázsló következő futása ezután a 0-s rövid címtől számozza a vezérlőket. No esetén semmi sem kerül kiküldésre.
  • Delete short address — paraméterek: Short address (0–63) és Confirm (Yes / No). A QUERY CONTROL GEAR PRESENT (0x91) paranccsal ellenőrzi, hogy válaszol-e vezérlő a címen, kiküldi a DTR0 = 0xFF és a SET SHORT ADDRESS parancsot erre a címre, majd újra ellenőriz, és ezek egyikét jelenti: Address N deleted, Address N still answers, No gear answers on address N vagy Not confirmed.
  • Change short address — paraméterek: Old short address és New short address (0–63). A QUERY CONTROL GEAR PRESENT paranccsal ellenőrzi, hogy az új cím szabad, és hogy a régi címen pontosan egy vezérlő válaszol, áthelyezi a vezérlőt (DTR0 = új cím, SET SHORT ADDRESS a régi címre), és megerősíti az új címen. Ha a régi címen több vezérlő osztozik, a művelet leáll, és kéri a cím törlését és a címzési varázsló futtatását.

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.

További hat szervizattribútum a modulon az átjáró adatait mutatja: Gateway firmware (H:65202, verzióként és nyers hex értékként), Gateway software group (H:65201), Gateway hardware group (H:65200), Gateway firmware author (H:65203), Gateway DIP switches (H:10009, a DIP 1–4 állapota 1:… 2:… 3:… 4:… formában) és Gateway converter status (H:5050); a csoport-, szerző- és státuszértékek hexben jelennek meg.

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

  1. 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.
  2. 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.
  3. 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.
  4. 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

  1. 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.
  2. Indítsa újra a varázslót a Rövid címek visszaállítása modulművelet után (Confirm = Yes). A keresés csak a rövid cím nélküli vezérlőket találja meg, így a korábban programozott címet még őrző vezérlők nem kapnak új címet, ha előbb nem reseteli őket.
  3. 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

  1. 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.
  2. 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.
  3. 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

  1. 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.
  2. 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.
  3. 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 1

Ezek az eszközök az importálás után jelennek meg a TapHome-ban.

Resi Dali - Konfiguráció Modul
Szerviz attribútumok
Slave IDBeolvassa 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 0DALI 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 1DALI eszköztípus szonda a 1 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 2DALI eszköztípus szonda a 2 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 3DALI eszköztípus szonda a 3 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 4DALI eszköztípus szonda a 4 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 5DALI eszköztípus szonda a 5 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 6DALI eszköztípus szonda a 6 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 7DALI eszköztípus szonda a 7 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 8DALI eszköztípus szonda a 8 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 9DALI eszköztípus szonda a 9 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 10DALI eszköztípus szonda a 10 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 11DALI eszköztípus szonda a 11 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 12DALI eszköztípus szonda a 12 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 13DALI eszköztípus szonda a 13 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 14DALI eszköztípus szonda a 14 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 15DALI eszköztípus szonda a 15 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 16DALI eszköztípus szonda a 16 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 17DALI eszköztípus szonda a 17 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 18DALI eszköztípus szonda a 18 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 19DALI eszköztípus szonda a 19 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 20DALI eszköztípus szonda a 20 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 21DALI eszköztípus szonda a 21 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 22DALI eszköztípus szonda a 22 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 23DALI eszköztípus szonda a 23 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 24DALI eszköztípus szonda a 24 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 25DALI eszköztípus szonda a 25 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 26DALI eszköztípus szonda a 26 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 27DALI eszköztípus szonda a 27 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 28DALI eszköztípus szonda a 28 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 29DALI eszköztípus szonda a 29 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 30DALI eszköztípus szonda a 30 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 31DALI eszköztípus szonda a 31 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 32DALI eszköztípus szonda a 32 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 33DALI eszköztípus szonda a 33 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 34DALI eszköztípus szonda a 34 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 35DALI eszköztípus szonda a 35 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 36DALI eszköztípus szonda a 36 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 37DALI eszköztípus szonda a 37 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 38DALI eszköztípus szonda a 38 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 39DALI eszköztípus szonda a 39 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 40DALI eszköztípus szonda a 40 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 41DALI eszköztípus szonda a 41 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 42DALI eszköztípus szonda a 42 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 43DALI eszköztípus szonda a 43 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 44DALI eszköztípus szonda a 44 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 45DALI eszköztípus szonda a 45 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 46DALI eszköztípus szonda a 46 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 47DALI eszköztípus szonda a 47 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 48DALI eszköztípus szonda a 48 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 49DALI eszköztípus szonda a 49 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 50DALI eszköztípus szonda a 50 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 51DALI eszköztípus szonda a 51 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 52DALI eszköztípus szonda a 52 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 53DALI eszköztípus szonda a 53 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 54DALI eszköztípus szonda a 54 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 55DALI eszköztípus szonda a 55 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 56DALI eszköztípus szonda a 56 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 57DALI eszköztípus szonda a 57 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 58DALI eszköztípus szonda a 58 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 59DALI eszköztípus szonda a 59 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 60DALI eszköztípus szonda a 60 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 61DALI eszköztípus szonda a 61 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 62DALI eszköztípus szonda a 62 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 63DALI eszköztípus szonda a 63 rövid címen — DT{n} vagy -- értéket ad vissza
Gear 58
Gear 59
Gear 60
Gear 61
Gear 62
Gear 63
Szerviz műveletek
Reset Gateway1-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 IDAz ú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 Lamps0xFE-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 Lamps0x00-t ír a DALI broadcast szint regiszterbe H:530 — kikapcsol minden vezérlőt a buszon
${xml_reset_short_addresses}
Delete short address
Change short address

${resi_dali_configuration}

Szerviz attribútumok
${xml_slave_id}
modbusr(H,65221,uint16)
Gateway firmware
var x := modbusr(H, 65202, uint16);
return(getbits(x, 12, 4) + "." + getbits(x, 8, 4) + "." + getbits(x, 0, 8) + " (" + "0x" + tostring(x, "X4") + ")");
Gateway software group
var x := modbusr(H, 65201, uint16);
return("0x" + tostring(x, "X4"));
Gateway hardware group
var x := modbusr(H, 65200, uint16);
return("0x" + tostring(x, "X4"));
Gateway firmware author
var x := modbusr(H, 65203, uint16);
return("0x" + tostring(x, "X4"));
Gateway DIP switches
var x := modbusr(H, 10009, uint16);
return("1:" + getbit(x, 0) + " 2:" + getbit(x, 1) + " 3:" + getbit(x, 2) + " 4:" + getbit(x, 3));
Gateway converter status
var x := modbusr(H, 5050, uint16);
return("0x" + tostring(x, "X4"));
Gear 0
var ShortAddress := 0;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 1
var ShortAddress := 1;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 2
var ShortAddress := 2;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 3
var ShortAddress := 3;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 4
var ShortAddress := 4;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 5
var ShortAddress := 5;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 6
var ShortAddress := 6;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 7
var ShortAddress := 7;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 8
var ShortAddress := 8;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 9
var ShortAddress := 9;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 10
var ShortAddress := 10;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 11
var ShortAddress := 11;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 12
var ShortAddress := 12;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 13
var ShortAddress := 13;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 14
var ShortAddress := 14;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 15
var ShortAddress := 15;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 16
var ShortAddress := 16;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 17
var ShortAddress := 17;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 18
var ShortAddress := 18;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 19
var ShortAddress := 19;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 20
var ShortAddress := 20;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 21
var ShortAddress := 21;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 22
var ShortAddress := 22;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 23
var ShortAddress := 23;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 24
var ShortAddress := 24;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 25
var ShortAddress := 25;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 26
var ShortAddress := 26;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 27
var ShortAddress := 27;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 28
var ShortAddress := 28;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 29
var ShortAddress := 29;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 30
var ShortAddress := 30;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 31
var ShortAddress := 31;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 32
var ShortAddress := 32;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 33
var ShortAddress := 33;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 34
var ShortAddress := 34;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 35
var ShortAddress := 35;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 36
var ShortAddress := 36;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 37
var ShortAddress := 37;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 38
var ShortAddress := 38;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 39
var ShortAddress := 39;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 40
var ShortAddress := 40;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 41
var ShortAddress := 41;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 42
var ShortAddress := 42;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 43
var ShortAddress := 43;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 44
var ShortAddress := 44;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 45
var ShortAddress := 45;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 46
var ShortAddress := 46;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 47
var ShortAddress := 47;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 48
var ShortAddress := 48;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 49
var ShortAddress := 49;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 50
var ShortAddress := 50;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 51
var ShortAddress := 51;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 52
var ShortAddress := 52;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 53
var ShortAddress := 53;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 54
var ShortAddress := 54;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 55
var ShortAddress := 55;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 56
var ShortAddress := 56;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 57
var ShortAddress := 57;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 58
var ShortAddress := 58;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 59
var ShortAddress := 59;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 60
var ShortAddress := 60;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 61
var ShortAddress := 61;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 62
var ShortAddress := 62;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
Gear 63
var ShortAddress := 63;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));
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)
${xml_reset_short_addresses}
Paraméterek: Confirm (Yes / No)
if CONF
    # DTR0 = 0xFF, then SET SHORT ADDRESS to all gear (sent twice): every gear loses its short address
    modbusw(SH, 541, uint16, 0xA3FF);
    sleep(100);
    modbusw(SH, 532, uint16, 0x80);
    SHORTADDR := -1;
    iterator := 64;
end
Delete short address
Paraméterek: Short address (0–63 ADDR), Confirm (Yes / No)
if CONF
    # QUERY CONTROL GEAR PRESENT first: nothing to delete when no gear answers
    var x := 0;
modbusr(SH, 511, uint16);
modbusw(SH, 511, uint16, (ADDR << 8) + 0x91);
sleep(60);
x := modbusr(SH, 511, uint16);
    if x = 0x8000
        return("No gear answers on address " + ADDR);
    end
    # DTR0 = 0xFF (MASK), then SET SHORT ADDRESS to that address (sent twice by the gateway): every gear on it loses the address
    modbusw(SH, 541, uint16, 0xA3FF);
    sleep(100);
    modbusw(SH, 512, uint16, (ADDR << 8) + 0x80);
    sleep(300);
modbusr(SH, 511, uint16);
modbusw(SH, 511, uint16, (ADDR << 8) + 0x91);
sleep(60);
x := modbusr(SH, 511, uint16);
    if x = 0x8000
        return("Address " + ADDR + " deleted");
    end
    return("Address " + ADDR + " still answers (0x" + tostring(x, "X4") + ")");
end
return("Not confirmed");
Change short address
Paraméterek: Old short address (0–63 FROM), New short address (0–63 TO)
if FROM = TO
    return("Old and new address are the same");
end
var x := 0;
# the new address must be free
modbusr(SH, 511, uint16);
modbusw(SH, 511, uint16, (TO << 8) + 0x91);
sleep(60);
x := modbusr(SH, 511, uint16);
if x != 0x8000
    return("Address " + TO + " is already in use");
end
# a gear must answer on the old address; a collision means more gears share it
modbusr(SH, 511, uint16);
modbusw(SH, 511, uint16, (FROM << 8) + 0x91);
sleep(60);
x := modbusr(SH, 511, uint16);
if x = 0x8000
    return("No gear answers on address " + FROM);
end
if x = 0x20FF
    return("More gears answer on address " + FROM + ", delete the address and run the addressing wizard");
end
# DTR0 = new address in the DALI format (2*TO + 1), then SET SHORT ADDRESS to the old address (sent twice by the gateway)
modbusw(SH, 541, uint16, 0xA300 + (TO << 1) + 1);
sleep(100);
modbusw(SH, 512, uint16, (FROM << 8) + 0x80);
sleep(300);
modbusr(SH, 511, uint16);
modbusw(SH, 511, uint16, (TO << 8) + 0x91);
sleep(60);
x := modbusr(SH, 511, uint16);
if x = 0x8000
    return("Change failed, no gear answers on address " + TO);
end
return("Gear moved from address " + FROM + " to " + TO);
Új eszközök keresése Többértékű kapcsoló Olvasás és írás

Ü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_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(8);
    end
    # check SEARCHADDRH
    modbusw(SH, 541, uint16, 0xB500 + getbyte(SEARCHADDRH,0));
    sleep(500);
    modbusw(SH, 541, uint16, 0xB300 + getbyte(SEARCHADDRH,1));
    sleep(500);
    modbusw(SH, 541, uint16, 0xB100 + getbyte(SEARCHADDRH,2));
    sleep(500);
    modbusw(SH, 541, uint16, 0xA900);
    sleep(5); rx := getbits(modbusr(SH, 550, uint16), 0, 2);
    if !rx
        sleep(50);
        rx := getbits(modbusr(SH, 550, uint16), 0, 2);
    end
    if rx
        x := modbusr(SH, 541, uint16);
        if getbyte(x, 0) = 0xFF
            #match: lets check
            return(2);
        else
            return(7);
        end
    else
        return(7);
    end
end
if Mu = 2
    # find max short address
    if SHORTADDR >= 63
        status := 254;
        return(8);
    end
    if iterator >= 64
        status := 10;
        return(3);
    end
    modbusw(SH, 511, uint16, (iterator << 8) + 0x91);
    sleep(5); rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
    x := modbusr(SH, 511, uint16);
    if (x = 0xFF, SHORTADDR := iterator); 
    iterator := iterator + 1;
end
if Mu = 3
    # bisection of SEARCHADDR in one run: SET SEARCHADDR to the middle, COMPARE, keep the half with an answer
    SEARCHADDRM := SEARCHADDRH - ((SEARCHADDRH - SEARCHADDRL) >> 1);
    while SEARCHADDRM != SEARCHADDRH and SEARCHADDRM != SEARCHADDRL
        modbusw(SH, 541, uint16, 0xB500 + getbyte(SEARCHADDRM,0));
        sleep(50);
        modbusw(SH, 541, uint16, 0xB300 + getbyte(SEARCHADDRM,1));
        sleep(50);
        modbusw(SH, 541, uint16, 0xB100 + getbyte(SEARCHADDRM,2));
        sleep(50);
        modbusw(SH, 541, uint16, 0xA900);
        sleep(5); rx := getbits(modbusr(SH, 550, uint16), 0, 2);
        if !rx
            sleep(50);
            rx := getbits(modbusr(SH, 550, uint16), 0, 2);
        end
        if rx
            x := modbusr(SH, 541, uint16);
            # collision or match: the gear is in the lower segment
            SEARCHADDRH := SEARCHADDRM;
        else
            # no response: look in the higher segment
            SEARCHADDRL := SEARCHADDRM;
        end
        SEARCHADDRM := SEARCHADDRH - ((SEARCHADDRH - SEARCHADDRL) >> 1);
    loop
    return(6);
end
if Mu = 4
    # COMPARE
    modbusw(SH, 541, uint16, 0xA900);
    sleep(5); rx := getbits(modbusr(SH, 550, uint16), 0, 2);
    if !rx
        sleep(50);
        rx := getbits(modbusr(SH, 550, uint16), 0, 2);
    end
    if rx
        x := modbusr(SH, 541, uint16);
        #collision or match: lets search the lower segment
        SEARCHADDRH := SEARCHADDRM;
    else
        #no response: lets look up in the higher segment
        SEARCHADDRL := SEARCHADDRM;
    end
    return(3);
end
if Mu = 6
    # check SEARCHADDRL
    modbusw(SH, 541, uint16, 0xB500 + getbyte(SEARCHADDRL,0));
    sleep(50);
    modbusw(SH, 541, uint16, 0xB300 + getbyte(SEARCHADDRL,1));
    sleep(50);
    modbusw(SH, 541, uint16, 0xB100 + getbyte(SEARCHADDRL,2));
    sleep(50);
    modbusw(SH, 541, uint16, 0xA900);
    sleep(5); rx := getbits(modbusr(SH, 550, uint16), 0, 2);
    if !rx
        sleep(50);
        rx := getbits(modbusr(SH, 550, uint16), 0, 2);
    end
    if rx
        x := modbusr(SH, 541, uint16);
        if getbyte(x, 0) = 0xFF
            #exact match: we have it, lets finish
            return(5);
        else
            #collision: 2 gear with same SEARCHADDR or something went wrong, start over
            return(7);
        end
    end
    # check SEARCHADDRH
    modbusw(SH, 541, uint16, 0xB500 + getbyte(SEARCHADDRH,0));
    sleep(50);
    modbusw(SH, 541, uint16, 0xB300 + getbyte(SEARCHADDRH,1));
    sleep(50);
    modbusw(SH, 541, uint16, 0xB100 + getbyte(SEARCHADDRH,2));
    sleep(50);
    modbusw(SH, 541, uint16, 0xA900);
    sleep(5); rx := getbits(modbusr(SH, 550, uint16), 0, 2);
    if !rx
        sleep(50);
        rx := getbits(modbusr(SH, 550, uint16), 0, 2);
    end    
    if rx
        x := modbusr(SH, 541, uint16);
        if getbyte(x, 0) = 0xFF
            #exact match: we have it, lets finish
            return(5);
        else
            #collision: 2 gear with same SEARCHADDR or something went wrong, start over
            return(7);
        end
    else
        #no response: something went wrong, finish with error
        status := 220;
        #return(8);
        return(7);
    end
end
if Mu = 5
	exit := 3;
    # PROGRAM SHORT ADDRESS
    SHORTADDR := SHORTADDR + 1;
    #program
    modbusw(SH, 542, uint16, 0xB701 + (SHORTADDR << 1));
    sleep(100);
    #verify
    modbusw(SH, 541, uint16, 0xB901 + (SHORTADDR << 1));
    sleep(5); rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
    x := modbusr(SH, 541, uint16);
    if getbyte(x, 0) = 0xFF
        status := 0;
    else
        status := 230;
        #return(8);
        SHORTADDR := SHORTADDR - 1;
        return(7);
    end
    #blink
    # blink the new address: RECALL MIN, RECALL MAX, RECALL MIN (short address in the upper byte)
    modbusw(SH, 511, uint16, (SHORTADDR << 8) + 0x06);
    sleep(500);
    modbusw(SH, 511, uint16, (SHORTADDR << 8) + 0x05);
    sleep(500);
    modbusw(SH, 511, uint16, (SHORTADDR << 8) + 0x06);
    #WITHDRAW
    modbusw(SH, 541, uint16, 0xAB00);
    sleep(100);
    SEARCHADDRH := 0xFFFFFF;
    SEARCHADDRL := 0;
    # a new search round needs a fresh 15-minute DALI window: INITIALISE (gear without short address) and RANDOMISE again
    modbusw(SH, 542, uint16, 0xA5FF);
    sleep(100);
    modbusw(SH, 542, uint16, 0xA700);
    sleep(100);
    return(1);
end
if Mu = 8
    # finish (state 8 since the short address reset moved to a module service action)
    # finish
    if(status = 99, adderror("Timeout!"));
    if(status = 220, adderror("Check failed! (" + tostring(SEARCHADDRH, "X2") + " | " + tostring(SEARCHADDRL, "X2") + " )"));
    if(status = 230, adderror("Verify short address failed! (" + tostring(SHORTADDR, "X2") + " | " + tostring(x, "X2") + 
        " | " + tostring(SEARCHADDRH, "X2") + " | " + tostring(SEARCHADDRM, "X2") + " | " + tostring(SEARCHADDRL, "X2") + " )"));
    if(status = 231, adderror("Short address mismatch! (" + tostring(SHORTADDR, "X2") + " | " + tostring(x, "X2") + " )"));
    if(status = 254, adderror("All short addresses are in use!"));
    if status = 255
        modbusw(SH, 531, uint16, 0x96);
        sleep(5); rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
        x := modbusr(SH, 531, uint16);
        if getbyte(x, 0) = 0xFF
            adderror("Some gear is still missing short address, but no response from SEARCHADDRH! ( " + tostring(SEARCHADDRH, "X2") + " )");
        else    
            status := 1;
        end
    end
    if(status = 1, addinfo("Search finished")); 
    if(status = 200 or status = 230 or status = 231 or status = 254, iterator := 0); 
end
#debug
#if(Mu = 7, addinfo("Debug:" + tostring(x, "X2") + " | " + status),0);

#if(Mu = 1, status := "rx:" + getbits(y, 0, 2) + "|" + getbits(y, 4, 1) + "|" + getbits(y, 5, 1), 0);
#if(Mu = 1, return(7),0);
if Mu = 7
	if SEARCHADDRH = SEARCHADDRL
    	SEARCHADDRH := 0xFFFFFF;
    	SEARCHADDRL := 0;
    	exit := exit -1;
        # a new search round needs a fresh 15-minute DALI window: INITIALISE (gear without short address) and RANDOMISE again
        modbusw(SH, 542, uint16, 0xA5FF);
        sleep(100);
        modbusw(SH, 542, uint16, 0xA700);
        sleep(100);
        return(1);
    end
	SEARCHADDRH := SEARCHADDRH >> 1;
	SEARCHADDRL := 0;
	if(iterator < 64, SHORTADDR := -1);
	if(iterator < 64, iterator := 0);    
    # check SEARCHADDRH
    modbusw(SH, 541, uint16, 0xB500 + getbyte(SEARCHADDRH,0));
    sleep(500);
    modbusw(SH, 541, uint16, 0xB300 + getbyte(SEARCHADDRH,1));
    sleep(500);
    modbusw(SH, 541, uint16, 0xB100 + getbyte(SEARCHADDRH,2));
    sleep(500);
    modbusw(SH, 541, uint16, 0xA900);
    sleep(5); rx := getbits(modbusr(SH, 550, uint16), 0, 2);
    if !rx
        sleep(50);
        rx := getbits(modbusr(SH, 550, uint16), 0, 2);
    end
    if rx
        x := modbusr(SH, 541, uint16);
        if getbyte(x, 0) = 0xFF
            #match: lets check
            return(2);
        else
            return(6);
        end
    else
        return(6);
    end
end
return(Mu);
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 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

Importálási paraméterek

Ezeket az értékeket az XML importálásakor adja meg.

Az alkalmazás kériAlapérték
Slave ID255
IP-cím192.168.1.0

Források

A gyártói dokumentumok © a mindenkori tulajdonosaikat illetik. A gyártó által közzétett formában, kizárólag tájékoztatásul tesszük elérhetővé őket.

Kapcsolódó dokumentáció

Talált problémát ezzel az eszközsablonnal?

Írja meg, mi nem működik, mi hiányzik, vagy hogyan kellene a sablonnak viselkednie. Visszajelzése segít, hogy a katalógus pontos maradjon.

Sablon · TapHome portál Resi Dali - Konfiguráció Nyisd meg ezt a sablont az ügyfélportálon, hogy alkalmazd az otthonaid egyikére, vagy készíts egy módosítást és küldd vissza a katalógusba. Modbus RTU Megnyitás a TapHome portálon