---
title: "Resi Dali - Configuration"
description: "Punerea în funcțiune DALI 2.0 pe gateway-ul RESI-DALI-SIO/ETH din TapHome: adrese scurte 0–63, tipul dispozitivelor, teste broadcast prin Modbus."
url: "https://taphome.com/ro/compatibility/resi-dali-daliconfig/"
language: ro
lastmod: 2026-11-15
generator: hugo
ai:
  topics: ["modbus-rtu","lighting","dali","dali-2.0","rs485","din-rail","commissioning","addressing","gateway"]
  questions: ["Cum atribui adresele scurte DALI din TapHome?","Cum pun în funcțiune dispozitivele de comandă DALI 2.0 cu gateway-ul RESI-DALI-SIO?","Ce face șablonul TapHome Resi Dali - Configuration?","Cum setez Modbus Slave ID pe un RESI-DALI-SIO / RESI-DALI-ETH?","Cum conectez RESI-DALI-SIO la o magistrală DALI cu o sursă de alimentare RESI-DALI-PS?","Care este diferența dintre șablonul Resi Dali - Configuration și șablonul operațional Resi Dali?","De ce are șablonul DaliConfig un parametru de import pentru adresa IP pe un gateway RTU?"]
---

# Resi Dali - Configuration

Comunicație: Modbus RTU

