--- title: "Resi Dali - Konfiguráció" description: "DALI 2.0 üzembe helyezés RESI-DALI-SIO/ETH átjárón TapHome-ból: rövid címek 0–63 kiosztása, eszköztípus lekérdezés, broadcast tesztek Modbuson." url: "https://taphome.com/hu/compatibility/resi-dali-daliconfig/" language: hu lastmod: 2026-11-15 generator: hugo ai: topics: ["modbus-rtu","lighting","dali","dali-2.0","rs485","din-rail","commissioning","addressing","gateway"] questions: ["Hogyan rendelhetek DALI rövid címeket a TapHome-ból?","Hogyan helyezhetem üzembe a DALI 2.0 vezérlőket a RESI-DALI-SIO átjáróval?","Mit csinál a Resi Dali - Konfiguráció sablon a TapHome-ban?","Hogyan állíthatom be a Modbus Slave ID-t egy RESI-DALI-SIO / RESI-DALI-ETH eszközön?","Hogyan vezetékezhetem a RESI-DALI-SIO-t egy DALI buszra RESI-DALI-PS tápegységgel?","Mi a különbség a Resi Dali - Konfiguráció és az operatív Resi Dali sablonok között?","Miért van IP-cím importparamétere a DaliConfig sablonnak egy RTU átjárón?"] --- # Resi Dali - Konfiguráció Kommunikáció: Modbus RTU - [RESI-DALI-SIO/ETH/PS termékoldal](https://www.resi.cc/prestashop/en/home/1-resi-dali-sioethps.html) - [RESI Informatik & Automation](https://www.resi.cc) ## 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. > [!NOTE] > 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)](https://taphome.com/images/compatibility/resi-dali-daliconfig/wiring-sio_hu_1af043ee91b2b0ed.jpg) 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)](https://taphome.com/images/compatibility/resi-dali-daliconfig/wiring-eth_hu_4bf0a5e8d8724d0b.jpg) 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)](https://taphome.com/images/compatibility/resi-dali-daliconfig/wiring-dali-ps_hu_bea720a419338afa.jpg) 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). > [!WARNING] > **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: 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. > [!WARNING] > **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 | Á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. A varázsló minden új keresési kör előtt újra kiküldi mindkét parancsot | | 2 | **Rövid cím keresése** | A `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 | | 3 | **Set SEARCHADDR** | Egy 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 | | 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 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 | | 6 | **Ellenőrzés** | `COMPARE`-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 | | 8 | **Befejezés** | Akkor á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. > [!TIP] > 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 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 | | Gear 58 | | | Gear 59 | | | Gear 60 | | | Gear 61 | | | Gear 62 | | | Gear 63 | | 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 | | ${xml\_reset\_short\_addresses} | | | Delete short address | | | Change short address | | Szerviz attribútumok ${xml\_slave\_id} ```taphome modbusr(H,65221,uint16) ``` Gateway firmware ```taphome 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 ```taphome var x := modbusr(H, 65201, uint16); return("0x" + tostring(x, "X4")); ``` Gateway hardware group ```taphome var x := modbusr(H, 65200, uint16); return("0x" + tostring(x, "X4")); ``` Gateway firmware author ```taphome var x := modbusr(H, 65203, uint16); return("0x" + tostring(x, "X4")); ``` Gateway DIP switches ```taphome 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 ```taphome var x := modbusr(H, 5050, uint16); return("0x" + tostring(x, "X4")); ``` Gear 0 ```taphome 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 ```taphome 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 ```taphome 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 ```taphome 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 ```taphome 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 ```taphome 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 ```taphome 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 ```taphome 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 ```taphome 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 ```taphome 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 ```taphome 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 ```taphome 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 ```taphome 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 ```taphome 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 ```taphome 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 ```taphome 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 ```taphome 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 ```taphome 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 ```taphome 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 ```taphome 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 ```taphome 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 ```taphome 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 ```taphome 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 ```taphome 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 ```taphome 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 ```taphome 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 ```taphome 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 ```taphome 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 ```taphome 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 ```taphome 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 ```taphome 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 ```taphome 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 ```taphome 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 ```taphome 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 ```taphome 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 ```taphome 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 ```taphome 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 ```taphome 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 ```taphome 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 ```taphome 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 ```taphome 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 ```taphome 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 ```taphome 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 ```taphome 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 ```taphome 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 ```taphome 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 ```taphome 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 ```taphome 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 ```taphome 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 ```taphome 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 ```taphome 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 ```taphome 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 ```taphome 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 ```taphome 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 ```taphome 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 ```taphome 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 ```taphome 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 ```taphome 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 ```taphome 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 ```taphome 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 ```taphome 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 ```taphome 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 ```taphome 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 ```taphome 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} ```taphome modbusw(SH,6000,uint16,1) ``` ${xml\_set\_slave\_id} Paraméterek: ${xml\_slave\_id} (1–255 SID) ```taphome modbusw(SH, 65221, uint16, SID); modbusw(SH,6000, uint16, 1); ``` ${xml\_turn\_on\_all\_lamps} ```taphome modbusw(SH, 530, uint16, 0xFE) ``` ${xml\_turn\_off\_all\_lamps} ```taphome modbusw(SH, 530, uint16, 0x00) ``` ${xml\_reset\_short\_addresses} Paraméterek: Confirm (Yes / No) ```taphome 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) ```taphome 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) ```taphome 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} Kapcsoló állapot olvasása ```taphome 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 ```taphome # 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éri | Alapérték | |--------------------|---------------| | Slave ID | `255` | | IP-cím | `192.168.1.0` | ## Források - RESI-DALI-SIO/ETH Modbus & ASCII protocol reference [www.resi.cc](https://www.resi.cc/resi/docs/RESI-L-DALI-SIO,ETH-MODBUS+ASCII-EN.pdf) 2026-04-15 [PDF](https://taphome.com/compatibility/devices/resi-dali-daliconfig/manufacturer/RESI-L-DALI-SIO,ETH-MODBUS+ASCII-EN.pdf) - RESI-xxx-SIO, RESI-xxx-ETH hardware & software manual (DALI chapter) [www.resi.cc](https://www.resi.cc/resi/docs/RESI-M-xxx-SIO-ETH-EN.pdf) 2026-04-15 [PDF](https://taphome.com/compatibility/devices/resi-dali-daliconfig/manufacturer/RESI-M-xxx-SIO-ETH-EN.pdf) - RESI-DALI-SIO datasheet (GW-28) [www.resi.cc](https://www.resi.cc/resi/catalog/files/RESI-CATALOG-GATEWAYS-EN-Pages/RESI-CATALOG-GATEWAYS-EN-GW-28-RESI-DALI-SIO.pdf) 2026-04-15 [PDF](https://taphome.com/compatibility/devices/resi-dali-daliconfig/manufacturer/RESI-CATALOG-GATEWAYS-EN-GW-28-RESI-DALI-SIO.pdf) - RESI-DALI-ETH datasheet (GW-29) [www.resi.cc](https://www.resi.cc/resi/catalog/files/RESI-CATALOG-GATEWAYS-EN-Pages/RESI-CATALOG-GATEWAYS-EN-GW-29-RESI-DALI-ETH.pdf) 2026-04-15 [PDF](https://taphome.com/compatibility/devices/resi-dali-daliconfig/manufacturer/RESI-CATALOG-GATEWAYS-EN-GW-29-RESI-DALI-ETH.pdf) - RESI-DALI-PS datasheet (GW-30) [www.resi.cc](https://www.resi.cc/resi/catalog/files/RESI-CATALOG-GATEWAYS-EN-Pages/RESI-CATALOG-GATEWAYS-EN-GW-30-RESI-DALI-PS.pdf) 2026-04-15 [PDF](https://taphome.com/compatibility/devices/resi-dali-daliconfig/manufacturer/RESI-CATALOG-GATEWAYS-EN-GW-30-RESI-DALI-PS.pdf) - RESI-DALI-SIO,ETH,PS product page [www.resi.cc](https://www.resi.cc/prestashop/en/home/1-resi-dali-sioethps.html) 2026-04-15 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ó - [Modbus Integration](https://taphome.com/hu/compatibility/modbus-guide/) - [Modbus útmutató a TapHome készülékekhez](https://taphome.com/hu/docs/integration/modbus/) - [Egyszerű konfiguráció sablonok használatával](https://taphome.com/hu/docs/integration/modbus/templates/) - [Modbus szkriptek és prefetch](https://taphome.com/hu/docs/script/modbus-scripts/) - [Modbus függvények](https://taphome.com/hu/docs/script/modbus/) - [Modbus adattípusok](https://taphome.com/hu/docs/script/modbus-data-types/)