RESI-DALI-SIO — Messa in Servizio DALI

Resi Dali - Configurazione

Modbus RTU

Inviato da

Ultimo aggiornamento: 04. 2026

Richiede gateway esterno
Resi RESI-DALI-PS — pagina prodotto

Il template Resi Dali - Configurazione è uno strumento di messa in servizio e indirizzamento monouso per il gateway Modbus-DALI RESI-DALI-SIO e RESI-DALI-ETH di RESI Informatik & Automation GmbH. Pilota l’algoritmo di indirizzamento casuale DALI 2.0 direttamente da TapHome per assegnare indirizzi brevi 0–63 ai control gear su un bus DALI appena cablato, interroga ogni indirizzo per il DALI device type e offre rapidi test broadcast ON/OFF — tutto il necessario per portare una nuova installazione a uno stato in cui le lampade possano essere controllate individualmente.

La comunicazione con il gateway avviene tramite Modbus RTU a 9600 baud 8N1. Il template espone anche un parametro di importazione IpAddress così lo stesso flusso funziona attraverso un serial-to-IP bridge (Moxa NPort, USR-TCP232) o un RESI-DALI-ETH configurato in modalità RTU-over-Ethernet trasparente.

Questo template è intenzionalmente solo di indirizzamento. Una volta assegnati gli indirizzi brevi, rimuovi il modulo Resi Dali - Configurazione e per il controllo quotidiano usa il template operativo gemello Resi Dali (Dali.xml) — dimming individuale delle lampade, gruppi, scene e controllo colore DT6/DT8 RGB/tunable-white. Il modulo di configurazione non è progettato per rimanere nel progetto dopo l’installazione iniziale.

Collegamento hardware

Il RESI-DALI-SIO è un gateway master DIN (17,5 × 90 × 56,4 mm, CEM17) che si colloca tra un host seriale/Ethernet e un bus di illuminazione DALI. Il gateway non alimenta il bus DALI — un alimentatore DALI compatibile (RESI-DALI-PS o qualsiasi alimentatore DALI conforme da 200 mA) è obbligatorio.

Collegamento del RESI-DALI-SIO (RS-485)

Schema di collegamento RESI-DALI-SIO — alimentatore DALI esterno (sopra) e con RESI-DALI-PS (sotto)

I terminali sul lato sinistro del RESI-DALI-SIO (dall’alto verso il basso): GND, +12..48V=, RS485 DATA+ (A+), RS485 DATA- (B-), RS485 GND, RS232 TX, RS232 RX, RS232 GND. I terminali del bus DALI sul lato opposto sono D+ / N/C / D- (morsetto USLIM a 3 poli, N/C rimane non collegato).

Per un’installazione TapHome usa l’interfaccia RS-485:

RS485 DATA+ (A+) → A+/D+ sul bus RS-485 TapHome
RS485 DATA- (B-) → B-/D- sul bus RS-485 TapHome
RS485 GND → GND sull’alimentatore TapHome (consigliato per comunicazione stabile)
+12..48V= / GND → alimentazione primaria 12–48 V DC

Collegamento del RESI-DALI-ETH (Ethernet)

Schema di collegamento RESI-DALI-ETH — alimentatore DALI esterno (sopra) e con RESI-DALI-PS (sotto)

La variante Ethernet ha gli stessi terminali del bus DALI (D+ / N/C / D-) e alimentazione primaria (GND, +12..48V=), più un singolo connettore RJ45 per Ethernet 10/100 Mbit. Le impostazioni IP di fabbrica predefinite sono 192.168.0.191 / 255.255.255.0 / 192.168.0.1 con Modbus Unit ID 255; le credenziali UI web sono RESI / RESI. TapHome parla con la variante ETH tramite Modbus TCP, o nella modalità RTU-over-Ethernet trasparente che questo template di configurazione si aspetta (vedi Configurazione sotto).

Alimentatore del bus DALI