- [Pagina produsului RESI-DALI-SIO/ETH/PS](https://www.resi.cc/prestashop/en/home/1-resi-dali-sioethps.html)
- [RESI Informatik & Automation](https://www.resi.cc)

## Ghid de integrare

Șablonul **Resi Dali - Configurare** este un **instrument de punere în funcțiune și adresare**, folosit o singură dată la configurarea inițială a gateway-ului Modbus-DALI RESI-DALI-SIO și RESI-DALI-ETH de la RESI Informatik & Automation GmbH. Din TapHome, el rulează algoritmul de adresare aleatorie DALI 2.0, care atribuie adresele scurte 0–63 dispozitivelor de comandă de pe o magistrală DALI nou cablată, interoghează fiecare adresă pentru tipul de dispozitiv DALI și oferă teste de verificare broadcast ON/OFF — tot ce este necesar pentru a aduce o instalație nouă în starea în care lămpile pot fi controlate individual.

Comunicația cu gateway-ul folosește Modbus RTU la 9600 baud 8N1. Șablonul oferă și parametrul de import `IpAddress`, astfel încât același proces funcționează și printr-un convertor serial-IP (Moxa NPort, USR-TCP232) sau printr-un RESI-DALI-ETH configurat în modul transparent RTU-over-Ethernet.

> [!NOTE]
> Acest șablon este conceput **exclusiv pentru adresare**. După atribuirea adreselor scurte, eliminați modulul Resi Dali - Configurare și folosiți pentru controlul de zi cu zi șablonul operațional înrudit **Resi DALI** (`Dali.xml`) — reglarea individuală a intensității lămpilor, reglarea intensității grupurilor și diagnosticarea fiecărui dispozitiv de comandă. Modulul de punere în funcțiune nu este conceput să rămână în proiect după configurarea inițială.

## Conectarea hardware

RESI-DALI-SIO este un gateway master pe șină DIN (17,5 × 90 × 56,4 mm, CEM17), care se află între un host serial/Ethernet și o magistrală de iluminat DALI. Gateway-ul **nu alimentează magistrala DALI** — este obligatorie o sursă de alimentare DALI separată (RESI-DALI-PS sau orice sursă DALI conformă de 200 mA).

### Conectarea RESI-DALI-SIO (RS-485)

![Schema de conectare RESI-DALI-SIO — cu sursă DALI externă (sus) și cu RESI-DALI-PS (jos)](https://taphome.com/images/compatibility/resi-dali-daliconfig/wiring-sio_hu_1af043ee91b2b0ed.jpg)

Bornele de pe partea stângă a RESI-DALI-SIO (de sus în jos): `GND`, `+12..48V=`, `RS485 DATA+ (A+)`, `RS485 DATA- (B-)`, `RS485 GND`, `RS232 TX`, `RS232 RX`, `RS232 GND`. Bornele magistralei DALI de pe partea opusă sunt **`D+ / N/C / D-`** (bloc USLIM cu 3 pini, `N/C` rămâne neconectat).

Pentru o instalație TapHome folosiți interfața RS-485:

- `RS485 DATA+ (A+)` → A+/D+ pe magistrala RS-485 TapHome
- `RS485 DATA- (B-)` → B-/D- pe magistrala RS-485 TapHome
- `RS485 GND` → GND pe sursa de alimentare TapHome (recomandat pentru o comunicație stabilă)
- `+12..48V=` / `GND` → alimentare principală 12–48 V DC

### Conectarea RESI-DALI-ETH (Ethernet)

![Schema de conectare RESI-DALI-ETH — cu sursă DALI externă (sus) și cu RESI-DALI-PS (jos)](https://taphome.com/images/compatibility/resi-dali-daliconfig/wiring-eth_hu_4bf0a5e8d8724d0b.jpg)

Varianta Ethernet are aceleași borne pentru magistrala DALI (`D+ / N/C / D-`) și pentru alimentarea principală (`GND`, `+12..48V=`), plus un singur conector RJ45 pentru Ethernet 10/100 Mbit. Setările IP implicite din fabrică sunt **192.168.0.191 / 255.255.255.0 / 192.168.0.1**, cu Modbus Unit ID 255; datele de autentificare pentru interfața web sunt `RESI` / `RESI`. TapHome comunică cu varianta ETH în modul transparent RTU-over-Ethernet, pe care îl așteaptă acest șablon de punere în funcțiune (consultați Configurare mai jos).

### Sursa de alimentare a magistralei DALI

![RESI-DALI-PS — alimentarea independentă a magistralei DALI (sus) și în combinație cu un gateway SIO/ETH (jos)](https://taphome.com/images/compatibility/resi-dali-daliconfig/wiring-dali-ps_hu_bea720a419338afa.jpg)

RESI-DALI-PS livrează până la **200 mA** pe magistrala DALI (curent de scurtcircuit ~225 mA, tensiunea tipică a magistralei 14–18 V) și acceptă până la 64 de balasturi DALI 1.0 sau dispozitive de comandă DALI 2.0 pe o singură linie. Partea primară acceptă aceeași alimentare de 12–48 V DC ca unitatea SIO/ETH. Gateway-ul și sursa de alimentare se conectează la aceeași pereche `D+` / `D-` — sursa alimentează magistrala, iar gateway-ul citește și scrie cadrele DALI.

Trei LED-uri de pe sursa de alimentare ajută la punerea în funcțiune: **POWER** (alimentarea primară de 12–48 V este în regulă, aprins permanent), **DALI** (clipește scurt în timpul traficului pe magistrală), **ERR** (aprins continuu la defectarea sursei, la scurtcircuit DALI sau la suprasarcina magistralei — în funcționare normală trebuie să fie stins).

### Regulile magistralei DALI

O linie DALI impune câteva constrângeri stricte, care influențează direct reușita punerii în funcțiune:

| Secțiunea conductorului | Lungimea maximă a cablului DALI |
|------------------------|----------------------|
| 1,5 mm² | 300 m |
| 1,0 mm² | 238 m |
| 0,75 mm² | 174 m |
| 0,5 mm² | 116 m |

Limita rezultă din **căderea de tensiune maximă admisă de 2 V** pe cablul DALI. Alte reguli:

- Maximum 64 de balasturi DALI 1.0 **și** până la 64 de dispozitive de comandă DALI 2.0 pe o magistrală (spații de adrese scurte separate).
- Doar topologie arborescentă — fără inele, fără bucle.
- Numărul real de dispozitive depinde și de curentul nominal al sursei de alimentare (de obicei 200 mA la RESI-DALI-PS, aproximativ 2 mA pentru fiecare dispozitiv plus rezervă).

> [!WARNING]
> **RESI-DALI-PS (sau o sursă DALI echivalentă) este obligatorie.** Fără ea, RESI-DALI-SIO/ETH nu poate comanda magistrala, iar asistentul de punere în funcțiune va depăși timpul de așteptare la fiecare pas. Dacă pe o linie lungă se folosește o a doua sursă de alimentare, introduceți o bobină DALI sau împărțiți magistrala în segmente separate galvanic.

## Configurare

### Activarea comunicației Modbus

Toți parametrii comunicației seriale cu hostul se selectează pe RESI-DALI-SIO cu un comutator DIP cu 4 poziții. Șablonul TapHome folosește valorile fixe **9600 baud 8N1**, așa că comutatoarele DIP trebuie setate corespunzător.

| DIP1 | DIP2 | Viteza de transmisie |
|------|------|-----------|
| **OFF** | **OFF** | **9600 bd (necesar pentru TapHome)** |
| ON | OFF | 19200 bd |
| OFF | ON | 38400 bd |
| ON | ON | Folosește viteza de transmisie programată în FLASH (implicit din fabrică 57600 bd) |

| DIP4 | Sursa pentru Modbus Unit ID |
|------|----------------------|
| **OFF** | Registrul FLASH `H:65221` — necesar pentru ca acțiunea **Setare Slave ID** să aibă efect |
| ON | Forțat la `255` (valoare de rezervă hardware, valoarea din FLASH este ignorată) |

`DIP3` este un bit rezervat specific produsului; lăsați-l în poziția din fabrică, cu excepția cazului în care manualul de service RESI indică explicit altfel. Paritatea este fixată la `None` (8N1) în valorile implicite din FLASH — șablonul nu oferă registrele pentru paritate / biți de stop.

**Terminarea RS-485:** terminați magistrala cu 120 Ω la ambele capete. TapHome Core asigură o terminare pe bornele sale BUS; dacă gateway-ul RESI este ultimul dispozitiv de pe linie, adăugați un rezistor separat de 120 Ω între `A+`/`B-` pe bornele sale RS-485.

**Configurarea RTU-over-TCP:** șablonul are ambii parametri de import `SlaveId` și `IpAddress`, deoarece același proces de punere în funcțiune DALI funcționează și printr-un **convertor serial-IP** (Moxa NPort, USR-TCP232) sau prin **RESI-DALI-ETH în modul transparent RTU-over-Ethernet**. În acest caz, setați în `IpAddress` adresa IP a convertorului / unității ETH și păstrați celelalte setări identice cu varianta RS-485. Pentru Modbus/TCP pur pe RESI-DALI-ETH ar fi mai potrivit un șablon bazat pe TCP — șablonul DaliConfig presupune în mod specific cadre Modbus RTU.

### Setarea Slave ID-ului gateway-ului

Unit ID-ul implicit din fabrică este **255**. Pentru a-l schimba:

1. Setați `DIP4 = OFF` pe gateway, ca să fie folosit Unit ID-ul din FLASH.
2. Importați șablonul în TapHome cu `SlaveId = 255` (adresa curentă).
3. Deschideți setările de service ale modulului „Resi Dali - Configurare” și declanșați acțiunea **Setare Slave ID** cu noul ID dorit (interval 1–255). Acțiunea scrie valoarea în registrul `H:65221` și declanșează imediat o resetare software prin `H:6000 = 1`, astfel încât gateway-ul repornește cu noua adresă.
4. Eliminați șablonul și importați-l din nou, cu `SlaveId` setat la noua valoare. Modulul poate fi apoi folosit pentru punerea în funcțiune.

Acțiunea **Resetare gateway** (scrie `1` în `H:6000`) este disponibilă și ca pas de recuperare independent — util după un scurtcircuit pe magistrala DALI, care a lăsat modulul DALI al gateway-ului într-o stare degradată.

> [!WARNING]
> **Un singur master Modbus în același timp.** Nici DALI, nici magistrala Modbus RTU nu arbitrează între mai mulți masteri simultani. Dacă în timpul punerii în funcțiune gateway-ul este interogat și de un PLC, de un sistem BMS sau de un instrument pe PC (de exemplu MODBUSConfigurator), programarea adreselor scurte va intra în coliziune, iar asistentul va raporta erori.

## Funcțiile dispozitivului

Șablonul este construit în jurul unui singur modul Modbus — *Resi Dali - Configurare* — care reunește asistentul de punere în funcțiune, interogarea tipului de dispozitiv DALI pentru fiecare adresă scurtă 0–63, atributele cu informații despre gateway și șapte acțiuni la nivelul gateway-ului.

### Asistentul de punere în funcțiune — Găsire dispozitive noi

*Găsire dispozitive noi* este un comutator cu nouă stări (multi-value switch), care rulează algoritmul de adresare aleatorie DALI 2.0 ca o mașină de stări. Fiecare nume de stare corespunde unei faze a secvenței de punere în funcțiune DALI 2.0; în fiecare stare, șablonul trimite cadrele DALI brute corecte de 16 biți pe `H:541` / `H:542`, interoghează starea DALI RX pe `H:550` pentru răspunsul gateway-ului, apoi trece singur comutatorul în starea următoare.

| Pas | Stare | Ce face |
|------|-------|--------------|
| 0 | **TERMINATE** | Cadrul DALI `TERMINATE` (`0xA100`) — întrerupe sesiunea de adresare curentă și resetează starea gateway-ului. Poate fi apelat oricând în siguranță |
| 1 | **Start** | `INITIALISE` (`0xA5FF`) + `RANDOMISE` (`0xA700`) — trece toate dispozitivele fără adresă în setul de adresare și cere fiecărui dispozitiv să-și aleagă o adresă aleatorie de 24 de biți. Asistentul trimite din nou ambele comenzi înaintea fiecărei noi runde de căutare |
| 2 | **Scanare adresă scurtă** | Interoghează adresele scurte 0–63 cu `QUERY CONTROL GEAR PRESENT` (`0x91`) pentru a găsi cea mai mare adresă scurtă deja folosită, astfel încât dispozitivele noi să fie numerotate după ea. Este omisă după **Resetare adrese scurte** — numerotarea începe atunci de la 0 |
| 3 | **Set SEARCHADDR** | Rulează întreaga căutare binară într-un singur pas: încarcă octeții superior/mijlociu/inferior SEARCHADDR (`0xB500/0xB300/0xB100`), trimite `COMPARE` (`0xA900`) și înjumătățește fereastra de căutare de 24 de biți până când aceasta este restrânsă, apoi continuă cu **Verificare** |
| 4 | **COMPARE** | Trimite `COMPARE` (`0xA900`) și restrânge fereastra de căutare de 24 de biți în funcție de răspuns |
| 5 | **PROGRAM SHORT ADDRESS** | Scrie următoarea adresă scurtă prin `0xB7xx` și o verifică (`0xB9xx`). Apoi dispozitivul clipește pe noua sa adresă scurtă (`RECALL MIN`, `RECALL MAX`, `RECALL MIN`) și iese din căutare (`WITHDRAW`, `0xAB00`); asistentul continuă cu runda următoare de la **Start** |
| 6 | **Verificare** | Confirmă adresa aleatorie găsită cu `COMPARE` la capătul inferior și la cel superior al ferestrei restrânse — un singur răspuns duce la **PROGRAM SHORT ADDRESS**, o coliziune sau lipsa răspunsului duce la **Reîncercare** |
| 7 | **Reîncercare** | Recuperare după coliziune / depășirea timpului de așteptare — înjumătățește intervalul de căutare curent și reîncearcă; când intervalul este epuizat, începe o rundă nouă cu `INITIALISE` + `RANDOMISE` |
| 8 | **Finalizare** | Se ajunge aici după trei runde de căutare fără niciun dispozitiv nou programat sau când toate adresele scurte 0–63 sunt ocupate. Citește octetul de rezultat DALI, afișează un mesaj TapHome de informare / eroare (`Search finished` la succes) și închide asistentul |

**Procesul tipic de punere în funcțiune:**

1. Alimentați magistrala DALI (`RESI-DALI-PS`), conectați dispozitivele în topologie arborescentă și asigurați-vă că nimic altceva nu comandă magistrala.
2. (Opțional, dar recomandat) rulați mai întâi acțiunea modulului **Resetare adrese scurte** cu *Confirm* = *Yes*, pentru a porni de la o stare curată, cu toate dispozitivele fără adresă.
3. Selectați **Start** — acesta trimite `INITIALISE` + `RANDOMISE`, astfel încât fiecare dispozitiv își alege o nouă adresă aleatorie de 24 de biți.
4. Comutatorul trece apoi singur prin **Scanare adresă scurtă** → **Set SEARCHADDR** → **Verificare** → **PROGRAM SHORT ADDRESS** și revine la **Start** pentru următorul dispozitiv. Fiecare dispozitiv nou programat clipește o dată pe noua sa adresă scurtă, ceea ce arată ce corp de iluminat a primit ce adresă.
5. Coliziunile și depășirile timpului de așteptare sunt tratate automat de **Reîncercare**, fără nicio intervenție din partea instalatorului.
6. Când comutatorul se oprește la **Finalizare**, citiți mesajul de informare / eroare, apoi selectați **TERMINATE** pentru a închide sesiunea de adresare DALI.
7. Folosiți atributele de service **Gear 0 … Gear 63** și acțiunile **Aprinderea / Stingerea tuturor lămpilor** pentru a verifica dacă adresele scurte 0–N sunt acum ocupate (consultați mai jos).

Instalatorul trebuie totuși să urmărească în timpul rulării comportamentul magistralei DALI (clipirea de confirmare, ritmul LED-ului `STATE` de pe gateway), pentru a depista dispozitivele conectate greșit sau lipsă.

### Interogarea dispozitivelor DALI — Gear 0 … Gear 63

Fiecare dintre cele 64 de atribute de service **Gear 0**, **Gear 1**, … **Gear 63** interoghează o adresă scurtă DALI cu comanda DALI 2.0 `QUERY DEVICE TYPE` (`0x99`). Intern, șablonul scrie `(SA << 8) | 0x99` în `H:511`, interoghează biții 0–2 din `H:550` până sosește un răspuns, apoi citește octetul de răspuns înapoi din `H:511`.

Valori posibile returnate în interfața de service TapHome:

- **`DT{n}`** — la această adresă este programat un dispozitiv de comandă, care a răspuns cu tipul de dispozitiv *n*. Valori tipice: `DT0` (fluorescent), `DT1` (iluminat de urgență), `DT2` (HID), `DT5` (0–10 V), `DT6` (driver LED), `DT7` (releu), `DT8` (culoare / alb reglabil), `DT9` (secvențiator).
- **`--`** — fie la această adresă nu este programat niciun dispozitiv, fie gateway-ul a returnat valoarea de semnalizare `0x8000` „no answer / already consumed”.

Interogarea arată rapid, cu rezultat reușit/eșuat, ce adrese scurte sunt ocupate după punerea în funcțiune și ce tipuri de dispozitive au fost descoperite — acesta este pasul principal de verificare înainte de trecerea proiectului la șablonul operațional *Resi Dali*.

### Acțiuni la nivelul gateway-ului

Șapte acțiuni de service ale modulului comandă direct gateway-ul:

- **Resetare gateway** — scrie `1` în `H:6000` (DIP SWITCH / SOFTWARE RESET). Repornește gateway-ul; util după un scurtcircuit pe magistrală, pentru a reface funcționarea modulului DALI.
- **Setare Slave ID** — scrie noul Unit ID (1–255) în registrul FLASH `H:65221`, apoi resetează prin `H:6000`. Pentru a avea efect necesită `DIP4 = OFF`.
- **Aprinderea tuturor lămpilor** — scrie `0xFE` (putere arc 254 = 100 %) în registrul de nivel broadcast DALI `H:530`. Aprinde fiecare dispozitiv de pe magistrală, indiferent de adresa scurtă — o confirmare vizuală rapidă că magistrala și sursa de alimentare sunt în regulă.
- **Stingerea tuturor lămpilor** — scrie `0x00` în `H:530` și stinge fiecare dispozitiv. Aceeași cale broadcast, valoare opusă.
- **Resetare adrese scurte** — parametrul *Confirm* (*Yes* / *No*). Cu *Yes* trimite `DTR0 = 0xFF` (`0xA3FF`) și un `SET SHORT ADDRESS` broadcast, astfel încât fiecare dispozitiv de pe magistrală își pierde adresa scurtă; următoarea rulare a asistentului numerotează apoi dispozitivele de la adresa scurtă 0. Cu *No* nu se trimite nimic.
- **Delete short address** — parametrii *Short address* (0–63) și *Confirm* (*Yes* / *No*). Verifică cu `QUERY CONTROL GEAR PRESENT` (`0x91`) că la adresă răspunde un dispozitiv, trimite `DTR0 = 0xFF` și `SET SHORT ADDRESS` la acea adresă, apoi verifică din nou și raportează `Address N deleted`, `Address N still answers`, `No gear answers on address N` sau `Not confirmed`.
- **Change short address** — parametrii *Old short address* și *New short address* (0–63). Verifică cu `QUERY CONTROL GEAR PRESENT` că noua adresă este liberă și că la adresa veche răspunde exact un dispozitiv, mută dispozitivul (`DTR0` = adresa nouă, `SET SHORT ADDRESS` la adresa veche) și îl confirmă la adresa nouă. Dacă mai multe dispozitive au aceeași adresă veche, acțiunea se oprește și cere ștergerea adresei și rularea asistentului de adresare.

Atributul de service **Slave ID** al modulului citește Unit ID-ul curent din registrul FLASH `H:65221`, astfel încât adresa programată în prezent poate fi verificată înainte de a trimite *Setare Slave ID*.

Alte șase atribute de service ale modulului afișează informații despre gateway: **Gateway firmware** (`H:65202`, ca versiune și ca valoare hex brută), **Gateway software group** (`H:65201`), **Gateway hardware group** (`H:65200`), **Gateway firmware author** (`H:65203`), **Gateway DIP switches** (`H:10009`, starea DIP 1–4 sub forma `1:… 2:… 3:… 4:…`) și **Gateway converter status** (`H:5050`); valorile de grup, autor și stare sunt afișate în hex.

> [!TIP]
> Rulați **Aprinderea tuturor lămpilor** imediat după cablare, *înainte* de a porni asistentul de adresare. Fiecare dispozitiv alimentat și conectat corect pe magistrală se va aprinde la 100 %, ceea ce este o metodă foarte rapidă de a depista corpurile de iluminat lipsă sau conectate greșit, înainte de a pierde timp cu programarea adreselor scurte.

## Depanare

### Asistentul depășește timpul de așteptare la fiecare pas

1. Verificați tensiunea magistralei DALI la bornele sursei de alimentare — trebuie să fie 11,5–22,5 V (tipic 14–16 V). O valoare semnificativ mai mică indică de obicei un scurtcircuit DALI.
2. Verificați LED-ul **ERR** al RESI-DALI-PS — dacă este aprins, magistrala este în scurtcircuit, supraîncărcată sau sursa de alimentare este defectă.
3. Verificați LED-ul **STATE** al gateway-ului — un ritm lent de 1 s înseamnă că magistrala DALI este în regulă, un ritm rapid de ~250 ms indică o eroare de magistrală, un scurtcircuit sau lipsa alimentării DALI.
4. Asigurați-vă că niciun alt master Modbus (MODBUSConfigurator, BMS, PLC) nu comunică în același timp cu gateway-ul.

### Toate atributele Gear 0–63 raportează `--` după punerea în funcțiune

1. Măsurați tensiunea DALI la dispozitivul cel mai îndepărtat de sursa de alimentare — trebuie să fie peste 9,5 V. Dacă este mai mică, magistrala este prea lungă pentru secțiunea cablului (consultați tabelul cu lungimile cablului DALI de mai sus). Împărțiți magistrala în două segmente cu o a doua sursă de alimentare.
2. Rulați din nou asistentul după acțiunea modulului **Resetare adrese scurte** (*Confirm* = *Yes*). Căutarea găsește doar dispozitivele *fără* adresă scurtă, așa că dispozitivele care încă au o adresă programată anterior nu sunt readresate decât dacă resetați mai întâi.
3. Căutați bucle în cablaj. DALI nu tolerează inele; întrerupeți orice buclă găsită și refaceți terminarea ambelor capete libere.

### Setare Slave ID nu schimbă adresa

1. Confirmați că pe gateway este `DIP4 = OFF`. Când `DIP4 = ON`, hardware-ul forțează Unit ID 255, indiferent de valoarea din FLASH.
2. Confirmați că gateway-ul chiar a repornit după acțiune (LED-urile gateway-ului se sting pentru scurt timp). Dacă nu a repornit, declanșați manual **Resetare gateway**.
3. Importați din nou șablonul cu noul parametru de import `SlaveId` — modulul importat anterior încă interoghează la adresa veche.

### Comunicația funcționează scurt timp, apoi se întrerupe

1. Verificați că `RS485 GND` este conectat între gateway și comunul sursei de alimentare TapHome. GND-ul lipsă este cea mai frecventă defecțiune RS-485.
2. Verificați terminarea — 120 Ω la ambele capete ale magistralei RS-485. Pentru RTU-over-TCP printr-un convertor serial, asigurați-vă că acesta transmite cadre RTU nemodificate, nu în modul TCP brut, și că pauza dintre caractere pe partea serială corespunde temporizării 9600 baud 8N1.
3. Reduceți numărul de interogări DALI paralele — gateway-ul serializează tranzacțiile DALI și nu arbitrează între mai mulți masteri Modbus.

## Dispozitive disponibile 1

Aceste dispozitive apar în TapHome după import.

Resi Dali - Configurare Modul

Atribute de service

|          |                                                                                                                                                    |
|----------|----------------------------------------------------------------------------------------------------------------------------------------------------|
| Slave ID | Citește Unit ID-ul Modbus salvat în registrul FLASH H:65221 — folosit pentru verificarea adresei curente a gateway-ului                            |
| Gear 0   | Interogarea tipului de dispozitiv DALI la adresa scurtă 0 — returnează DT{n} când răspunde un dispozitiv de comandă sau -- când adresa este liberă |
| Gear 1   | Interogarea tipului de dispozitiv DALI la adresa scurtă 1 — returnează DT{n} sau --                                                                |
| Gear 2   | Interogarea tipului de dispozitiv DALI la adresa scurtă 2 — returnează DT{n} sau --                                                                |
| Gear 3   | Interogarea tipului de dispozitiv DALI la adresa scurtă 3 — returnează DT{n} sau --                                                                |
| Gear 4   | Interogarea tipului de dispozitiv DALI la adresa scurtă 4 — returnează DT{n} sau --                                                                |
| Gear 5   | Interogarea tipului de dispozitiv DALI la adresa scurtă 5 — returnează DT{n} sau --                                                                |
| Gear 6   | Interogarea tipului de dispozitiv DALI la adresa scurtă 6 — returnează DT{n} sau --                                                                |
| Gear 7   | Interogarea tipului de dispozitiv DALI la adresa scurtă 7 — returnează DT{n} sau --                                                                |
| Gear 8   | Interogarea tipului de dispozitiv DALI la adresa scurtă 8 — returnează DT{n} sau --                                                                |
| Gear 9   | Interogarea tipului de dispozitiv DALI la adresa scurtă 9 — returnează DT{n} sau --                                                                |
| Gear 10  | Interogarea tipului de dispozitiv DALI la adresa scurtă 10 — returnează DT{n} sau --                                                               |
| Gear 11  | Interogarea tipului de dispozitiv DALI la adresa scurtă 11 — returnează DT{n} sau --                                                               |
| Gear 12  | Interogarea tipului de dispozitiv DALI la adresa scurtă 12 — returnează DT{n} sau --                                                               |
| Gear 13  | Interogarea tipului de dispozitiv DALI la adresa scurtă 13 — returnează DT{n} sau --                                                               |
| Gear 14  | Interogarea tipului de dispozitiv DALI la adresa scurtă 14 — returnează DT{n} sau --                                                               |
| Gear 15  | Interogarea tipului de dispozitiv DALI la adresa scurtă 15 — returnează DT{n} sau --                                                               |
| Gear 16  | Interogarea tipului de dispozitiv DALI la adresa scurtă 16 — returnează DT{n} sau --                                                               |
| Gear 17  | Interogarea tipului de dispozitiv DALI la adresa scurtă 17 — returnează DT{n} sau --                                                               |
| Gear 18  | Interogarea tipului de dispozitiv DALI la adresa scurtă 18 — returnează DT{n} sau --                                                               |
| Gear 19  | Interogarea tipului de dispozitiv DALI la adresa scurtă 19 — returnează DT{n} sau --                                                               |
| Gear 20  | Interogarea tipului de dispozitiv DALI la adresa scurtă 20 — returnează DT{n} sau --                                                               |
| Gear 21  | Interogarea tipului de dispozitiv DALI la adresa scurtă 21 — returnează DT{n} sau --                                                               |
| Gear 22  | Interogarea tipului de dispozitiv DALI la adresa scurtă 22 — returnează DT{n} sau --                                                               |
| Gear 23  | Interogarea tipului de dispozitiv DALI la adresa scurtă 23 — returnează DT{n} sau --                                                               |
| Gear 24  | Interogarea tipului de dispozitiv DALI la adresa scurtă 24 — returnează DT{n} sau --                                                               |
| Gear 25  | Interogarea tipului de dispozitiv DALI la adresa scurtă 25 — returnează DT{n} sau --                                                               |
| Gear 26  | Interogarea tipului de dispozitiv DALI la adresa scurtă 26 — returnează DT{n} sau --                                                               |
| Gear 27  | Interogarea tipului de dispozitiv DALI la adresa scurtă 27 — returnează DT{n} sau --                                                               |
| Gear 28  | Interogarea tipului de dispozitiv DALI la adresa scurtă 28 — returnează DT{n} sau --                                                               |
| Gear 29  | Interogarea tipului de dispozitiv DALI la adresa scurtă 29 — returnează DT{n} sau --                                                               |
| Gear 30  | Interogarea tipului de dispozitiv DALI la adresa scurtă 30 — returnează DT{n} sau --                                                               |
| Gear 31  | Interogarea tipului de dispozitiv DALI la adresa scurtă 31 — returnează DT{n} sau --                                                               |
| Gear 32  | Interogarea tipului de dispozitiv DALI la adresa scurtă 32 — returnează DT{n} sau --                                                               |
| Gear 33  | Interogarea tipului de dispozitiv DALI la adresa scurtă 33 — returnează DT{n} sau --                                                               |
| Gear 34  | Interogarea tipului de dispozitiv DALI la adresa scurtă 34 — returnează DT{n} sau --                                                               |
| Gear 35  | Interogarea tipului de dispozitiv DALI la adresa scurtă 35 — returnează DT{n} sau --                                                               |
| Gear 36  | Interogarea tipului de dispozitiv DALI la adresa scurtă 36 — returnează DT{n} sau --                                                               |
| Gear 37  | Interogarea tipului de dispozitiv DALI la adresa scurtă 37 — returnează DT{n} sau --                                                               |
| Gear 38  | Interogarea tipului de dispozitiv DALI la adresa scurtă 38 — returnează DT{n} sau --                                                               |
| Gear 39  | Interogarea tipului de dispozitiv DALI la adresa scurtă 39 — returnează DT{n} sau --                                                               |
| Gear 40  | Interogarea tipului de dispozitiv DALI la adresa scurtă 40 — returnează DT{n} sau --                                                               |
| Gear 41  | Interogarea tipului de dispozitiv DALI la adresa scurtă 41 — returnează DT{n} sau --                                                               |
| Gear 42  | Interogarea tipului de dispozitiv DALI la adresa scurtă 42 — returnează DT{n} sau --                                                               |
| Gear 43  | Interogarea tipului de dispozitiv DALI la adresa scurtă 43 — returnează DT{n} sau --                                                               |
| Gear 44  | Interogarea tipului de dispozitiv DALI la adresa scurtă 44 — returnează DT{n} sau --                                                               |
| Gear 45  | Interogarea tipului de dispozitiv DALI la adresa scurtă 45 — returnează DT{n} sau --                                                               |
| Gear 46  | Interogarea tipului de dispozitiv DALI la adresa scurtă 46 — returnează DT{n} sau --                                                               |
| Gear 47  | Interogarea tipului de dispozitiv DALI la adresa scurtă 47 — returnează DT{n} sau --                                                               |
| Gear 48  | Interogarea tipului de dispozitiv DALI la adresa scurtă 48 — returnează DT{n} sau --                                                               |
| Gear 49  | Interogarea tipului de dispozitiv DALI la adresa scurtă 49 — returnează DT{n} sau --                                                               |
| Gear 50  | Interogarea tipului de dispozitiv DALI la adresa scurtă 50 — returnează DT{n} sau --                                                               |
| Gear 51  | Interogarea tipului de dispozitiv DALI la adresa scurtă 51 — returnează DT{n} sau --                                                               |
| Gear 52  | Interogarea tipului de dispozitiv DALI la adresa scurtă 52 — returnează DT{n} sau --                                                               |
| Gear 53  | Interogarea tipului de dispozitiv DALI la adresa scurtă 53 — returnează DT{n} sau --                                                               |
| Gear 54  | Interogarea tipului de dispozitiv DALI la adresa scurtă 54 — returnează DT{n} sau --                                                               |
| Gear 55  | Interogarea tipului de dispozitiv DALI la adresa scurtă 55 — returnează DT{n} sau --                                                               |
| Gear 56  | Interogarea tipului de dispozitiv DALI la adresa scurtă 56 — returnează DT{n} sau --                                                               |
| Gear 57  | Interogarea tipului de dispozitiv DALI la adresa scurtă 57 — returnează DT{n} sau --                                                               |
| Gear 58  | Interogarea tipului de dispozitiv DALI la adresa scurtă 58 — returnează DT{n} sau --                                                               |
| Gear 59  | Interogarea tipului de dispozitiv DALI la adresa scurtă 59 — returnează DT{n} sau --                                                               |
| Gear 60  | Interogarea tipului de dispozitiv DALI la adresa scurtă 60 — returnează DT{n} sau --                                                               |
| Gear 61  | Interogarea tipului de dispozitiv DALI la adresa scurtă 61 — returnează DT{n} sau --                                                               |
| Gear 62  | Interogarea tipului de dispozitiv DALI la adresa scurtă 62 — returnează DT{n} sau --                                                               |
| Gear 63  | Interogarea tipului de dispozitiv DALI la adresa scurtă 63 — returnează DT{n} sau --                                                               |
| Gear 58  |                                                                                                                                                    |
| Gear 59  |                                                                                                                                                    |
| Gear 60  |                                                                                                                                                    |
| Gear 61  |                                                                                                                                                    |
| Gear 62  |                                                                                                                                                    |
| Gear 63  |                                                                                                                                                    |

Acțiuni de service

|                                 |                                                                                                                                                                                              |
|---------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| Resetare gateway                | Scrie 1 în registrul H:6000 pentru a reporni gateway-ul RESI-DALI — necesar după schimbarea Slave ID-ului sau pentru a reface funcționarea modulului DALI după un scurtcircuit pe magistrală |
| Setare Slave ID                 | Scrie noul Modbus Unit ID în registrul FLASH H:65221 și declanșează o resetare, astfel încât gateway-ul repornește cu noua adresă (1–255, DIP4 trebuie să fie OFF)                           |
| Aprinderea tuturor lămpilor     | Scrie 0xFE în registrul de nivel broadcast DALI H:530 — aduce toate dispozitivele de comandă de pe magistrală la luminozitate maximă (test rapid de verificare la punerea în funcțiune)      |
| Stingerea tuturor lămpilor      | Scrie 0x00 în registrul de nivel broadcast DALI H:530 — oprește toate dispozitivele de comandă de pe magistrală                                                                              |
| ${xml\_reset\_short\_addresses} |                                                                                                                                                                                              |
| Delete short address            |                                                                                                                                                                                              |
| Change short address            |                                                                                                                                                                                              |

Atribute de service

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

Acțiuni de service

${xml\_reset\_gateway}

```taphome
modbusw(SH,6000,uint16,1)
```

${xml\_set\_slave\_id}

Parametri: ${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}

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

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

Parametri: 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);
```

Găsire dispozitive noi Comutator cu mai multe valori Citire și scriere

Asistent de punere în funcțiune care parcurge pas cu pas algoritmul de adresare aleatorie DALI 2.0, pentru a atribui adresele scurte 0–63 dispozitivelor de comandă

Registru: H:541 → H:542 UInt16 numeric

Valori / Stări: TERMINATE · ${xml\_start} · ${xml\_scan\_short\_address} · Set SEARCHADDR · COMPARE · PROGRAM SHORT ADDRESS · Check · Try again · ${xml\_finish}

Citirea stării comutatorului

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

Scrierea stării comutatorului

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

**Conexiune:** Modbus RTU • 9600 baud• 8N1 • Slave ID: $\[SlaveId]

Îmbunătățiri posibile (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

## Parametri de import

Introduceți aceste valori când importați XML-ul.

| Solicitat în aplicație | Implicit      |
|------------------------|---------------|
| Slave ID               | `255`         |
| Adresă IP              | `192.168.1.0` |

## Surse

- 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

Documentele producătorilor sunt © ale proprietarilor respectivi. Sunt furnizate așa cum au fost publicate de producător, doar ca referință.

## Documentație asociată

- [Modbus Integration](https://taphome.com/ro/compatibility/modbus-guide/)
- [Modbus](https://taphome.com/ro/docs/integration/modbus/)
- [Configurare simplă cu ajutorul șabloanelor](https://taphome.com/ro/docs/integration/modbus/templates/)
- [Scripturi Modbus și prefetch](https://taphome.com/ro/docs/script/modbus-scripts/)
- [Funcții Modbus](https://taphome.com/ro/docs/script/modbus/)
- [Tipuri de date Modbus](https://taphome.com/ro/docs/script/modbus-data-types/)

