# Rockwell EtherNet/IP

> Collegare i controllori Allen-Bradley su EtherNet/IP: ControlLogix, CompactLogix, PLC-5, SLC 500, MicroLogix e Micro800, i loro indirizzi di tag, i tipi di dato e il rilevamento di rete.

Il driver **Rockwell EtherNet/IP** parla con i controllori Allen-Bradley / Rockwell su
EtherNet/IP. I controllori ControlLogix e CompactLogix si indirizzano con il nome del
tag del controllore dichiarato nel progetto Logix, un Micro800 con il nome della sua
variabile globale, e un PLC-5, SLC 500 o MicroLogix con un indirizzo di file dati,
senza alcuna mappa di registri di mezzo. Aggiungi un dispositivo sotto il driver
Rockwell EtherNet/IP nel [Connector](connector) e scegli la sua **Famiglia del
controllore**; il pannello mostra solo i campi che quella famiglia usa.

## Famiglie di controllore {#controller-families}

La **Famiglia del controllore** del dispositivo decide come si raggiunge il controllore
e come si indirizzano i suoi tag:

| Famiglia del controllore | Controllori | I tag si indirizzano con | Slot del telaio |
| --- | --- | --- | --- |
| **ControlLogix / CompactLogix** | ControlLogix, CompactLogix | **Tag del controllore**, il nome del tag | sì |
| **PLC-5** | PLC-5 con porta Ethernet (PLC-5/20E, /40E, /80E) | **Indirizzo di file dati**, come `N7:0` | no |
| **SLC 500** | SLC 5/05 | **Indirizzo di file dati** | no |
| **MicroLogix** | MicroLogix 1100 e 1400, e gli altri tramite un 1761-NET-ENI | **Indirizzo di file dati** | no |
| **Micro800** | Micro820, Micro850, Micro870 | **Tag del controllore**, il nome di una variabile globale | no |

ControlLogix / CompactLogix è il valore predefinito, e un dispositivo creato prima che
il campo esistesse è uno di questi, quindi legge esattamente come ha sempre fatto. Solo
un controllore ControlLogix o CompactLogix si raggiunge attraverso il bus di fondo in
uno slot: ogni altra famiglia risponde sulla propria porta Ethernet, e il suo
dispositivo non ha il campo **Slot del telaio**. Un rilevamento legge la famiglia
nell'identità del controllore, quindi un controllore trovato arriva con la famiglia già
scelta.

## Connessione {#connection}

| Campo | Significato | Predefinito |
| --- | --- | --- |
| **Indirizzo host** | Indirizzo IP o nome host della porta Ethernet del controllore. | vuoto |
| **Famiglia del controllore** | La famiglia a cui appartiene il controllore; decide i campi qui sotto e come si indirizzano i tag. | ControlLogix / CompactLogix |
| **Slot del telaio** | Solo ControlLogix / CompactLogix: in quale posizione del telaio è alloggiato il controllore, contando da 0. | 0 |
| **Intervallo di interrogazione (ms)** | Il periodo di lettura valido per tutto il dispositivo, per i tag che non lo ridefiniscono. | 1.000 |

Non c'è alcun campo per la porta: EtherNet/IP usa la sua porta TCP standard 44818. Il
percorso CIP è il bus di fondo più lo **Slot del telaio**, quindi un controllore
alloggiato in qualunque posizione del telaio è raggiungibile; un controllore rilevato
parte dallo slot 0 e il campo è dove lo si corregge. Non c'è alcun campo per il telaio:
un percorso CIP non porta un numero di telaio. Le richieste scadono dopo 10 secondi.
L'intestazione del dispositivo mostra l'endpoint composto, per esempio
`eip://192.168.0.10:0`, dove il numero dopo l'indirizzo è lo slot.

Un controllore di qualsiasi altra famiglia non porta uno slot, e la sua intestazione
nomina invece la famiglia, per esempio `eip://192.168.0.20?family=slc500`.

Ogni tag può impostare il proprio **Intervallo di interrogazione (ms)**; un valore di
tag pari a 0 ricade sull'intervallo del dispositivo.

## Indirizzamento {#addressing}

Un tag Rockwell viene indirizzato da due campi nella scheda Sorgente del tag:

