--- title: "Resi Dali - Konfiguracja" description: "Uruchom urządzenia DALI 2.0 na bramce RESI-DALI-SIO/ETH z TapHome: przydziel krótkie adresy 0–63, sprawdź device type, testy broadcast przez Modbus." url: "https://taphome.com/pl/compatibility/resi-dali-daliconfig/" language: pl lastmod: 2026-11-15 generator: hugo ai: topics: ["modbus-rtu","lighting","dali","dali-2.0","rs485","din-rail","commissioning","addressing","gateway"] questions: ["Jak przydzielić krótkie adresy DALI z TapHome?","Jak uruchomić urządzenia sterujące DALI 2.0 z bramką RESI-DALI-SIO?","Co robi szablon Resi Dali - Konfiguracja w TapHome?","Jak ustawić Modbus Slave ID na RESI-DALI-SIO / RESI-DALI-ETH?","Jak podłączyć RESI-DALI-SIO do magistrali DALI z zasilaczem RESI-DALI-PS?","Jaka jest różnica między szablonami Resi Dali - Konfiguracja i operacyjnym Resi Dali?","Dlaczego szablon DaliConfig ma parametr importu IP address na bramce RTU?"] --- # Resi Dali - Konfiguracja Komunikacja: Modbus RTU - [Strona produktu RESI-DALI-SIO/ETH/PS](https://www.resi.cc/prestashop/en/home/1-resi-dali-sioethps.html) - [RESI Informatik & Automation](https://www.resi.cc) ## Poradnik integracji Szablon **Resi Dali - Konfiguracja** to jednorazowe **narzędzie uruchomieniowe i adresowania** dla bramki Modbus-DALI RESI-DALI-SIO i RESI-DALI-ETH firmy RESI Informatik & Automation GmbH. Steruje algorytmem losowego adresowania DALI 2.0 bezpośrednio z TapHome, przydzielając krótkie adresy 0–63 urządzeniom sterującym na świeżo okablowanej magistrali DALI, na każdym adresie sonduje typ urządzenia DALI (device type) i oferuje szybkie testy broadcast ON/OFF — wszystko, co jest potrzebne do doprowadzenia nowej instalacji do stanu, w którym lampy mogą być sterowane indywidualnie. Komunikacja z bramką odbywa się przez Modbus RTU z prędkością 9600 baud 8N1. Szablon udostępnia także parametr importu `IpAddress`, więc ten sam przepływ działa przez serial-to-IP bridge (Moxa NPort, USR-TCP232) lub RESI-DALI-ETH skonfigurowany w trybie transparentnym RTU-over-Ethernet. > [!NOTE] > Ten szablon jest celowo przeznaczony **wyłącznie do adresowania**. Po przydzieleniu krótkich adresów usuń moduł Resi Dali - Konfiguracja z projektu i do codziennej kontroli użyj siostrzanego operacyjnego szablonu **Resi DALI** (`Dali.xml`) — ściemnianie pojedynczych lamp, ściemnianie grup i diagnostyka poszczególnych urządzeń Gear. Moduł konfiguracyjny nie jest zaprojektowany tak, by pozostać w projekcie po wstępnej konfiguracji. ## Połączenia sprzętowe RESI-DALI-SIO to bramka master na szynę DIN (17,5 × 90 × 56,4 mm, CEM17), która znajduje się pomiędzy hostem szeregowym/Ethernet a magistralą oświetleniową DALI. Bramka **nie zasila magistrali DALI** — kompatybilny zasilacz DALI (RESI-DALI-PS lub dowolny zgodny ze standardem zasilacz DALI 200 mA) jest wymagany. ### Podłączenie RESI-DALI-SIO (RS-485) ![Schemat podłączenia RESI-DALI-SIO — zewnętrzny zasilacz DALI (góra) i z RESI-DALI-PS (dół)](https://taphome.com/images/compatibility/resi-dali-daliconfig/wiring-sio_hu_1af043ee91b2b0ed.jpg) Zaciski po lewej stronie RESI-DALI-SIO (od góry do dołu): `GND`, `+12..48V=`, `RS485 DATA+ (A+)`, `RS485 DATA- (B-)`, `RS485 GND`, `RS232 TX`, `RS232 RX`, `RS232 GND`. Zaciski magistrali DALI po przeciwnej stronie to **`D+ / N/C / D-`** (3-pinowy blok USLIM, `N/C` pozostaje niepodłączony). Do instalacji TapHome użyj interfejsu RS-485: - `RS485 DATA+ (A+)` → A+/D+ na magistrali RS-485 TapHome - `RS485 DATA- (B-)` → B-/D- na magistrali RS-485 TapHome - `RS485 GND` → GND na zasilaczu TapHome (zalecane dla stabilnej komunikacji) - `+12..48V=` / `GND` → zasilanie pierwotne 12–48 V DC ### Podłączenie RESI-DALI-ETH (Ethernet) ![Schemat podłączenia RESI-DALI-ETH — zewnętrzny zasilacz DALI (góra) i z RESI-DALI-PS (dół)](https://taphome.com/images/compatibility/resi-dali-daliconfig/wiring-eth_hu_4bf0a5e8d8724d0b.jpg) Wariant Ethernet ma te same zaciski magistrali DALI (`D+ / N/C / D-`) i zasilanie pierwotne (`GND`, `+12..48V=`) oraz pojedyncze złącze RJ45 dla Ethernet 10/100 Mbit. Fabryczne domyślne ustawienia IP to **192.168.0.191 / 255.255.255.0 / 192.168.0.1** z Modbus Unit ID 255; poświadczenia UI sieci web to `RESI` / `RESI`. TapHome komunikuje się z wariantem ETH w transparentnym trybie RTU-over-Ethernet, którego oczekuje ten szablon konfiguracyjny (patrz Konfiguracja poniżej). ### Zasilacz magistrali DALI ![RESI-DALI-PS — samodzielne zasilanie magistrali DALI (góra) i w połączeniu z bramką SIO/ETH (dół)](https://taphome.com/images/compatibility/resi-dali-daliconfig/wiring-dali-ps_hu_bea720a419338afa.jpg) RESI-DALI-PS dostarcza do **200 mA** na magistralę DALI (prąd zwarcia ~225 mA, typowe napięcie magistrali 14–18 V) i obsługuje do 64 stateczników DALI 1.0 lub urządzeń sterujących DALI 2.0 na pojedynczej linii. Strona pierwotna akceptuje to samo zasilanie 12–48 V DC co jednostka SIO/ETH. Bramka i zasilacz korzystają z tej samej pary `D+` / `D-` — zasilacz energizuje magistralę, podczas gdy bramka odczytuje i zapisuje ramki DALI. Trzy diody LED na zasilaczu pomagają podczas uruchamiania: **POWER** (pierwotne 12–48 V OK, zawsze świeci), **DALI** (krótko miga podczas ruchu na magistrali), **ERR** (świeci stale przy awarii zasilacza, zwarciu DALI lub przeciążeniu magistrali — podczas normalnej pracy musi być zgaszona). ### Reguły magistrali DALI Linia DALI narzuca kilka ścisłych ograniczeń, które bezpośrednio wpływają na powodzenie uruchamiania: | Przekrój przewodu | Maks. długość kabla DALI | |-------------------|-------------------------| | 1,5 mm² | 300 m | | 1,0 mm² | 238 m | | 0,75 mm² | 174 m | | 0,5 mm² | 116 m | Limit wynika z maksymalnego dopuszczalnego **spadku napięcia 2 V** na kablu DALI. Inne reguły: - Maksymalnie 64 stateczniki DALI 1.0 **i** do 64 urządzenia sterujące DALI 2.0 na magistralę (oddzielne przestrzenie krótkich adresów). - Tylko topologia drzewa — bez pierścieni, bez pętli. - Rzeczywista liczba urządzeń zależy także od wydajności prądowej zasilacza (typowo 200 mA na RESI-DALI-PS, licz ~2 mA na urządzenie plus rezerwa). > [!WARNING] > **RESI-DALI-PS (lub równoważny zasilacz DALI) jest wymagany.** Bez niego RESI-DALI-SIO/ETH nie może sterować magistralą, a kreator uruchomieniowy będzie wypadać timeoutem na każdym kroku. Jeśli na długiej linii używany jest drugi zasilacz, wstaw dławik DALI lub podziel magistralę na segmenty galwanicznie odseparowane. ## Konfiguracja ### Włączenie komunikacji Modbus Wszystkie parametry portu szeregowego hosta na RESI-DALI-SIO wybiera się 4-pozycyjnym przełącznikiem DIP na module. Szablon TapHome wymusza **9600 baud 8N1**, więc przełączniki DIP muszą być odpowiednio ustawione. | DIP1 | DIP2 | Prędkość transmisji | |------|------|--------------------| | **OFF** | **OFF** | **9600 bd (wymagane przez TapHome)** | | ON | OFF | 19200 bd | | OFF | ON | 38400 bd | | ON | ON | Używa prędkości baud zaprogramowanej we FLASH (fabryczne 57600 bd) | | DIP4 | Źródło Modbus Unit ID | |------|----------------------| | **OFF** | Rejestr FLASH `H:65221` — wymagane, aby akcja **Set Slave ID** miała efekt | | ON | Wymuszone na `255` (sprzętowy fallback, wartość FLASH ignorowana) | `DIP3` to bit zarezerwowany specyficzny dla produktu; pozostaw go w fabrycznej pozycji, chyba że instrukcja serwisowa RESI wyraźnie nakazuje inaczej. Parzystość jest stała `None` (8N1) w domyślnych wartościach FLASH — szablon nie udostępnia rejestrów parzystości/bitu stop. **Terminacja RS-485:** zakończ magistralę rezystorem 120 Ω na obu końcach. TapHome Core zapewnia jedną terminację na swoich zaciskach BUS; jeśli bramka RESI jest ostatnim urządzeniem na linii, dodaj dyskretny rezystor 120 Ω między `A+`/`B-` na jej zaciskach RS-485. **Konfiguracja RTU-over-TCP:** szablon ma zarówno parametry importu `SlaveId`, jak i `IpAddress`, ponieważ ten sam przepływ konfiguracji DALI działa również przez **serial-to-IP bridge** (Moxa NPort, USR-TCP232) lub **RESI-DALI-ETH w transparentnym trybie RTU-over-Ethernet**. W takim przypadku skieruj `IpAddress` na IP bridge'a / jednostki ETH i pozostałe ustawienia pozostaw identyczne jak w wariancie RS-485. Dla czystego Modbus/TCP na RESI-DALI-ETH bardziej naturalny byłby szablon oparty na TCP — szablon DaliConfig zakłada konkretnie ruch RTU w ramkach. ### Ustawianie Slave ID bramki Fabryczny domyślny Unit ID to **255**. Aby go zmienić: 1. Ustaw na bramce `DIP4 = OFF`, aby FLASH Unit ID był honorowany. 2. Zaimportuj szablon w TapHome z `SlaveId = 255` (aktualny adres). 3. Otwórz ustawienia serwisowe modułu "Resi Dali - Konfiguracja" i uruchom akcję **Set Slave ID** z pożądanym nowym ID (zakres 1–255). Akcja zapisuje wartość do rejestru `H:65221` i natychmiast wyzwala programowy reset przez `H:6000 = 1`, więc bramka restartuje z nowym adresem. 4. Usuń szablon i zaimportuj go ponownie z `SlaveId` ustawionym na nową wartość. Moduł można wtedy używać do uruchamiania. Akcja **Reset Gateway** (zapisuje `1` do `H:6000`) jest również dostępna jako samodzielny krok naprawczy — przydatny po zwarciu magistrali DALI, które pozostawiło silnik DALI bramki w zdegradowanym stanie. > [!WARNING] > **Tylko jeden master Modbus naraz.** Ani DALI, ani magistrala Modbus RTU nie arbitrują między równoległymi masterami. Jeśli podczas uruchamiania PLC, BMS lub narzędzie PC (na przykład MODBUSConfigurator) także odpytuje bramkę, programowanie krótkich adresów będzie kolidować, a kreator zgłosi błędy. ## Możliwości urządzenia Szablon jest zbudowany wokół pojedynczego modułu Modbus — *Resi Dali - Konfiguracja* — który łączy kreator uruchomieniowy, sondę typu urządzenia DALI dla każdego krótkiego adresu 0–63, atrybuty z informacjami o bramce i siedem akcji na poziomie bramki. ### Kreator uruchomieniowy — Find New Devices *Find New Devices* to dziewięciostanowy przełącznik multi-value, który steruje algorytmem losowego adresowania DALI 2.0 jako maszyną stanów. Każda nazwa stanu odpowiada jednej fazie sekwencji konfiguracyjnej DALI 2.0; w każdym stanie szablon wysyła odpowiednie surowe 16-bitowe ramki DALI na `H:541` / `H:542`, odpytuje status DALI RX na `H:550` o odpowiedź bramki, a następnie sam przestawia przełącznik na następny stan. | Krok | Stan | Co robi | |------|------|---------| | 0 | **TERMINATE** | Ramka DALI `TERMINATE` (`0xA100`) — przerywa bieżącą sesję adresowania i resetuje stan bramki. Zawsze bezpieczne do wywołania | | 1 | **Start** | `INITIALISE` (`0xA5FF`) + `RANDOMISE` (`0xA700`) — przełącza wszystkie nieadresowane urządzenia do puli adresowania i prosi każde o wybranie 24-bitowego adresu losowego. Kreator wysyła oba polecenia ponownie przed każdą nową rundą wyszukiwania | | 2 | **Skanuj krótki adres** | Odpytuje krótkie adresy 0–63 poleceniem `QUERY CONTROL GEAR PRESENT` (`0x91`), aby znaleźć najwyższy już używany krótki adres, dzięki czemu nowe urządzenia są numerowane po nim. Pomijany po **Resetuj krótkie adresy** — numeracja zaczyna się wtedy od 0 | | 3 | **Set SEARCHADDR** | Wykonuje całe wyszukiwanie binarne w jednym kroku: ładuje górne/środkowe/dolne bajty SEARCHADDR (`0xB500/0xB300/0xB100`), wysyła `COMPARE` (`0xA900`) i połowi 24-bitowe okno wyszukiwania, aż zostanie zawężone, po czym przechodzi do **Sprawdź** | | 4 | **COMPARE** | Wysyła `COMPARE` (`0xA900`) i zawęża 24-bitowe okno wyszukiwania na podstawie odpowiedzi | | 5 | **PROGRAM SHORT ADDRESS** | Zapisuje następny krótki adres przez `0xB7xx` i weryfikuje go (`0xB9xx`). Urządzenie następnie miga na swoim nowym krótkim adresie (`RECALL MIN`, `RECALL MAX`, `RECALL MIN`) i opuszcza wyszukiwanie (`WITHDRAW`, `0xAB00`); kreator kontynuuje następną rundą od **Start** | | 6 | **Sprawdź** | Potwierdza znaleziony adres losowy poleceniem `COMPARE` na dolnym i górnym końcu zawężonego okna — pojedyncza odpowiedź prowadzi do **PROGRAM SHORT ADDRESS**, kolizja lub brak odpowiedzi do **Spróbuj ponownie** | | 7 | **Spróbuj ponownie** | Odzyskiwanie po kolizji / timeoucie — połowi aktualny interwał wyszukiwania i ponawia; gdy interwał się wyczerpie, rozpoczyna się nowa runda z `INITIALISE` + `RANDOMISE` | | 8 | **Zakończ** | Osiągany po trzech rundach wyszukiwania bez nowo zaprogramowanego urządzenia lub gdy wszystkie krótkie adresy 0–63 są zajęte. Odczytuje bajt wyniku DALI, emituje wiadomość info/błąd TapHome (`Search finished` w przypadku powodzenia) i opuszcza kreator | **Typowy przepływ uruchamiania:** 1. Zasil magistralę DALI (`RESI-DALI-PS`), okabluj urządzenia w topologii drzewa i upewnij się, że nic innego nie steruje magistralą. 2. (Opcjonalnie, ale zalecane) najpierw uruchom akcję modułu **Resetuj krótkie adresy** z *Confirm* = *Yes*, aby rozpocząć od czystego stanu bez adresowanych urządzeń. 3. Wybierz **Start** — wysyła `INITIALISE` + `RANDOMISE`, więc każde urządzenie wybiera nowy 24-bitowy losowy adres. 4. Przełącznik następnie sam przechodzi przez **Skanuj krótki adres** → **Set SEARCHADDR** → **Sprawdź** → **PROGRAM SHORT ADDRESS** i wraca do **Start** dla następnego urządzenia. Każde nowo zaprogramowane urządzenie mignie raz na swoim nowym krótkim adresie, co pokazuje, która oprawa otrzymała który adres. 5. Kolizje i timeouty obsługuje **Spróbuj ponownie** automatycznie, bez żadnej ingerencji instalatora. 6. Gdy przełącznik zatrzyma się na **Zakończ**, odczytaj wiadomość info/błąd, a następnie wybierz **TERMINATE**, aby zamknąć sesję adresowania DALI. 7. Użyj atrybutów serwisowych **Gear 0 … Gear 63** i akcji **Turn On / Off All Lamps** do weryfikacji, że krótkie adresy 0–N są teraz zapełnione (patrz poniżej). Instalator nadal musi obserwować zachowanie magistrali DALI podczas przebiegu (mignięcie potwierdzające, rytm LED `STATE` na bramce), aby wychwycić źle podłączone lub brakujące urządzenia. ### Sonda DALI gear — Gear 0 … Gear 63 Każdy z 64 atrybutów serwisowych **Gear 0**, **Gear 1**, … **Gear 63** sonduje jeden krótki adres DALI poleceniem DALI 2.0 `QUERY DEVICE TYPE` (`0x99`). Wewnętrznie szablon zapisuje `(SA << 8) | 0x99` do `H:511`, odpytuje bity 0–2 `H:550` aż do nadejścia odpowiedzi, następnie odczytuje bajt odpowiedzi z `H:511`. Możliwe wartości zwracane w interfejsie serwisowym TapHome: - **`DT{n}`** — urządzenie sterujące jest zaprogramowane na tym adresie i odpowiedziało typem urządzenia *n*. Typowe wartości: `DT0` (fluorescencyjne), `DT1` (awaryjne), `DT2` (HID), `DT5` (0–10 V), `DT6` (sterownik LED), `DT7` (przekaźnik), `DT8` (kolor / tunable white), `DT9` (sekwencer). - **`--`** — żadne urządzenie nie jest zaprogramowane na tym adresie lub bramka zwróciła sentinel `0x8000` "no answer / already consumed". Sonda zapewnia szybki przegląd pass/fail, które krótkie adresy są zapełnione po uruchomieniu i jakie typy urządzeń zostały odkryte — jest to główny krok weryfikacji przed przełączeniem projektu na operacyjny szablon *Resi Dali*. ### Akcje na poziomie bramki Siedem akcji serwisowych na module steruje bramką bezpośrednio: - **Reset Gateway** — zapisuje `1` do `H:6000` (DIP SWITCH / SOFTWARE RESET). Restartuje bramkę; przydatne po zwarciu magistrali do odzyskania silnika DALI. - **Set Slave ID** — zapisuje nowy Unit ID (1–255) do rejestru FLASH `H:65221`, a następnie resetuje przez `H:6000`. Wymaga `DIP4 = OFF`, aby akcja miała efekt. - **Turn On All Lamps** — zapisuje `0xFE` (arc power 254 = 100 %) do rejestru DALI broadcast level `H:530`. Włącza każde urządzenie na magistrali niezależnie od krótkiego adresu — szybkie wizualne potwierdzenie, że magistrala i zasilacz są sprawne. - **Turn Off All Lamps** — zapisuje `0x00` do `H:530`, wyłączając każde urządzenie. Ta sama ścieżka broadcast, przeciwna wartość. - **Resetuj krótkie adresy** — parametr *Confirm* (*Yes* / *No*). Przy *Yes* wysyła `DTR0 = 0xFF` (`0xA3FF`) i broadcast `SET SHORT ADDRESS`, więc każde urządzenie na magistrali traci swój krótki adres; następne uruchomienie kreatora numeruje wtedy urządzenia od krótkiego adresu 0. Przy *No* nic nie jest wysyłane. - **Delete short address** — parametry *Short address* (0–63) i *Confirm* (*Yes* / *No*). Sprawdza poleceniem `QUERY CONTROL GEAR PRESENT` (`0x91`), czy na adresie odpowiada urządzenie, wysyła `DTR0 = 0xFF` i `SET SHORT ADDRESS` na ten adres, następnie sprawdza ponownie i zgłasza `Address N deleted`, `Address N still answers`, `No gear answers on address N` lub `Not confirmed`. - **Change short address** — parametry *Old short address* i *New short address* (0–63). Sprawdza poleceniem `QUERY CONTROL GEAR PRESENT`, czy nowy adres jest wolny i czy na starym odpowiada dokładnie jedno urządzenie, przenosi urządzenie (`DTR0` = nowy adres, `SET SHORT ADDRESS` na stary adres) i potwierdza je na nowym adresie. Jeśli stary adres współdzieli kilka urządzeń, akcja zatrzymuje się i prosi o usunięcie adresu oraz uruchomienie kreatora adresowania. Atrybut serwisowy **Slave ID** na module odczytuje z powrotem aktualny Unit ID z rejestru FLASH `H:65221`, więc aktualnie zaprogramowany adres można zweryfikować przed wysłaniem *Set Slave ID*. Sześć kolejnych atrybutów serwisowych modułu pokazuje informacje o bramce: **Gateway firmware** (`H:65202`, jako wersja i surowa wartość hex), **Gateway software group** (`H:65201`), **Gateway hardware group** (`H:65200`), **Gateway firmware author** (`H:65203`), **Gateway DIP switches** (`H:10009`, stan DIP 1–4 jako `1:… 2:… 3:… 4:…`) i **Gateway converter status** (`H:5050`); wartości grupy, autora i statusu są wyświetlane w hex. > [!TIP] > Uruchom **Turn On All Lamps** natychmiast po okablowaniu, *przed* uruchomieniem kreatora adresowania. Każde zasilane i prawidłowo podłączone urządzenie na magistrali zapali się na 100 %, co jest bardzo szybkim sposobem na wykrycie brakujących lub źle podłączonych opraw, zanim spędzisz czas na programowaniu krótkich adresów. ## Rozwiązywanie problemów ### Kreator wypada timeoutem na każdym kroku 1. Sprawdź napięcie magistrali DALI na zaciskach zasilacza — musi wynosić 11,5–22,5 V (typowo 14–16 V). Znacznie niższy odczyt zwykle wskazuje zwarcie DALI. 2. Sprawdź diodę LED **ERR** na RESI-DALI-PS — jeśli świeci, magistrala jest zwarta, przeciążona lub sam zasilacz jest uszkodzony. 3. Sprawdź diodę LED **STATE** na bramce — powolny rytm 1 s oznacza sprawną magistralę DALI, szybki rytm ~250 ms wskazuje błąd magistrali, zwarcie lub brakujące zasilanie DALI. 4. Upewnij się, że żaden inny master Modbus (MODBUSConfigurator, BMS, PLC) nie rozmawia z bramką w tym samym czasie. ### Gear 0–63 wszystkie zgłaszają `--` po uruchomieniu 1. Zmierz napięcie DALI na urządzeniu najdalej od zasilacza — musi być powyżej 9,5 V. Jeśli jest niższe, magistrala jest za długa dla przekroju przewodu (patrz tabela długości kabla DALI powyżej). Podziel magistralę na dwa segmenty z drugim zasilaczem. 2. Uruchom kreator ponownie po akcji modułu **Resetuj krótkie adresy** (*Confirm* = *Yes*). Wyszukiwanie znajduje tylko urządzenia *bez* krótkiego adresu, więc urządzenia, które wciąż mają wcześniej zaprogramowany adres, nie zostaną ponownie zaadresowane, chyba że najpierw wykonasz reset. 3. Szukaj pętli w okablowaniu. DALI nie toleruje pierścieni; przerwij każdą znalezioną pętlę i ponownie zakończ oba otwarte końce. ### Set Slave ID nie zmienia adresu 1. Potwierdź `DIP4 = OFF` na bramce. Gdy `DIP4 = ON`, sprzęt wymusza Unit ID 255 niezależnie od wartości FLASH. 2. Potwierdź, że bramka faktycznie zrestartowała się po akcji (diody LED bramki krótko gasną). Jeśli nie, wywołaj **Reset Gateway** ręcznie. 3. Zaimportuj szablon ponownie z nowym parametrem importu `SlaveId` — wcześniej zaimportowany moduł wciąż odpytuje na starym adresie. ### Komunikacja działa krótko, a potem zawodzi 1. Sprawdź, czy `RS485 GND` jest podłączone między bramką a wspólną masą zasilacza TapHome. Brakujące GND to najczęstsza awaria RS-485. 2. Zweryfikuj terminację — 120 Ω na obu końcach magistrali RS-485. Dla RTU-over-TCP przez serial bridge upewnij się, że bridge jest w trybie ramkowym RTU, a nie raw TCP, i że odstęp między znakami po stronie szeregowej odpowiada taktowaniu 9600 baud 8N1. 3. Zmniejsz liczbę równoległych zapytań DALI — bramka serializuje transakcje DALI i nie arbitruje między wieloma masterami Modbus. ## Dostępne urządzenia 1 Te urządzenia pojawią się w TapHome po imporcie. Resi Dali - Konfiguracja Moduł Atrybuty serwisowe | | | |----------|------------------------------------------------------------------------------------------------------------------------------| | Slave ID | Odczytuje Modbus Unit ID zapisany w rejestrze FLASH H:65221 — używany do weryfikacji aktualnego adresu bramki | | Gear 0 | Sonda DALI device-type na krótkim adresie 0 — zwraca DT{n}, gdy urządzenie sterujące odpowiada, lub --, gdy adres jest wolny | | Gear 1 | Sonda DALI device-type na krótkim adresie 1 — zwraca DT{n} lub -- | | Gear 2 | Sonda DALI device-type na krótkim adresie 2 — zwraca DT{n} lub -- | | Gear 3 | Sonda DALI device-type na krótkim adresie 3 — zwraca DT{n} lub -- | | Gear 4 | Sonda DALI device-type na krótkim adresie 4 — zwraca DT{n} lub -- | | Gear 5 | Sonda DALI device-type na krótkim adresie 5 — zwraca DT{n} lub -- | | Gear 6 | Sonda DALI device-type na krótkim adresie 6 — zwraca DT{n} lub -- | | Gear 7 | Sonda DALI device-type na krótkim adresie 7 — zwraca DT{n} lub -- | | Gear 8 | Sonda DALI device-type na krótkim adresie 8 — zwraca DT{n} lub -- | | Gear 9 | Sonda DALI device-type na krótkim adresie 9 — zwraca DT{n} lub -- | | Gear 10 | Sonda DALI device-type na krótkim adresie 10 — zwraca DT{n} lub -- | | Gear 11 | Sonda DALI device-type na krótkim adresie 11 — zwraca DT{n} lub -- | | Gear 12 | Sonda DALI device-type na krótkim adresie 12 — zwraca DT{n} lub -- | | Gear 13 | Sonda DALI device-type na krótkim adresie 13 — zwraca DT{n} lub -- | | Gear 14 | Sonda DALI device-type na krótkim adresie 14 — zwraca DT{n} lub -- | | Gear 15 | Sonda DALI device-type na krótkim adresie 15 — zwraca DT{n} lub -- | | Gear 16 | Sonda DALI device-type na krótkim adresie 16 — zwraca DT{n} lub -- | | Gear 17 | Sonda DALI device-type na krótkim adresie 17 — zwraca DT{n} lub -- | | Gear 18 | Sonda DALI device-type na krótkim adresie 18 — zwraca DT{n} lub -- | | Gear 19 | Sonda DALI device-type na krótkim adresie 19 — zwraca DT{n} lub -- | | Gear 20 | Sonda DALI device-type na krótkim adresie 20 — zwraca DT{n} lub -- | | Gear 21 | Sonda DALI device-type na krótkim adresie 21 — zwraca DT{n} lub -- | | Gear 22 | Sonda DALI device-type na krótkim adresie 22 — zwraca DT{n} lub -- | | Gear 23 | Sonda DALI device-type na krótkim adresie 23 — zwraca DT{n} lub -- | | Gear 24 | Sonda DALI device-type na krótkim adresie 24 — zwraca DT{n} lub -- | | Gear 25 | Sonda DALI device-type na krótkim adresie 25 — zwraca DT{n} lub -- | | Gear 26 | Sonda DALI device-type na krótkim adresie 26 — zwraca DT{n} lub -- | | Gear 27 | Sonda DALI device-type na krótkim adresie 27 — zwraca DT{n} lub -- | | Gear 28 | Sonda DALI device-type na krótkim adresie 28 — zwraca DT{n} lub -- | | Gear 29 | Sonda DALI device-type na krótkim adresie 29 — zwraca DT{n} lub -- | | Gear 30 | Sonda DALI device-type na krótkim adresie 30 — zwraca DT{n} lub -- | | Gear 31 | Sonda DALI device-type na krótkim adresie 31 — zwraca DT{n} lub -- | | Gear 32 | Sonda DALI device-type na krótkim adresie 32 — zwraca DT{n} lub -- | | Gear 33 | Sonda DALI device-type na krótkim adresie 33 — zwraca DT{n} lub -- | | Gear 34 | Sonda DALI device-type na krótkim adresie 34 — zwraca DT{n} lub -- | | Gear 35 | Sonda DALI device-type na krótkim adresie 35 — zwraca DT{n} lub -- | | Gear 36 | Sonda DALI device-type na krótkim adresie 36 — zwraca DT{n} lub -- | | Gear 37 | Sonda DALI device-type na krótkim adresie 37 — zwraca DT{n} lub -- | | Gear 38 | Sonda DALI device-type na krótkim adresie 38 — zwraca DT{n} lub -- | | Gear 39 | Sonda DALI device-type na krótkim adresie 39 — zwraca DT{n} lub -- | | Gear 40 | Sonda DALI device-type na krótkim adresie 40 — zwraca DT{n} lub -- | | Gear 41 | Sonda DALI device-type na krótkim adresie 41 — zwraca DT{n} lub -- | | Gear 42 | Sonda DALI device-type na krótkim adresie 42 — zwraca DT{n} lub -- | | Gear 43 | Sonda DALI device-type na krótkim adresie 43 — zwraca DT{n} lub -- | | Gear 44 | Sonda DALI device-type na krótkim adresie 44 — zwraca DT{n} lub -- | | Gear 45 | Sonda DALI device-type na krótkim adresie 45 — zwraca DT{n} lub -- | | Gear 46 | Sonda DALI device-type na krótkim adresie 46 — zwraca DT{n} lub -- | | Gear 47 | Sonda DALI device-type na krótkim adresie 47 — zwraca DT{n} lub -- | | Gear 48 | Sonda DALI device-type na krótkim adresie 48 — zwraca DT{n} lub -- | | Gear 49 | Sonda DALI device-type na krótkim adresie 49 — zwraca DT{n} lub -- | | Gear 50 | Sonda DALI device-type na krótkim adresie 50 — zwraca DT{n} lub -- | | Gear 51 | Sonda DALI device-type na krótkim adresie 51 — zwraca DT{n} lub -- | | Gear 52 | Sonda DALI device-type na krótkim adresie 52 — zwraca DT{n} lub -- | | Gear 53 | Sonda DALI device-type na krótkim adresie 53 — zwraca DT{n} lub -- | | Gear 54 | Sonda DALI device-type na krótkim adresie 54 — zwraca DT{n} lub -- | | Gear 55 | Sonda DALI device-type na krótkim adresie 55 — zwraca DT{n} lub -- | | Gear 56 | Sonda DALI device-type na krótkim adresie 56 — zwraca DT{n} lub -- | | Gear 57 | Sonda DALI device-type na krótkim adresie 57 — zwraca DT{n} lub -- | | Gear 58 | Sonda DALI device-type na krótkim adresie 58 — zwraca DT{n} lub -- | | Gear 59 | Sonda DALI device-type na krótkim adresie 59 — zwraca DT{n} lub -- | | Gear 60 | Sonda DALI device-type na krótkim adresie 60 — zwraca DT{n} lub -- | | Gear 61 | Sonda DALI device-type na krótkim adresie 61 — zwraca DT{n} lub -- | | Gear 62 | Sonda DALI device-type na krótkim adresie 62 — zwraca DT{n} lub -- | | Gear 63 | Sonda DALI device-type na krótkim adresie 63 — zwraca DT{n} lub -- | | Gear 58 | | | Gear 59 | | | Gear 60 | | | Gear 61 | | | Gear 62 | | | Gear 63 | | Akcje serwisowe | | | |---------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------| | Reset Gateway | Zapisuje 1 do rejestru H:6000 aby zrestartować bramkę RESI-DALI — wymagane po zmianie Slave ID lub do odzyskania silnika DALI po zwarciu magistrali | | Set Slave ID | Zapisuje nowy Modbus Unit ID do rejestru FLASH H:65221 i wyzwala reset, aby bramka zrestartowała z nowym adresem (1–255, DIP4 musi być OFF) | | Turn On All Lamps | Zapisuje 0xFE do rejestru DALI broadcast level H:530 — włącza każde urządzenie sterujące na magistrali na maksymalną jasność (szybki test uruchomieniowy) | | Turn Off All Lamps | Zapisuje 0x00 do rejestru DALI broadcast level H:530 — wyłącza każde urządzenie sterujące na magistrali | | ${xml\_reset\_short\_addresses} | | | Delete short address | | | Change short address | | Atrybuty serwisowe ${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("--")); ``` Akcje serwisowe ${xml\_reset\_gateway} ```taphome modbusw(SH,6000,uint16,1) ``` ${xml\_set\_slave\_id} Parametry: ${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} Parametry: 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 Parametry: 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 Parametry: 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); ``` Znajdź nowe urządzenia Przełącznik wielowartościowy Odczyt i zapis Kreator uruchomieniowy, który przechodzi przez algorytm losowego adresowania DALI 2.0, aby przydzielić krótkie adresy 0–63 urządzeniom sterującym Rejestr: H:541 → H:542 UInt16 numeric Wartości / Stany: TERMINATE · ${xml\_start} · ${xml\_scan\_short\_address} · Set SEARCHADDR · COMPARE · PROGRAM SHORT ADDRESS · Check · Try again · ${xml\_finish} Odczyt stanu przełącznika ```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); ``` Zapis stanu przełącznika ```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); ``` **Połączenie:** Modbus RTU • 9600 baud• 8N1 • Slave ID: $\[SlaveId] Możliwe ulepszenia (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 ## Parametry importu Te wartości podajesz podczas importu pliku XML. | Pytanie w aplikacji | Domyślnie | |---------------------|---------------| | Slave ID | `255` | | Adres IP | `192.168.1.0` | ## Źródła - 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 Dokumenty producentów są © ich właścicieli. Udostępniamy je w formie opublikowanej przez producenta, wyłącznie w celach informacyjnych. ## Powiązana dokumentacja - [Modbus Integration](https://taphome.com/pl/compatibility/modbus-guide/) - [Modbus](https://taphome.com/pl/docs/integration/modbus/) - [Prosta konfiguracja za pomocą szablonów](https://taphome.com/pl/docs/integration/modbus/templates/) - [Skrypty Modbus i prefetch](https://taphome.com/pl/docs/script/modbus-scripts/) - [Funkcje Modbus](https://taphome.com/pl/docs/script/modbus/) - [Typy danych Modbus](https://taphome.com/pl/docs/script/modbus-data-types/)