RESI-DALI-PS — alimentazione del bus DALI autonoma (sopra) e in combinazione con un gateway SIO/ETH (sotto)

Il RESI-DALI-PS eroga fino a 200 mA sul bus DALI (corrente di cortocircuito ~225 mA, tensione bus tipica 14–18 V) e supporta fino a 64 reattori DALI 1.0 o control gear DALI 2.0 su una singola linea. Il lato primario accetta la stessa alimentazione 12–48 V DC dell’unità SIO/ETH. Gateway e alimentatore condividono la stessa coppia D+ / D- — l’alimentatore energizza il bus mentre il gateway legge e scrive i frame DALI.

Tre LED sull’alimentatore aiutano durante la messa in servizio: POWER (primaria 12–48 V OK, sempre acceso), DALI (lampeggia brevemente durante il traffico sul bus), ERR (acceso fisso in caso di guasto dell’alimentatore, cortocircuito DALI o sovraccarico del bus — deve essere spento durante il funzionamento normale).

Regole del bus DALI

Una linea DALI impone alcuni vincoli stringenti che influenzano direttamente il successo della messa in servizio:

Sezione conduttore	Lunghezza max cavo DALI
1,5 mm²	300 m
1,0 mm²	238 m
0,75 mm²	174 m
0,5 mm²	116 m

Il limite deriva dalla caduta di tensione massima consentita di 2 V sul cavo DALI. Altre regole:

Massimo 64 reattori DALI 1.0 e fino a 64 control gear DALI 2.0 per bus (spazi di indirizzo breve separati).
Solo topologia ad albero — niente anelli, niente loop.
Il conteggio effettivo dei gear dipende anche dalla corrente dell’alimentatore (tipicamente 200 mA sul RESI-DALI-PS, considera ~2 mA per gear più riserva).

Il RESI-DALI-PS (o un alimentatore DALI equivalente) è obbligatorio. Senza di esso il RESI-DALI-SIO/ETH non può pilotare il bus e la procedura guidata di messa in servizio andrà in timeout ad ogni passaggio. Se si utilizza un secondo alimentatore su una linea lunga, inserire un’induttanza DALI o suddividere il bus in segmenti galvanicamente separati.

Configurazione

Abilitare la comunicazione Modbus

Tutti i parametri seriali host sul RESI-DALI-SIO sono selezionati tramite un dip switch a 4 posizioni sul modulo. Il template TapHome fissa 9600 baud 8N1, quindi i dip switch devono essere impostati di conseguenza.

DIP1	DIP2	Velocità baud
OFF	OFF	9600 bd (richiesto da TapHome)
ON	OFF	19200 bd
OFF	ON	38400 bd
ON	ON	Usa la velocità baud programmata in FLASH (predefinita di fabbrica 57600 bd)

DIP4	Sorgente Modbus Unit ID
OFF	Registro FLASH `H:65221` — richiesto perché l’azione Set Slave ID abbia effetto
ON	Forzato a `255` (fallback hardware, valore FLASH ignorato)

DIP3 è un bit riservato specifico del prodotto; lascialo in posizione di fabbrica a meno che il manuale di servizio RESI non istruisca esplicitamente altrimenti. La parità è fissata a None (8N1) nei valori di default FLASH — il template non espone i registri di parità/stop bit.

Terminazione RS-485: termina il bus con 120 Ω su entrambe le estremità. TapHome Core fornisce una terminazione sui suoi terminali BUS; se il gateway RESI è l’ultimo dispositivo sulla linea, aggiungi una resistenza discreta da 120 Ω tra A+/B- sui suoi terminali RS-485.

Configurazione RTU-over-TCP: il template ha entrambi i parametri di importazione SlaveId e IpAddress perché lo stesso flusso di configurazione DALI funziona anche tramite un serial-to-IP bridge (Moxa NPort, USR-TCP232) o tramite il RESI-DALI-ETH in modalità RTU-over-Ethernet trasparente. In quel caso punta IpAddress all’IP del bridge / unità ETH e mantieni il resto delle impostazioni identiche alla variante RS-485. Per Modbus/TCP puro sul RESI-DALI-ETH sarebbe più naturale un template basato su TCP — il template DaliConfig presuppone specificamente traffico RTU a frame.