| Campo | Significato | Valori accettati | Predefinito |
| --- | --- | --- | --- |
| **Tag del controllore** | Il nome del tag come è dichiarato nel controllore. Obbligatorio. | testo libero | vuoto |
| **Scostamento nel tag (byte, bit per BOOL)** | Dove il valore si trova dentro i dati di quel tag: uno scostamento in byte, oppure uno scostamento in bit per i tag Boolean. | 0–255 | 0 |

Il driver apre il tag del controllore indicato e prende il valore dal suo buffer di
dati allo scostamento. Per un semplice tag atomico lo scostamento resta 0. È lo
scostamento che permette a un solo tag del controllore di servire più canali: un DINT
all'inizio di una struttura ha scostamento 0, il REAL quattro byte dopo ha scostamento
4, e per un tag Boolean lo scostamento conta bit invece di byte.

| Per leggere | Tag del controllore | Scostamento | Tipo di dato |
| --- | --- | --- | --- |
| Un DINT `Counter` di ambito controllore | `Counter` | 0 | Int32 |
| Un DINT di ambito programma in `Main` | `Program:Main.Counter` | 0 | Int32 |
| Un elemento di array REAL `Temps[2]` | `Temps[2]` | 0 | Float |
| Un elemento di array BOOL `Flags[5]` | `Flags[5]` | 0 | Boolean |
| Il secondo DINT dentro la struttura `Recipe` | `Recipe` | 4 | Int32 |
| Il bit 3 dei dati in `Flags` | `Flags` | 3 | Boolean |

In un array BOOL l'indice indica il BOOL, non la parola a 32 bit del
controllore: `Flags[5]` è il BOOL 5, e uno scostamento in bit conta a partire
dal BOOL indicato, quindi `Flags[5]` con scostamento 2 è il BOOL 7.

Il nome arriva al controllore per intero, punti compresi, e una lettura e una
scrittura dello stesso tag finiscono nello stesso posto. È questo che fa funzionare un
nome di ambito programma come `Program:Main.Counter`. Un percorso di membro con il
punto (`MyUdt.Member`) viene risolto dal controllore quando il controllore pubblica
quel membro per nome; dove non lo fa, nomina il tag di base di ambito controllore e
raggiungi quello che ha dentro con lo scostamento in byte, che funziona sempre. La riga
in sola lettura **Indirizzo di origine (bus)** della scheda Sorgente mostra l'indirizzo
composto mentre modifichi.

Un Micro800 si indirizza allo stesso modo, con il nome di una variabile globale come
`Level`: non ha tag con ambito di programma da nominare.

### Indirizzi di file dati {#data-file-addresses}

Un tag di un PLC-5, SLC 500 o MicroLogix si indirizza con un solo campo, **Indirizzo di
file dati**: la lettera e il numero del file, i due punti e l'elemento, poi un membro
dopo un punto o un bit dopo una barra. Non c'è un campo per lo scostamento, perché
l'indirizzo nomina da sé il proprio elemento, membro e bit, e il campo rifiuta mentre
scrivi un indirizzo che il driver non sa leggere, dicendo perché.

| File | Esempi | Legge | Tipo di dato |
| --- | --- | --- | --- |
| Intero (N) | `N7:0`, `N7:0/15` | una parola di 16 bit, o uno dei suoi bit | Int16 o UInt16; Boolean per un bit |
| Bit (B) | `B3:0`, `B3:0/2` | una parola di 16 bit, o uno dei suoi bit | Int16 o UInt16; Boolean per un bit |
| Virgola mobile (F) | `F8:1` | un valore in virgola mobile a 32 bit | Float |
| Intero lungo (L) | `L9:0` | un intero a 32 bit | Int32 o UInt32 |
| Temporizzatore (T) | `T4:0.ACC`, `T4:0.PRE`, `T4:0.DN` | ACC o PRE, o il bit EN, TT o DN | Int16 o UInt16; Boolean per un bit |
| Contatore (C) | `C5:0.ACC`, `C5:0.PRE`, `C5:0.DN` | ACC o PRE, o il bit CU, CD, DN, OV o UN | Int16 o UInt16; Boolean per un bit |
| Controllo (R) | `R6:0.LEN`, `R6:0.POS` | LEN o POS | Int16 o UInt16 |
| Stato (S) | `S:1`, `S:1/15` | una parola del file di stato, o uno dei suoi bit | Int16 o UInt16; Boolean per un bit |
| Ingresso (I), uscita (O) | `I:0`, `I:0/1`, `O:0/1` | una parola dell'immagine degli ingressi o delle uscite, o uno dei suoi bit | Int16 o UInt16; Boolean per un bit |

