RESI-DALI-SIO — Uruchomienie DALI

Resi Dali - Konfiguracja

Modbus RTU

Dodane przez

Ostatnia aktualizacja: 04. 2026

Wymaga zewnętrznej bramki
Resi RESI-DALI-PS — strona produktu

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.

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, grupy, sceny i sterowanie kolorem DT6/DT8 RGB / tunable-white. 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ół)

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ół)

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 przez Modbus TCP lub 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ół)

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

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ć:

Ustaw na bramce DIP4 = OFF, aby FLASH Unit ID był honorowany.
Zaimportuj szablon w TapHome z SlaveId = 255 (aktualny adres).
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.
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.

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 i cztery akcje na poziomie bramki.

Kreator uruchomieniowy — Find New Devices

Find New Devices to dziesięciostanowy przełącznik multi-value, który steruje algorytmem losowego adresowania DALI 2.0 w dyskretnych krokach. Każda nazwa stanu odpowiada jednej fazie sekwencji konfiguracyjnej DALI 2.0; wybór stanu powoduje, że szablon wysyła odpowiednią surową 16-bitową ramkę DALI na H:541 / H:542, a następnie odpytuje status DALI RX na H:550 o odpowiedź bramki.

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
2	Skanuj krótki adres	Sonduje następny slot krótkiego adresu; zwraca kod statusu 7, gdy żadne urządzenie nie odpowiada
3	Set SEARCHADDR	Ładuje górne/środkowe/dolne bajty SEARCHADDR (`0xB500/0xB300/0xB100`) do wyszukiwania binarnego
4	COMPARE	Wysyła `COMPARE` (`0xA900`) i zawęża 24-bitowe okno wyszukiwania na podstawie odpowiedzi
5	PROGRAM SHORT ADDRESS	Zapisuje zweryfikowany krótki adres przez `0xB7xx` — urządzenie jest teraz trwale zaadresowane
6	Sprawdź	Weryfikuje zaprogramowany adres drugim `COMPARE` na końcowym `SEARCHADDRL`
7	Spróbuj ponownie	Odzyskiwanie po kolizji / timeoucie — połowi aktualny interwał wyszukiwania i ponawia
8	Resetuj krótkie adresy	DALI `DTR = 0xFF` (`0xA3FF`) + broadcast `REMOVE SHORT ADDRESS` — kasuje wszystkie istniejące krótkie adresy, gotowe do pełnego readresowania
9	Zakończ	Odczytuje bajt wyniku DALI, emituje wiadomość info/błąd TapHome i opuszcza kreator

Typowy przepływ uruchamiania:

Zasil magistralę DALI (RESI-DALI-PS), okabluj urządzenia w topologii drzewa i upewnij się, że nic innego nie steruje magistralą.
(Opcjonalnie, ale zalecane) najpierw uruchom Resetuj krótkie adresy, aby rozpocząć od czystego stanu bez adresowanych urządzeń.
Uruchom Start — wysyła INITIALISE + RANDOMISE, więc każde urządzenie wybiera nowy 24-bitowy losowy adres.
Uruchom Skanuj krótki adres → Set SEARCHADDR → COMPARE → PROGRAM SHORT ADDRESS → Sprawdź sekwencyjnie. Stany enkapsulują wyszukiwanie binarne DALI 2.0; każdy krok przesuwa algorytm o jedną fazę.
Jeśli krok zgłosi kolizję lub timeout, wywołaj Spróbuj ponownie i ponów sekwencję compare/program.
Gdy wszystkie widoczne urządzenia zostały zaprogramowane, uruchom TERMINATE, a następnie Zakończ, aby czysto opuścić kreator.
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).