Impostare lo Slave ID del gateway

L’Unit ID predefinito di fabbrica è 255. Per cambiarlo:

Imposta DIP4 = OFF sul gateway in modo che l’Unit ID FLASH sia rispettato.
Importa il template in TapHome con SlaveId = 255 (indirizzo corrente).
Apri le impostazioni di servizio del modulo “Resi Dali - Configurazione” e attiva l’azione Set Slave ID con il nuovo ID desiderato (intervallo 1–255). L’azione scrive il valore nel registro H:65221 e attiva immediatamente un reset software tramite H:6000 = 1 così il gateway si riavvia con il nuovo indirizzo.
Rimuovi il template e reimportalo con SlaveId impostato sul nuovo valore. Il modulo può quindi essere usato per la messa in servizio.

L’azione Reset Gateway (scrive 1 in H:6000) è disponibile anche come passo di ripristino autonomo — utile dopo un cortocircuito del bus DALI che ha lasciato il motore DALI del gateway in uno stato degradato.

Un solo Modbus master alla volta. Né DALI né il bus Modbus RTU arbitrano tra master concorrenti. Se un PLC, BMS o strumento PC (ad esempio MODBUSConfigurator) sta anche interrogando il gateway durante la messa in servizio, la programmazione degli indirizzi brevi andrà in collisione e la procedura guidata riporterà errori.

Capacità del dispositivo

Il template è costruito attorno a un singolo modulo Modbus — Resi Dali - Configurazione — che raggruppa la procedura guidata di messa in servizio, una sonda DALI device type per ogni indirizzo breve 0–63 e quattro azioni a livello di gateway.

Procedura guidata di messa in servizio — Find New Devices

Find New Devices è un interruttore multi-value a dieci stati che pilota l’algoritmo di indirizzamento casuale DALI 2.0 in passi discreti. Ogni nome di stato corrisponde a una fase della sequenza di configurazione DALI 2.0; selezionando uno stato il template invia il frame DALI a 16 bit grezzi corretto a H:541 / H:542 e poi interroga lo stato DALI RX a H:550 per la risposta del gateway.

Passo	Stato	Cosa fa
0	TERMINATE	Frame DALI `TERMINATE` (`0xA100`) — interrompe la sessione di indirizzamento corrente e reimposta lo stato del gateway. Sempre sicuro da richiamare
1	Avvio	`INITIALISE` (`0xA5FF`) + `RANDOMISE` (`0xA700`) — commuta tutti i gear non indirizzati nel pool di indirizzamento e chiede a ogni gear di scegliere un indirizzo casuale a 24 bit
2	Scansiona indirizzo breve	Interroga lo slot di indirizzo breve successivo; restituisce il codice di stato 7 quando nessun gear risponde
3	Set SEARCHADDR	Carica i byte SEARCHADDR superiore/medio/inferiore (`0xB500/0xB300/0xB100`) per la ricerca binaria
4	COMPARE	Invia `COMPARE` (`0xA900`) e restringe la finestra di ricerca a 24 bit in base alla risposta
5	PROGRAM SHORT ADDRESS	Scrive l’indirizzo breve verificato tramite `0xB7xx` — il gear è ora indirizzato in modo permanente
6	Verifica	Verifica l’indirizzo programmato con un secondo `COMPARE` al `SEARCHADDRL` finale
7	Riprova	Recupero da collisione / timeout — dimezza l’intervallo di ricerca corrente e riprova
8	Reset indirizzi brevi	DALI `DTR = 0xFF` (`0xA3FF`) + broadcast `REMOVE SHORT ADDRESS` — cancella tutti gli indirizzi brevi esistenti, pronto per un re-indirizzamento completo
9	Termina	Legge il byte di risultato DALI, emette un messaggio info/errore TapHome e lascia la procedura guidata