Il **Tipo di dato** offerto segue il file, e scrivere un indirizzo il cui file non
contiene il tipo del tag lo cambia in quello del file. I file di stato, degli ingressi e
delle uscite si possono scrivere senza il loro numero, come li scrive il software di
programmazione; il driver li invia come `S2:1`, `I1:0/1` e `O0:0/1`, e la riga
**Indirizzo di origine (bus)** lo mostra. In un indirizzo di ingresso o di uscita,
l'elemento è la posizione della parola nell'immagine: gli ingressi integrati di un
MicroLogix vanno da `I:0/0` in poi. Un elemento di temporizzatore, contatore o
controllo si legge tramite uno dei suoi membri, mai per intero, e i file di stringa,
ASCII, BCD, messaggio e PID non si leggono. Un PLC-5 numera ingressi e uscite in
ottale, e il driver non legge questa numerazione, quindi i suoi file I e O vengono
rifiutati: leggi un valore del genere tramite un file dati in cui il programma lo
copia. Se un file esiste si sa solo leggendolo: un file che il controllore non ha
(`N9:0` senza N9) si legge come errore dalla prima lettura di quel tag, e tutti gli
altri tag del dispositivo continuano a leggere.

## Tipi di dato {#data-types}

Ogni tipo atomico CIP è disponibile come **Tipo di dato** di un tag:

| Tipo di dato | Tipo CIP | Dimensione |
| --- | --- | --- |
| Boolean | BOOL | 1 bit allo scostamento in bit |
| SByte | SINT | 1 byte |
| Byte | USINT | 1 byte |
| Int16 | INT | 2 byte |
| UInt16 | UINT | 2 byte |
| Int32 | DINT | 4 byte |
| UInt32 | UDINT | 4 byte |
| Int64 | LINT | 8 byte |
| UInt64 | ULINT | 8 byte |
| Float | REAL | 4 byte |
| Double | LREAL | 8 byte |

Le strutture e gli UDT non sono supportati: si possono leggere o scrivere solo i tipi
atomici qui sopra, ed è per questo che esiste lo scostamento in byte, per raggiungere i
membri al loro interno. String manca deliberatamente dal selettore: una STRING Logix
non è un tipo atomico ma una struttura fatta di una lunghezza e di un array di 82 byte,
e il driver non la sa né leggere né scrivere. L'ordine dei byte sul bus è il
little-endian proprio di CIP e viene gestito automaticamente; non c'è alcuna opzione
sull'ordine dei byte.

Su un PLC-5, SLC 500 o MicroLogix il tipo segue invece il file dati, come mostra la
tabella degli indirizzi di file dati qui sopra.

## Scritture {#writes}

I tag il cui **Accesso** è Lettura e scrittura oppure Sola scrittura si possono scrivere. Una
scrittura invia il valore richiesto e nient'altro, così un bit o un membro che cambia nel
controllore nello stesso istante non viene mai riportato a com'era un momento prima:

| Il tag indirizza | Che cosa invia la scrittura |
| --- | --- |
| Un tag atomico completo (scostamento 0 e la dimensione del tag stesso), oppure un tag BOOL | Il valore, a quel tag |
| Un bit di un tag di tipo intero (`Flags`, scostamento 3, Boolean) | Solo quel bit, come `Flags.3`: il controllore lo cambia sul posto e lascia gli altri bit come sono |
| Un elemento di un array BOOL (`Flags[5]`, Boolean) | Solo quel BOOL, come bit 5 della prima parola dell'array (`Flags[0].5`): il controllore lo cambia sul posto e lascia gli altri BOOL della parola come sono |
| Un valore dentro una struttura (`Recipe`, scostamento 4) | Solo quel membro, per nome (`Recipe.Speed`), trovato nella definizione della struttura che il controllore pubblica |

Una scrittura che si potrebbe fare solo rimandando indietro il resto del tag viene
rifiutata, e il motivo nomina l'indirizzo: una parte di un tag atomico (un Int16 allo
scostamento 2 di un DINT), un bit di un REAL, oppure uno scostamento dove nessun membro
della struttura comincia con la dimensione del valore. In quel caso indirizza il valore con
il suo nome, per esempio `Recipe.Speed` con scostamento 0. Il driver stabilisce dove
arrivano le scritture di un tag alla sua prima scrittura e lo tiene finché il dispositivo
resta collegato. Un tag nuovo nasce Sola lettura.