Kreator jest zaprojektowany tak, aby przechodzić przez niego stan po stanie — szablon nie automatyzuje całej pętli, ponieważ instalator musi obserwować zachowanie magistrali DALI (pulsowanie lamp, 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

Cztery akcje serwisowe na module sterują 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ść.

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.

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

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.
Sprawdź diodę LED ERR na RESI-DALI-PS — jeśli świeci, magistrala jest zwarta, przeciążona lub sam zasilacz jest uszkodzony.
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.
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

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.
Uruchom kreator ponownie od Resetuj krótkie adresy. Nie uruchamiaj Start na magistrali, która wciąż zawiera wcześniej zaprogramowane urządzenia, chyba że najpierw wykonasz reset — algorytm znajduje tylko urządzenia bez krótkiego adresu.
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

Potwierdź DIP4 = OFF na bramce. Gdy DIP4 = ON, sprzęt wymusza Unit ID 255 niezależnie od wartości FLASH.
Potwierdź, że bramka faktycznie zrestartowała się po akcji (diody LED bramki krótko gasną). Jeśli nie, wywołaj Reset Gateway ręcznie.
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

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.
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.
Zmniejsz liczbę równoległych zapytań DALI — bramka serializuje transakcje DALI i nie arbitruje między wieloma masterami Modbus.

Dostępne urządzenia

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

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

${resi_dali_configuration}

Atrybuty serwisowe

${xml_slave_id}

modbusr(H,65221,uint16)

Gear 0

var ShortAddress := 0;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 1

var ShortAddress := 1;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 2

var ShortAddress := 2;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 3

var ShortAddress := 3;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 4

var ShortAddress := 4;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 5

var ShortAddress := 5;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 6

var ShortAddress := 6;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 7

var ShortAddress := 7;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 8

var ShortAddress := 8;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 9

var ShortAddress := 9;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 10

var ShortAddress := 10;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 11

var ShortAddress := 11;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 12

var ShortAddress := 12;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 13

var ShortAddress := 13;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 14

var ShortAddress := 14;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 15

var ShortAddress := 15;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 16

var ShortAddress := 16;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 17

var ShortAddress := 17;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 18

var ShortAddress := 18;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 19

var ShortAddress := 19;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 20

var ShortAddress := 20;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 21

var ShortAddress := 21;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 22

var ShortAddress := 22;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 23

var ShortAddress := 23;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 24

var ShortAddress := 24;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 25

var ShortAddress := 25;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 26

var ShortAddress := 26;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 27

var ShortAddress := 27;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 28

var ShortAddress := 28;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 29

var ShortAddress := 29;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 30

var ShortAddress := 30;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 31

var ShortAddress := 31;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 32

var ShortAddress := 32;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 33

var ShortAddress := 33;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 34

var ShortAddress := 34;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 35

var ShortAddress := 35;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 36

var ShortAddress := 36;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 37

var ShortAddress := 37;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 38

var ShortAddress := 38;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 39

var ShortAddress := 39;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 40

var ShortAddress := 40;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 41

var ShortAddress := 41;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 42

var ShortAddress := 42;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 43

var ShortAddress := 43;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 44

var ShortAddress := 44;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 45

var ShortAddress := 45;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 46

var ShortAddress := 46;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 47

var ShortAddress := 47;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 48

var ShortAddress := 48;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 49

var ShortAddress := 49;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 50

var ShortAddress := 50;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 51

var ShortAddress := 51;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 52

var ShortAddress := 52;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 53

var ShortAddress := 53;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 54

var ShortAddress := 54;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 55

var ShortAddress := 55;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 56

var ShortAddress := 56;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 57

var ShortAddress := 57;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 58

var ShortAddress := 58;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 59

var ShortAddress := 59;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 60

var ShortAddress := 60;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 61

var ShortAddress := 61;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 62

var ShortAddress := 62;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Gear 63

var ShortAddress := 63;
modbusw(SH, 511, uint16, (ShortAddress << 8) + 0x99);
sleep(5); var rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
var x := modbusr(SH, 511, uint16);
if (x != 0x8000, return("DT" + x), return("--"));

Akcje serwisowe

${xml_reset_gateway}

modbusw(SH,6000,uint16,1)

${xml_set_slave_id}

Parametry: ${xml_slave_id} (1–255 SID)

modbusw(SH, 65221, uint16, SID);

modbusw(SH,6000, uint16, 1);

${xml_turn_on_all_lamps}

modbusw(SH, 530, uint16, 0xFE)

${xml_turn_off_all_lamps}

modbusw(SH, 530, uint16, 0x00)

Znajdź nowe urządzenia Przełącznik wielowartościowy

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_reset_short_addresses} · ${xml_finish}