Flusso tipico di messa in servizio:

Alimenta il bus DALI (RESI-DALI-PS), cabla i gear in topologia ad albero e assicurati che nient’altro stia pilotando il bus.
(Opzionale ma consigliato) esegui prima Reset indirizzi brevi, per partire da uno stato pulito senza gear indirizzati.
Esegui Avvio — emette INITIALISE + RANDOMISE così ogni gear sceglie un nuovo indirizzo casuale a 24 bit.
Esegui Scansiona indirizzo breve → Set SEARCHADDR → COMPARE → PROGRAM SHORT ADDRESS → Verifica in sequenza. Gli stati incapsulano la ricerca binaria DALI 2.0; ogni passo avanza l’algoritmo di una fase.
Se un passo segnala una collisione o un timeout, richiama Riprova e riesegui la sequenza compare/program.
Quando tutti i gear visibili sono stati programmati, esegui TERMINATE e poi Termina per uscire dalla procedura guidata in modo pulito.
Usa gli attributi di servizio Gear 0 … Gear 63 e le azioni Turn On / Off All Lamps per verificare che gli indirizzi brevi 0–N siano ora popolati (vedi sotto).

La procedura guidata è progettata per essere percorsa uno stato alla volta — il template non automatizza l’intero loop perché l’installatore deve osservare il comportamento del bus DALI (lampade che pulsano, ritmo del LED STATE sul gateway) per rilevare gear cablati male o mancanti.

Sonda DALI gear — Gear 0 … Gear 63

Ognuno dei 64 attributi di servizio Gear 0, Gear 1, … Gear 63 interroga un indirizzo breve DALI con il comando DALI 2.0 QUERY DEVICE TYPE (0x99). Internamente il template scrive (SA << 8) | 0x99 in H:511, interroga i bit 0–2 di H:550 finché arriva una risposta, poi rilegge il byte di risposta da H:511.

Possibili valori di ritorno nella UI di servizio TapHome:

DT{n} — un control gear è programmato a questo indirizzo e ha risposto con device type n. Valori tipici: DT0 (fluorescente), DT1 (emergenza), DT2 (HID), DT5 (0–10 V), DT6 (driver LED), DT7 (relè), DT8 (colore / tunable white), DT9 (sequencer).
-- — nessun gear è programmato a questo indirizzo o il gateway ha restituito il sentinel 0x8000 “no answer / already consumed”.

La sonda fornisce una rapida panoramica pass/fail di quali indirizzi brevi sono popolati dopo la messa in servizio e quali device type sono stati scoperti — questo è il passaggio primario di verifica prima di commutare il progetto al template Resi Dali operativo.

Azioni a livello di gateway

Quattro azioni di servizio sul modulo pilotano direttamente il gateway:

Reset Gateway — scrive 1 in H:6000 (DIP SWITCH / SOFTWARE RESET). Riavvia il gateway; utile dopo un cortocircuito del bus per ripristinare il motore DALI.
Set Slave ID — scrive il nuovo Unit ID (1–255) nel registro FLASH H:65221, poi resetta tramite H:6000. Richiede DIP4 = OFF per avere effetto.
Turn On All Lamps — scrive 0xFE (arc power 254 = 100 %) nel registro DALI broadcast level H:530. Accende ogni gear sul bus indipendentemente dall’indirizzo breve — una rapida conferma visiva che bus e alimentatore sono integri.
Turn Off All Lamps — scrive 0x00 in H:530, spegnendo ogni gear. Stesso percorso broadcast, valore opposto.

L’attributo di servizio Slave ID sul modulo rilegge l’Unit ID corrente dal registro FLASH H:65221 così che l’indirizzo attualmente programmato possa essere verificato prima di inviare Set Slave ID.

