# Mitsubishi MC

> Collegare i PLC Mitsubishi MELSEC con il protocollo MC (trama 3E) - codici di dispositivo, numerazione decimale ed esadecimale, e lunghezze di lettura.

Il driver **Mitsubishi MC** parla con i PLC Mitsubishi MELSEC con il protocollo MC,
usando la trama binaria 3E su TCP, cioè la trama che parlano le serie Q, L e iQ. I
valori si indirizzano con la familiare notazione di dispositivo MELSEC: un codice di
dispositivo più un numero, come `D100` oppure `M50`. Aggiungi un dispositivo sotto il
driver Mitsubishi MC nel [Connector](connector); il pannello mostra solo i campi che
questo protocollo usa.

## Connessione {#connection}

| Campo | Significato | Predefinito |
| --- | --- | --- |
| **Indirizzo host** | Indirizzo IP o nome host dell'interfaccia Ethernet del PLC. | vuoto |
| **Porta** | La porta TCP della connessione con protocollo MC, da 1 a 65535. Un campo vuoto mostra 5007 in grigio e il dispositivo viene chiamato su di essa; un dispositivo salvato con 0 si legge allo stesso modo. | 5007 |

L'intestazione del dispositivo mostra l'endpoint composto, per esempio
`mcp://192.168.0.20:5007`. Per questo driver non ci sono campi per l'intervallo di
interrogazione: i suoi tag vengono letti una volta al secondo. Dalla parte del PLC serve
una connessione con protocollo MC (SLMP), TCP e binaria, sulla porta scelta:
[Preparare il PLC](#prepare-the-plc) dice dove si crea.

## Preparare il PLC {#prepare-the-plc}

Una CPU MELSEC serve il protocollo MC solo su una connessione creata dal suo progetto, e rifiuta
una scrittura mentre è in RUN, a meno che la sua porta Ethernet non la consenta. Le impostazioni
si fanno nello strumento di ingegneria e si scrivono nella CPU con i suoi parametri (**Online >
Write to PLC**); la CPU le legge all'avvio, quindi dopo occorre resettarla o spegnerla e
riaccenderla.

| Impostazione | GX Works3 (iQ-R, iQ-F) | GX Works2 (Q, L) | Senza di essa |
| --- | --- | --- | --- |
| Una connessione MC, TCP, sulla **Porta** del dispositivo | **Module Parameter > Ethernet Port > Basic Settings > External Device Configuration**: trascinare un **SLMP Connection Module** nella tabella, con Protocol TCP e la porta del dispositivo come **Port No.** | **PLC Parameter > Built-in Ethernet Port Setting > Open Setting**: una riga con Protocol TCP, **Open System** MC Protocol e la porta del dispositivo come **Host Station Port No.** | La CPU rifiuta la connessione su quella porta, e il dispositivo resta offline. |
| **Communication Data Code** in binario | **Module Parameter > Ethernet Port > Basic Settings**: **Binary**. | **PLC Parameter > Built-in Ethernet Port Setting**: **Binary Code**. | La CPU risponde in caratteri ASCII, o non risponde, e nessun tag legge. |
| Scrittura in RUN consentita | iQ-R: **Module Parameter > Ethernet Port > Basic Settings**, **Enable/Disable Online Change** su **Enable All (SLMP)**. | **PLC Parameter > Built-in Ethernet Port Setting**, **Enable online change (FTP, MC Protocol)** spuntato. | La CPU legge normalmente e rifiuta ogni scrittura mentre è in RUN, con il codice di fine 0x0055. |

Una CPU Q o L riserva a sé le porte da 5000 a 5009, quindi la sua connessione MC non può prendere
la 5007, il valore predefinito del dispositivo: darle un'altra porta, per esempio la 5010, e
scriverla nella **Porta** del dispositivo. GX Works2 può mostrare **Host Station Port No.** in
esadecimale, dove 5010 è 1392. Il codice dei dati è uno per tutta la porta Ethernet: un altro
programma che parla con la CPU in ASCII su quella porta deve passare anch'esso al binario.

Quando la CPU rifiuta la porta, risponde in ASCII o rifiuta una scrittura in RUN, la pagina del
dispositivo dice quale impostazione è, con questi passi e la porta che il dispositivo chiama, in
un avviso che scompare da solo appena la CPU accetta. Per una scrittura rifiutata in RUN nomina i
tag le cui scritture sono state rifiutate. Il diario tecnico e l'agente leggono gli stessi passi.

## Indirizzamento {#addressing}

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

| Campo | Significato | Valori accettati | Predefinito |
| --- | --- | --- | --- |
| **Indirizzo di dispositivo** | Codice di dispositivo MELSEC più numero, per esempio `D100`. Obbligatorio. | testo libero | vuoto |
| **Lunghezza di lettura (byte, vuoto = automatico)** | Quanti byte trasferire a ogni lettura. Vuoto dimensiona la lettura in base al tipo di dato. | da 1 in su, oppure vuoto | vuoto |

L'indirizzo non distingue maiuscole e minuscole e vince il codice corrispondente più
lungo, quindi `SD100` è il registro speciale 100, non il relè di passo `S`. Il numero è
**esadecimale** per i dispositivi che Mitsubishi numera in esadecimale, cioè X, Y, B,
W, SB, SW, DX, DY, e decimale per tutti gli altri (`X1F` è l'ingresso 0x1F). I codici
di dispositivo accettati:

| Codice | Dispositivo | Numerazione |
| --- | --- | --- |
| `M` | relè interno | decimale |
| `SM` | relè speciale | decimale |
| `L` | relè a ritenuta | decimale |
| `F` | segnalatore | decimale |
| `V` | relè di fronte | decimale |
| `S` | relè di passo | decimale |
| `X` | ingresso | esadecimale |
| `Y` | uscita | esadecimale |
| `B` | relè di collegamento | esadecimale |
| `SB` | relè speciale di collegamento | esadecimale |
| `DX` | ingresso diretto | esadecimale |
| `DY` | uscita diretta | esadecimale |
| `D` | registro dati | decimale |
| `SD` | registro speciale | decimale |
| `R` | registro di file | decimale |
| `ZR` | registro di file esteso | decimale |
| `W` | registro di collegamento | esadecimale |
| `SW` | registro speciale di collegamento | esadecimale |
| `Z` | registro indice | decimale |
| `TC` / `TS` / `TN` | bobina / contatto / valore corrente del temporizzatore | decimale |
| `SC` / `SS` / `SN` | bobina / contatto / valore corrente del temporizzatore a ritenuta | decimale |
| `CC` / `CS` / `CN` | bobina / contatto / valore corrente del contatore | decimale |

La libreria MC sottostante accetta anche i codici `TT`, `TM`, `CT`, `CM` e `A`. La riga
in sola lettura **Indirizzo di origine (bus)** della scheda Sorgente mostra l'indirizzo
composto mentre modifichi.

## Tipi di dato {#data-types}

Il selettore **Tipo di dato** offre i quattro tipi che il driver sa trasportare:

| Tipo di dato | Lunghezza di lettura automatica | Note |
| --- | --- | --- |
| Boolean | 1 byte | su un dispositivo a bit, il singolo relè nominato; su un dispositivo a parola, qualunque parola diversa da zero |
| Int32 | 4 byte | due parole consecutive a 16 bit, per esempio `D100`+`D101` |
| Float | 4 byte | due parole consecutive che contengono un IEEE a precisione singola |
| String | 16 byte | il testo fino al primo NUL del buffer di lettura |

I dati a parola arrivano nell'ordine little-endian nativo di MELSEC e vengono
decodificati automaticamente; non c'è alcuna opzione sull'ordine dei byte. Un valore a
32 bit occupa due dispositivi a parola consecutivi. Per una String più lunga di 16
caratteri, alza la **Lunghezza di lettura** per coprire il testo memorizzato. La
**Lunghezza di lettura** è un conteggio di byte e il protocollo trasferisce parole
intere a 16 bit, quindi una lunghezza dispari viene arrotondata per eccesso alla parola
che porta il suo ultimo byte.

I dispositivi a bit, quelli che il driver legge un relè per volta, sono `X`, `Y`, `M`,
`L`, `F`, `V`, `B`, `S`, `TS`, `TC`, `SS`, `SC`, `CS`, `CC`, `SB`, `DX` e `DY`. Lì un tag
Boolean risponde per l'indirizzo scritto e per nient'altro. Ogni altro codice è un
dispositivo a parola, compresi il valore corrente di un temporizzatore o di un contatore
(`TN`, `SN`, `CN`) e i registri di collegamento (`W`, `SW`), e lì decide l'intera parola:
`D100` che contiene `0x0100` si legge true.

Una lettura che il PLC rifiuta, come un indirizzo oltre la fine del suo intervallo,
lascia quel tag senza valore, e il suo errore nomina il codice di fine e il significato
che gli dà il manuale, per esempio
`end code 0xC056 (the request goes past the last address of the device)`. Tutti gli
altri tag del dispositivo continuano a leggere.

## Scritture {#writes}

I tag il cui **Accesso** è Lettura e scrittura oppure Sola scrittura si possono scrivere, sullo
stesso indirizzo di dispositivo che la lettura usa. Una scrittura Boolean su un
dispositivo a bit attiva o azzera il singolo relè nominato e non tocca nessuno dei suoi
vicini. Tutto il resto viene scritto come parole intere a 16 bit: due parole per Int32
e Float, una parola per un Boolean su un dispositivo a parola, e per String tutta la
**Lunghezza di lettura** del tag, davanti i byte UTF-8 del testo e dietro degli zeri,
arrotondata per eccesso all'ultima parola. Un testo più corto scritto sopra uno più
lungo sostituisce quindi l'intero valore, e del vecchio non sopravvive nulla. Un testo
che non sta nella lunghezza dichiarata viene rifiutato con la lunghezza nominata nel
diario, mai tagliato a misura. Un tag nuovo nasce Sola lettura.

Una scrittura che il PLC rifiuta torna rifiutata e nomina il codice di fine e il suo
significato allo stesso modo. Una scrittura rifiutata perché la CPU è in RUN (codice di fine
0x0055) la dice anche la pagina del dispositivo, con l'impostazione che la consente (vedere
[Preparare il PLC](#prepare-the-plc)).

## Rilevamento {#discovery}

In questo driver il protocollo MC non ha un rilevamento a diffusione, quindi il
Connector non mostra alcun pulsante Rileva. Aggiungi il dispositivo e i suoi indirizzi
a mano.

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

- L'interrogazione è fissa a un secondo per ogni tag di questo driver; i soliti campi
  per l'intervallo di interrogazione non vengono mostrati.
- Il driver parla solo la trama 3E binaria, mai l'ASCII: una connessione impostata sul
  codice ASCII non legge nulla (vedere [Preparare il PLC](#prepare-the-plc)).
- Un PLC irraggiungibile non costa nulla all'avvio: il dispositivo continua a
  ritentare in secondo piano e i suoi tag leggono cattiva qualità finché la connessione
  non si stabilisce.
- La connessione TCP ha 5 secondi per aprirsi, e ogni richiesta 10 secondi per avere
  risposta. Un PLC che accetta la connessione e non risponde in tempo viene disconnesso e
  ritentato come uno irraggiungibile; il suo errore nomina la porta e i due motivi
  consueti: una CPU Q o L con la porta impostata sul codice ASCII, che non risponde nulla a
  una richiesta binaria, o un'apparecchiatura che su quella porta non parla il protocollo MC.