Znajdź nowe urządzenia

Odczyt stanu przełącznika

var x := 0x8000; var rx := 0;

if Mu = 1
	if exit <= 0
		status := 255;
        return(9);
    end
    # check SEARCHADDRH
    modbusw(SH, 541, uint16, 0xB500 + getbyte(SEARCHADDRH,0));
    sleep(500);
    modbusw(SH, 541, uint16, 0xB300 + getbyte(SEARCHADDRH,1));
    sleep(500);
    modbusw(SH, 541, uint16, 0xB100 + getbyte(SEARCHADDRH,2));
    sleep(500);
    modbusw(SH, 541, uint16, 0xA900);
    sleep(5); rx := getbits(modbusr(SH, 550, uint16), 0, 2);
    if !rx
        sleep(50);
        rx := getbits(modbusr(SH, 550, uint16), 0, 2);
    end
    if rx
        x := modbusr(SH, 541, uint16);
        if getbyte(x, 0) = 0xFF
            #match: lets check
            return(2);
        else
            return(7);
        end
    else
        return(7);
    end
end
if Mu = 2
    # find max short address
    if SHORTADDR >= 63
        status := 254;
        return(9);
    end
    if iterator >= 64
        status := 10;
        return(3);
    end
    modbusw(SH, 511, uint16, (iterator << 8) + 0x91);
    sleep(5); rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
    x := modbusr(SH, 511, uint16);
    if (x = 0xFF, SHORTADDR := iterator); 
    iterator := iterator + 1;
end
if Mu = 3
    # set SEARCHADDR
    SEARCHADDRM := SEARCHADDRH - ((SEARCHADDRH - SEARCHADDRL) >> 1);
    if(SEARCHADDRM = SEARCHADDRH or SEARCHADDRM = SEARCHADDRL, return(6));
    modbusw(SH, 541, uint16, 0xB500 + getbyte(SEARCHADDRM,0));
    sleep(50);
    modbusw(SH, 541, uint16, 0xB300 + getbyte(SEARCHADDRM,1));
    sleep(50);
    modbusw(SH, 541, uint16, 0xB100 + getbyte(SEARCHADDRM,2));
    sleep(50);
    return(4);
end
if Mu = 4
    # COMPARE
    modbusw(SH, 541, uint16, 0xA900);
    sleep(5); rx := getbits(modbusr(SH, 550, uint16), 0, 2);
    if !rx
        sleep(50);
        rx := getbits(modbusr(SH, 550, uint16), 0, 2);
    end
    if rx
        x := modbusr(SH, 541, uint16);
        #collision or match: lets search the lower segment
        SEARCHADDRH := SEARCHADDRM;
    else
        #no response: lets look up in the higher segment
        SEARCHADDRL := SEARCHADDRM;
    end
    return(3);