Esegui Turn On All Lamps immediatamente dopo il cablaggio, prima di avviare la procedura guidata di indirizzamento. Ogni gear alimentato e correttamente collegato sul bus si accenderà al 100 %, che è un modo molto rapido per individuare apparecchi mancanti o cablati male prima di spendere tempo sulla programmazione degli indirizzi brevi.

Risoluzione dei problemi

La procedura guidata va in timeout ad ogni passo

Verifica la tensione del bus DALI sui terminali dell’alimentatore — deve essere 11,5–22,5 V (tipicamente 14–16 V). Una lettura significativamente inferiore indica solitamente un cortocircuito DALI.
Controlla il LED ERR del RESI-DALI-PS — se è acceso, il bus è in cortocircuito, sovraccarico o l’alimentatore stesso è guasto.
Controlla il LED STATE del gateway — un ritmo lento da 1 s significa bus DALI integro, un ritmo veloce ~250 ms indica errore del bus, cortocircuito o alimentazione DALI mancante.
Assicurati che nessun altro Modbus master (MODBUSConfigurator, BMS, PLC) stia parlando con il gateway contemporaneamente.

Gear 0–63 riportano tutti `--` dopo la messa in servizio

Misura la tensione DALI sul gear più lontano dall’alimentatore — deve essere sopra 9,5 V. Se è inferiore, il bus è troppo lungo per la sezione del conduttore (vedi tabella lunghezze cavo DALI sopra). Suddividi il bus in due segmenti con un secondo alimentatore.
Riesegui la procedura guidata partendo da Reset indirizzi brevi. Non eseguire Avvio su un bus che contiene ancora gear precedentemente programmati se non esegui prima il reset — l’algoritmo trova solo i gear senza indirizzo breve.
Cerca loop nel cablaggio. DALI non tollera anelli; interrompi qualsiasi loop trovato e riterminazione entrambe le estremità aperte.

Set Slave ID non cambia l’indirizzo

Conferma DIP4 = OFF sul gateway. Quando DIP4 = ON l’hardware forza l’Unit ID 255 indipendentemente dal valore FLASH.
Conferma che il gateway si sia effettivamente riavviato dopo l’azione (i LED del gateway si spengono brevemente). Se non lo ha fatto, attiva manualmente Reset Gateway.
Reimporta il template con il nuovo parametro di importazione SlaveId — il modulo precedentemente importato sta ancora interrogando al vecchio indirizzo.

La comunicazione funziona brevemente poi fallisce

Controlla che RS485 GND sia collegato tra gateway e il comune dell’alimentatore TapHome. Un GND mancante è il guasto RS-485 più comune.
Verifica la terminazione — 120 Ω su entrambe le estremità del bus RS-485. Per RTU-over-TCP attraverso un serial bridge, assicurati che il bridge sia in modalità RTU a frame, non TCP raw, e che il gap inter-carattere sul lato seriale corrisponda alla temporizzazione 9600 baud 8N1.
Riduci il numero di query DALI in parallelo — il gateway serializza le transazioni DALI e non arbitra tra più Modbus master.

Dispositivi disponibili

Resi Dali - Configurazione Modulo

Attributi di servizio