Un indirizzo di file dati si scrive così come è nominato: una parola, un valore in
virgola mobile o un membro per intero, e un bit (`B3:0/2`, `T4:0.DN`) da solo, che
il controllore cambia sul posto lasciando gli altri bit della sua parola come sono.

## Rilevamento {#discovery}

Il pulsante Rileva del Connector diffonde una richiesta CIP List Identity su **ogni
rete su cui questo computer si trova** e continua ad ascoltare finché non passano 10
secondi senza una nuova risposta. La scansione nomina quelle reti mentre gira, così un
risultato pari a zero dice dove la domanda è andata davvero: una stazione con
adattatori virtuali per macchine, WSL o una VPN ha spesso più reti di quante
l'operatore si aspetti, e i candidati possono arrivare da una di quelle.

Le interfacce che non possono portare la richiesta vengono saltate: tutto ciò che non è
attivo, gli adattatori di loopback e di tunnel, e un indirizzo che l'interfaccia si è
data da sé perché nessuno ha risposto al DHCP (169.254.x.x). Solo una risposta che sia
la risposta di identità di un controllore diventa un dispositivo candidato, chiamato
`eip://` più il suo indirizzo; qualunque altra cosa risponda sulla porta EtherNet/IP
viene ignorata e detta nel diario. Un controllore Omron risponde alla stessa richiesta e
viene anch'esso lasciato fuori, con una riga propria nel diario: un controllore NJ, NX o NY
viene offerto dalla scansione del driver [Omron](driver-omron#discovery). Per ogni candidato la scansione legge poi l'elenco
dei tag di ambito controllore e offre i suoi tag atomici come canali candidati,
ciascuno con scostamento 0.
Un array di un tipo atomico viene offerto come il suo primo elemento, in quel
tipo (`Temps[0]`, oppure `Grid[0,0]` con due dimensioni), e un array BOOL come
un Boolean sul suo primo BOOL (`Flags[0]`).

Il rilevamento scarta quello che il driver non può interrogare: i tag di struttura e di
UDT (STRING Logix comprese) vengono lasciati cadere, e le voci `Program:`, `Task:` e
`Map:` vengono saltate. Un controllore su una rete su cui questo computer non si trova
non risponde alla diffusione; aggiungilo a mano.
Nemmeno un tag di qualunque altro tipo, come un tipo di sistema, viene offerto,
e il diario lo dice.

L'identità con cui un controllore risponde porta il suo numero di catalogo, che nomina
la sua famiglia: un PLC-5, SLC 500, MicroLogix o Micro800 arriva con la famiglia scelta
e con l'indirizzo che la nomina (`eip://192.168.0.20?family=micrologix`). Un PLC-5,
SLC 500 o MicroLogix non pubblica alcun elenco di tag, quindi arriva senza canali
candidati e i suoi tag si scrivono per indirizzo di file dati; l'elenco di tag di un
Micro800 si legge come quello di un Logix.

Un controllore Logix o Micro800 che c'è già rilegge il suo elenco dei tag dalla sua stessa pagina: **Rileva tag**, nell'intestazione della sua scheda **Tag**, offre solo i tag del controllore per cui non ha ancora un tag, confrontati per nome senza distinguere maiuscole e minuscole. Un controllore a file di dati non ha un elenco da leggere e non mostra Rileva tag (vedere [Rilevare i tag di un dispositivo](connector-discovery#discovering-a-devices-tags)).

## Buono a sapersi {#good-to-know}

- Ogni richiesta al controllore scade dopo 10 secondi, e la finestra di ascolto del
  rilevamento si chiude dopo 10 secondi di silenzio.
- Il driver apre ogni tag del controllore una volta sola e lo tiene aperto finché il
  dispositivo resta connesso, così un controllore con decine di tag viene letto sulle
  sessioni che ha già, invece di aprirne e chiuderne una per ogni lettura. Una lettura che
  fallisce lascia andare il proprio tag, e quella dopo lo riapre per nome.
- Rinominare un tag nel progetto Logix rompe il canale in silenzio; il tag legge allora
  cattiva qualità finché il nome configurato non torna a corrispondere.