end
if Mu = 6
    # check SEARCHADDRL
    modbusw(SH, 541, uint16, 0xB500 + getbyte(SEARCHADDRL,0));
    sleep(50);
    modbusw(SH, 541, uint16, 0xB300 + getbyte(SEARCHADDRL,1));
    sleep(50);
    modbusw(SH, 541, uint16, 0xB100 + getbyte(SEARCHADDRL,2));
    sleep(50);
    modbusw(SH, 541, uint16, 0xA900);
    sleep(5); rx := getbits(modbusr(SH, 550, uint16), 0, 2);
    if !rx
        sleep(50);
        rx := getbits(modbusr(SH, 550, uint16), 0, 2);
    end
    if rx
        x := modbusr(SH, 541, uint16);
        if getbyte(x, 0) = 0xFF
            #exact match: we have it, lets finish
            return(5);
        else
            #collision: 2 gear with same SEARCHADDR or something went wrong, start over
            return(7);
        end
    end
    # check SEARCHADDRH
    modbusw(SH, 541, uint16, 0xB500 + getbyte(SEARCHADDRH,0));
    sleep(50);
    modbusw(SH, 541, uint16, 0xB300 + getbyte(SEARCHADDRH,1));
    sleep(50);
    modbusw(SH, 541, uint16, 0xB100 + getbyte(SEARCHADDRH,2));
    sleep(50);
    modbusw(SH, 541, uint16, 0xA900);
    sleep(5); rx := getbits(modbusr(SH, 550, uint16), 0, 2);
    if !rx
        sleep(50);
        rx := getbits(modbusr(SH, 550, uint16), 0, 2);
    end    
    if rx
        x := modbusr(SH, 541, uint16);
        if getbyte(x, 0) = 0xFF
            #exact match: we have it, lets finish
            return(5);
        else
            #collision: 2 gear with same SEARCHADDR or something went wrong, start over
            return(7);
        end
    else
        #no response: something went wrong, finish with error
        status := 220;
        #return(9);
        return(7);
    end
end
if Mu = 5
	exit := 3;
    # PROGRAM SHORT ADDRESS
    SHORTADDR := SHORTADDR + 1;
    #program
    modbusw(SH, 542, uint16, 0xB701 + (SHORTADDR << 1));
    sleep(100);
    #verify
    modbusw(SH, 541, uint16, 0xB901 + (SHORTADDR << 1));
    sleep(5); rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
    x := modbusr(SH, 541, uint16);
    if getbyte(x, 0) = 0xFF
        status := 0;
    else
        status := 230;
        #return(9);
        SHORTADDR := SHORTADDR - 1;
        return(7);
    end
    #blink
    modbusw(SH, 511, uint16, SHORTADDR + 0x06);
    sleep(500);
    modbusw(SH, 511, uint16, SHORTADDR + 0x05);
    sleep(500);
    modbusw(SH, 511, uint16, SHORTADDR + 0x06);
    #WITHDRAW
    modbusw(SH, 541, uint16, 0xAB00);
    sleep(100);
    SEARCHADDRH := 0xFFFFFF;
    SEARCHADDRL := 0;
    return(1);
end
if Mu = 9
    # finish
    if(status = 99, adderror("Timeout!"));
    if(status = 220, adderror("Check failed! (" + tostring(SEARCHADDRH, "X2") + " | " + tostring(SEARCHADDRL, "X2") + " )"));
    if(status = 230, adderror("Verify short address failed! (" + tostring(SHORTADDR, "X2") + " | " + tostring(x, "X2") + 
        " | " + tostring(SEARCHADDRH, "X2") + " | " + tostring(SEARCHADDRM, "X2") + " | " + tostring(SEARCHADDRL, "X2") + " )"));
    if(status = 231, adderror("Short address mismatch! (" + tostring(SHORTADDR, "X2") + " | " + tostring(x, "X2") + " )"));
    if(status = 254, adderror("All short addresses are in use!"));
    if status = 255
        modbusw(SH, 531, uint16, 0x96);
        sleep(5); rx := getbits(modbusr(SH, 550, uint16), 0, 2); if(rx, 0, sleep(50));
        x := modbusr(SH, 531, uint16);
        if getbyte(x, 0) = 0xFF
            adderror("Some gear is still missing short address, but no response from SEARCHADDRH! ( " + tostring(SEARCHADDRH, "X2") + " )");
        else    
            status := 1;
        end
    end
    if(status = 1, addinfo("Search finished")); 
    if(status = 200 or status = 230 or status = 231 or status = 254, iterator := 0); 