Slave ID	Legge il Modbus Unit ID memorizzato nel registro FLASH H:65221 — usato per verificare l'indirizzo corrente del gateway
Gear 0	Sonda DALI device-type all'indirizzo breve 0 — restituisce DT{n} quando un control gear risponde, o -- quando l'indirizzo è libero
Gear 1	Sonda DALI device-type all'indirizzo breve 1 — restituisce DT{n} o --
Gear 2	Sonda DALI device-type all'indirizzo breve 2 — restituisce DT{n} o --
Gear 3	Sonda DALI device-type all'indirizzo breve 3 — restituisce DT{n} o --
Gear 4	Sonda DALI device-type all'indirizzo breve 4 — restituisce DT{n} o --
Gear 5	Sonda DALI device-type all'indirizzo breve 5 — restituisce DT{n} o --
Gear 6	Sonda DALI device-type all'indirizzo breve 6 — restituisce DT{n} o --
Gear 7	Sonda DALI device-type all'indirizzo breve 7 — restituisce DT{n} o --
Gear 8	Sonda DALI device-type all'indirizzo breve 8 — restituisce DT{n} o --
Gear 9	Sonda DALI device-type all'indirizzo breve 9 — restituisce DT{n} o --
Gear 10	Sonda DALI device-type all'indirizzo breve 10 — restituisce DT{n} o --
Gear 11	Sonda DALI device-type all'indirizzo breve 11 — restituisce DT{n} o --
Gear 12	Sonda DALI device-type all'indirizzo breve 12 — restituisce DT{n} o --
Gear 13	Sonda DALI device-type all'indirizzo breve 13 — restituisce DT{n} o --
Gear 14	Sonda DALI device-type all'indirizzo breve 14 — restituisce DT{n} o --
Gear 15	Sonda DALI device-type all'indirizzo breve 15 — restituisce DT{n} o --
Gear 16	Sonda DALI device-type all'indirizzo breve 16 — restituisce DT{n} o --
Gear 17	Sonda DALI device-type all'indirizzo breve 17 — restituisce DT{n} o --
Gear 18	Sonda DALI device-type all'indirizzo breve 18 — restituisce DT{n} o --
Gear 19	Sonda DALI device-type all'indirizzo breve 19 — restituisce DT{n} o --
Gear 20	Sonda DALI device-type all'indirizzo breve 20 — restituisce DT{n} o --
Gear 21	Sonda DALI device-type all'indirizzo breve 21 — restituisce DT{n} o --
Gear 22	Sonda DALI device-type all'indirizzo breve 22 — restituisce DT{n} o --
Gear 23	Sonda DALI device-type all'indirizzo breve 23 — restituisce DT{n} o --
Gear 24	Sonda DALI device-type all'indirizzo breve 24 — restituisce DT{n} o --
Gear 25	Sonda DALI device-type all'indirizzo breve 25 — restituisce DT{n} o --
Gear 26	Sonda DALI device-type all'indirizzo breve 26 — restituisce DT{n} o --
Gear 27	Sonda DALI device-type all'indirizzo breve 27 — restituisce DT{n} o --
Gear 28	Sonda DALI device-type all'indirizzo breve 28 — restituisce DT{n} o --
Gear 29	Sonda DALI device-type all'indirizzo breve 29 — restituisce DT{n} o --
Gear 30	Sonda DALI device-type all'indirizzo breve 30 — restituisce DT{n} o --
Gear 31	Sonda DALI device-type all'indirizzo breve 31 — restituisce DT{n} o --
Gear 32	Sonda DALI device-type all'indirizzo breve 32 — restituisce DT{n} o --
Gear 33	Sonda DALI device-type all'indirizzo breve 33 — restituisce DT{n} o --
Gear 34	Sonda DALI device-type all'indirizzo breve 34 — restituisce DT{n} o --
Gear 35	Sonda DALI device-type all'indirizzo breve 35 — restituisce DT{n} o --
Gear 36	Sonda DALI device-type all'indirizzo breve 36 — restituisce DT{n} o --
Gear 37	Sonda DALI device-type all'indirizzo breve 37 — restituisce DT{n} o --
Gear 38	Sonda DALI device-type all'indirizzo breve 38 — restituisce DT{n} o --
Gear 39	Sonda DALI device-type all'indirizzo breve 39 — restituisce DT{n} o --
Gear 40	Sonda DALI device-type all'indirizzo breve 40 — restituisce DT{n} o --
Gear 41	Sonda DALI device-type all'indirizzo breve 41 — restituisce DT{n} o --
Gear 42	Sonda DALI device-type all'indirizzo breve 42 — restituisce DT{n} o --
Gear 43	Sonda DALI device-type all'indirizzo breve 43 — restituisce DT{n} o --
Gear 44	Sonda DALI device-type all'indirizzo breve 44 — restituisce DT{n} o --
Gear 45	Sonda DALI device-type all'indirizzo breve 45 — restituisce DT{n} o --
Gear 46	Sonda DALI device-type all'indirizzo breve 46 — restituisce DT{n} o --
Gear 47	Sonda DALI device-type all'indirizzo breve 47 — restituisce DT{n} o --
Gear 48	Sonda DALI device-type all'indirizzo breve 48 — restituisce DT{n} o --
Gear 49	Sonda DALI device-type all'indirizzo breve 49 — restituisce DT{n} o --
Gear 50	Sonda DALI device-type all'indirizzo breve 50 — restituisce DT{n} o --
Gear 51	Sonda DALI device-type all'indirizzo breve 51 — restituisce DT{n} o --
Gear 52	Sonda DALI device-type all'indirizzo breve 52 — restituisce DT{n} o --
Gear 53	Sonda DALI device-type all'indirizzo breve 53 — restituisce DT{n} o --
Gear 54	Sonda DALI device-type all'indirizzo breve 54 — restituisce DT{n} o --
Gear 55	Sonda DALI device-type all'indirizzo breve 55 — restituisce DT{n} o --
Gear 56	Sonda DALI device-type all'indirizzo breve 56 — restituisce DT{n} o --
Gear 57	Sonda DALI device-type all'indirizzo breve 57 — restituisce DT{n} o --
Gear 58	Sonda DALI device-type all'indirizzo breve 58 — restituisce DT{n} o --
Gear 59	Sonda DALI device-type all'indirizzo breve 59 — restituisce DT{n} o --
Gear 60	Sonda DALI device-type all'indirizzo breve 60 — restituisce DT{n} o --
Gear 61	Sonda DALI device-type all'indirizzo breve 61 — restituisce DT{n} o --
Gear 62	Sonda DALI device-type all'indirizzo breve 62 — restituisce DT{n} o --
Gear 63	Sonda DALI device-type all'indirizzo breve 63 — restituisce DT{n} o --

