--- title: "Resi Dali - Configurazione" description: "Assegna indirizzi brevi DALI 0–63 da TapHome tramite il gateway RESI-DALI-SIO o RESI-DALI-ETH su Modbus RTU, verifica i gear e testa ON/OFF broadcast." url: "https://taphome.com/it/compatibility/resi-dali-daliconfig/" language: it lastmod: 2026-11-15 generator: hugo ai: topics: ["modbus-rtu","lighting","dali","dali-2.0","rs485","din-rail","commissioning","addressing","gateway"] questions: ["Come assegno gli indirizzi brevi DALI da TapHome?","Come mettere in servizio i control gear DALI 2.0 con il gateway RESI-DALI-SIO?","Cosa fa il template Resi Dali - Configurazione di TapHome?","Come impostare il Modbus Slave ID su un RESI-DALI-SIO / RESI-DALI-ETH?","Come cablare il RESI-DALI-SIO a un bus DALI con alimentatore RESI-DALI-PS?","Qual è la differenza tra i template Resi Dali - Configurazione e il Resi Dali operativo?","Perché il template DaliConfig ha un parametro di importazione IP address su un gateway RTU?"] --- # Resi Dali - Configurazione Comunicazione: Modbus RTU - [Pagina prodotto RESI-DALI-SIO/ETH/PS](https://www.resi.cc/prestashop/en/home/1-resi-dali-sioethps.html) - [RESI Informatik & Automation](https://www.resi.cc) ## Guida all'integrazione 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. > [!NOTE] > 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, dimming dei gruppi e diagnostica per singolo gear. 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)](https://taphome.com/images/compatibility/resi-dali-daliconfig/wiring-sio_hu_1af043ee91b2b0ed.jpg) 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)](https://taphome.com/images/compatibility/resi-dali-daliconfig/wiring-eth_hu_4bf0a5e8d8724d0b.jpg) 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 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)](https://taphome.com/images/compatibility/resi-dali-daliconfig/wiring-dali-ps_hu_bea720a419338afa.jpg) 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). > [!WARNING] > **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: 1. Imposta `DIP4 = OFF` sul gateway in modo che l'Unit ID FLASH sia rispettato. 2. Importa il template in TapHome con `SlaveId = 255` (indirizzo corrente). 3. 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. 4. 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. > [!WARNING] > **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, attributi informativi del gateway e sette azioni a livello di gateway. ### Procedura guidata di messa in servizio — Find New Devices *Find New Devices* è un interruttore multi-value a nove stati che pilota l'algoritmo di indirizzamento casuale DALI 2.0 come macchina a stati. Ogni nome di stato corrisponde a una fase della sequenza di configurazione DALI 2.0; in ogni stato il template invia i frame DALI a 16 bit grezzi corretti a `H:541` / `H:542`, interroga lo stato DALI RX a `H:550` per la risposta del gateway e poi porta da solo l'interruttore allo stato successivo. | 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. La procedura guidata invia di nuovo entrambi i comandi prima di ogni nuovo ciclo di ricerca | | 2 | **Scansiona indirizzo breve** | Interroga gli indirizzi brevi 0–63 con `QUERY CONTROL GEAR PRESENT` (`0x91`) per trovare l'indirizzo breve più alto già in uso, così i nuovi gear vengono numerati dopo di esso. Saltato dopo **Reimposta indirizzi brevi** — la numerazione parte allora da 0 | | 3 | **Set SEARCHADDR** | Esegue l'intera ricerca binaria in un solo passo: carica i byte SEARCHADDR superiore/medio/inferiore (`0xB500/0xB300/0xB100`), invia `COMPARE` (`0xA900`) e dimezza la finestra di ricerca a 24 bit finché non è ristretta, poi prosegue con **Verifica** | | 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 successivo tramite `0xB7xx` e lo verifica (`0xB9xx`). Il gear poi lampeggia sul suo nuovo indirizzo breve (`RECALL MIN`, `RECALL MAX`, `RECALL MIN`) ed esce dalla ricerca (`WITHDRAW`, `0xAB00`); la procedura guidata prosegue con il ciclo successivo da **Avvio** | | 6 | **Verifica** | Conferma l'indirizzo casuale trovato con `COMPARE` all'estremo inferiore e superiore della finestra ristretta — una sola risposta porta a **PROGRAM SHORT ADDRESS**, una collisione o nessuna risposta a **Riprova** | | 7 | **Riprova** | Recupero da collisione / timeout — dimezza l'intervallo di ricerca corrente e riprova; quando l'intervallo è esaurito, un nuovo ciclo inizia con `INITIALISE` + `RANDOMISE` | | 8 | **Termina** | Raggiunto dopo tre cicli di ricerca senza un gear appena programmato, o quando tutti gli indirizzi brevi 0–63 sono in uso. Legge il byte di risultato DALI, emette un messaggio info/errore TapHome (`Search finished` in caso di successo) e lascia la procedura guidata | **Flusso tipico di messa in servizio:** 1. Alimenta il bus DALI (`RESI-DALI-PS`), cabla i gear in topologia ad albero e assicurati che nient'altro stia pilotando il bus. 2. (Opzionale ma consigliato) esegui prima l'azione del modulo **Reimposta indirizzi brevi** con *Confirm* = *Yes*, per partire da uno stato pulito senza gear indirizzati. 3. Seleziona **Avvio** — emette `INITIALISE` + `RANDOMISE` così ogni gear sceglie un nuovo indirizzo casuale a 24 bit. 4. L'interruttore poi passa da solo per **Scansiona indirizzo breve** → **Set SEARCHADDR** → **Verifica** → **PROGRAM SHORT ADDRESS** e torna su **Avvio** per il gear successivo. Ogni gear appena programmato lampeggia una volta sul suo nuovo indirizzo breve, il che mostra quale apparecchio ha ricevuto quale indirizzo. 5. Collisioni e timeout sono gestiti automaticamente da **Riprova**, senza alcun intervento dell'installatore. 6. Quando l'interruttore si ferma su **Termina**, leggi il messaggio info/errore, poi seleziona **TERMINATE** per chiudere la sessione di indirizzamento DALI. 7. 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). L'installatore deve comunque osservare il comportamento del bus DALI durante l'esecuzione (il lampeggio di conferma, il 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 Sette 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. - **Reimposta indirizzi brevi** — parametro *Confirm* (*Yes* / *No*). Con *Yes* invia `DTR0 = 0xFF` (`0xA3FF`) e un broadcast `SET SHORT ADDRESS`, così ogni gear sul bus perde il suo indirizzo breve; l'esecuzione successiva della procedura guidata numera quindi i gear dall'indirizzo breve 0. Con *No* non viene inviato nulla. - **Delete short address** — parametri *Short address* (0–63) e *Confirm* (*Yes* / *No*). Verifica con `QUERY CONTROL GEAR PRESENT` (`0x91`) che un gear risponda sull'indirizzo, invia `DTR0 = 0xFF` e `SET SHORT ADDRESS` a quell'indirizzo, poi verifica di nuovo e riporta `Address N deleted`, `Address N still answers`, `No gear answers on address N` o `Not confirmed`. - **Change short address** — parametri *Old short address* e *New short address* (0–63). Verifica con `QUERY CONTROL GEAR PRESENT` che il nuovo indirizzo sia libero e che sul vecchio risponda esattamente un gear, sposta il gear (`DTR0` = nuovo indirizzo, `SET SHORT ADDRESS` al vecchio indirizzo) e lo conferma sul nuovo indirizzo. Se più gear condividono il vecchio indirizzo, l'azione si interrompe e chiede di cancellare l'indirizzo ed eseguire la procedura guidata di indirizzamento. 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*. Altri sei attributi di servizio del modulo mostrano informazioni sul gateway: **Gateway firmware** (`H:65202`, come versione e valore hex grezzo), **Gateway software group** (`H:65201`), **Gateway hardware group** (`H:65200`), **Gateway firmware author** (`H:65203`), **Gateway DIP switches** (`H:10009`, lo stato dei DIP 1–4 come `1:… 2:… 3:… 4:…`) e **Gateway converter status** (`H:5050`); i valori di gruppo, autore e stato sono mostrati in hex. > [!TIP] > 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 1. 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. 2. Controlla il LED **ERR** del RESI-DALI-PS — se è acceso, il bus è in cortocircuito, sovraccarico o l'alimentatore stesso è guasto. 3. 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. 4. 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 1. 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. 2. Riesegui la procedura guidata dopo l'azione del modulo **Reimposta indirizzi brevi** (*Confirm* = *Yes*). La ricerca trova solo i gear *senza* indirizzo breve, quindi i gear che hanno ancora un indirizzo programmato in precedenza non vengono reindirizzati se non esegui prima il reset. 3. 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 1. Conferma `DIP4 = OFF` sul gateway. Quando `DIP4 = ON` l'hardware forza l'Unit ID 255 indipendentemente dal valore FLASH. 2. 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**. 3. 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 1. Controlla che `RS485 GND` sia collegato tra gateway e il comune dell'alimentatore TapHome. Un GND mancante è il guasto RS-485 più comune. 2. 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. 3. Riduci il numero di query DALI in parallelo — il gateway serializza le transazioni DALI e non arbitra tra più Modbus master. ## Dispositivi disponibili 1 Questi dispositivi compaiono in TapHome dopo l'importazione. 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 -- | | Gear 58 | | | Gear 59 | | | Gear 60 | | | Gear 61 | | | Gear 62 | | | Gear 63 | | 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 | | ${xml\_reset\_short\_addresses} | | | Delete short address | | | Change short address | | Attributi di servizio ${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("--")); ``` Azioni di servizio ${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); ``` Trova nuovi dispositivi Interruttore multivalore Lettura e scrittura 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\_finish} Lettura stato interruttore ```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); ``` Scrittura stato interruttore ```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); ``` **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 ## Parametri di importazione Inserisci questi valori quando importi l'XML. | Richiesto nell'app | Predefinito | |--------------------|---------------| | Slave ID | `255` | | Indirizzo IP | `192.168.1.0` | ## Fonti - 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 I documenti del produttore sono © dei rispettivi proprietari. Sono forniti così come pubblicati dal produttore, solo a titolo informativo. ## Documentazione correlata - [Modbus Integration](https://taphome.com/it/compatibility/modbus-guide/) - [Modbus - Configurazione](https://taphome.com/it/docs/integration/modbus/) - [Configurazione semplice utilizzando modelli](https://taphome.com/it/docs/integration/modbus/templates/) - [Script Modbus e prefetch](https://taphome.com/it/docs/script/modbus-scripts/) - [Funzioni Modbus](https://taphome.com/it/docs/script/modbus/) - [Tipi di dati Modbus](https://taphome.com/it/docs/script/modbus-data-types/)