end
#debug
#if(Mu = 7, addinfo("Debug:" + tostring(x, "X2") + " | " + status),0);

#if(Mu = 1, status := "rx:" + getbits(y, 0, 2) + "|" + getbits(y, 4, 1) + "|" + getbits(y, 5, 1), 0);
#if(Mu = 1, return(7),0);
if Mu = 7
	if SEARCHADDRH = SEARCHADDRL
    	SEARCHADDRH := 0xFFFFFF;
    	SEARCHADDRL := 0;
    	exit := exit -1;
        return(1);
    end
	SEARCHADDRH := SEARCHADDRH >> 1;
	SEARCHADDRL := 0;
	if(iterator < 64, SHORTADDR := -1);
	if(iterator < 64, iterator := 0);    
    # check SEARCHADDRH
    modbusw(SH, 541, uint16, 0xB500 + getbyte(SEARCHADDRH,0));
    sleep(500);
    modbusw(SH, 541, uint16, 0xB300 + getbyte(SEARCHADDRH,1));
    sleep(500);
    modbusw(SH, 541, uint16, 0xB100 + getbyte(SEARCHADDRH,2));
    sleep(500);
    modbusw(SH, 541, uint16, 0xA900);
    sleep(5); rx := getbits(modbusr(SH, 550, uint16), 0, 2);
    if !rx
        sleep(50);
        rx := getbits(modbusr(SH, 550, uint16), 0, 2);
    end
    if rx
        x := modbusr(SH, 541, uint16);
        if getbyte(x, 0) = 0xFF
            #match: lets check
            return(2);
        else
            return(6);
        end
    else
        return(6);
    end
end
return(Mu);

Zapis stanu przełącznika

# TERMINATE
if(Mu = 0, modbusw(SH, 542, uint16, 0xA100), 0);
# INITIALIZE:CONTROL GEARS WITHOUT SHORT ADDRESS
if(Mu = 1, modbusw(SH, 542, uint16, 0xA5FF), 0);
if(Mu = 1, sleep(100));
# RANDOMIZE
if(Mu = 1, modbusw(SH, 542, uint16, 0xA700), 0);
if(Mu = 1, sleep(100));
# Init SEARCHADDR variables
if(Mu = 1, SEARCHADDRH := 0xFFFFFF, 0);
#if(Mu = 1, SEARCHADDRM := SEARCHADDRH / 2, 0);
if(Mu = 1, SEARCHADDRL := 0, 0);
if(Mu = 1, if(iterator < 64, SHORTADDR := -1, 0), 0);
if(Mu = 1, if(iterator < 64, iterator := 0, 0), 0);
if(Mu = 1, exit := 3, 0);
# Reset Short Addresses 
if(Mu = 8, modbusw(h, 541, uint16, 0xA3FF), 0);
if(Mu = 8, sleep(100));
if(Mu = 8, modbusw(h, 532, uint16, 0x80), 0);
if(Mu = 8, SHORTADDR := -1, 0);
if(Mu = 8, iterator := 64, 0);
# Reset All to Defaults 
#if(Mu = 7, modbusw(SH, 532, uint16, 0x20), 0);
#if(Mu = 7, sleep(100));
#collision: halve interval


sleep(100);

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

Pobierz szablon

Źródła

RESI-DALI-SIO/ETH Modbus & ASCII protocol reference
www.resi.cc 2026-04-15
PDF
RESI-xxx-SIO, RESI-xxx-ETH hardware & software manual (DALI chapter)
www.resi.cc 2026-04-15
PDF
RESI-DALI-SIO datasheet (GW-28)
www.resi.cc 2026-04-15
PDF
RESI-DALI-ETH datasheet (GW-29)
www.resi.cc 2026-04-15
PDF
RESI-DALI-PS datasheet (GW-30)
www.resi.cc 2026-04-15
PDF
RESI-DALI-SIO,ETH,PS product page
www.resi.cc 2026-04-15