Azioni di servizio

Reset Gateway	Scrive 1 nel registro H:6000 per riavviare il gateway RESI-DALI — richiesto dopo aver cambiato lo Slave ID o per ripristinare il motore DALI dopo un cortocircuito del bus
Set Slave ID	Scrive il nuovo Modbus Unit ID nel registro FLASH H:65221 e attiva un reset così il gateway si riavvia con il nuovo indirizzo (1–255, DIP4 deve essere OFF)
Turn On All Lamps	Scrive 0xFE nel registro DALI broadcast level H:530 — porta ogni control gear sul bus alla massima luminosità (rapido sanity test di messa in servizio)
Turn Off All Lamps	Scrive 0x00 nel registro DALI broadcast level H:530 — spegne ogni control gear sul bus

${resi_dali_configuration}

Attributi di servizio

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

Azioni di servizio

${xml_reset_gateway}

modbusw(SH,6000,uint16,1)

${xml_set_slave_id}

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

Trova nuovi dispositivi Interruttore multivalore

Procedura guidata di messa in servizio che percorre l'algoritmo di indirizzamento casuale DALI 2.0 per assegnare indirizzi brevi 0–63 ai control gear

Registro: H:541 → H:542 UInt16 numeric

Valori / Stati: TERMINATE · ${xml_start} · ${xml_scan_short_address} · Set SEARCHADDR · COMPARE · PROGRAM SHORT ADDRESS · Check · Try again · ${xml_reset_short_addresses} · ${xml_finish}

Trova nuovi dispositivi

Lettura stato interruttore

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

Scrittura stato interruttore

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

Connessione: Modbus RTU • 9600 baud• 8N1 • Slave ID: $[SlaveId]

Possibili miglioramenti (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

Scarica template

Fonti

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