ESP32 Modbus Master TCP: 7 passaggi

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:02

In questa classe, programmerai il processore ESP32 come Modbus TCP Master.

Useremo due dispositivi, che contengono questo processore: Moduino ESP32 e Pycom. Entrambi i dispositivi sono in esecuzione in ambiente MicroPytthon. Il nostro Modbus Slave sarà un computer PC con il software di simulazione Modbus in esecuzione su di esso.

Avrai bisogno:

• Dispositivo Moduino ESP32 o Moduino Pycom (controlla questo sito Web per saperne di più sul dispositivo Moduino ESP32 e questo per controllare il dispositivo Pycom)
• PC con sistema operativo Linux
• Porta RS-232/RS-485 nel computer o convertitore da USB a RS-232/RS-485

Passaggio 1: scaricare e avviare il simulatore slave Modbus TCP

Scarica il simulatore Modbus Slave da https://www.modbusdriver.com/diagslave.html. Quindi apri l'archivio scaricato e decomprimi la versione per il sistema operativo Linux.

Esegui il programma dalla console con l'argomento -p:

./diagslave -p

è una porta su cui funzionerà il server Modbus Slave. Per il protocollo Modbus è di default 502, ma puoi usarne un altro.

In Linux le porte inferiori a 1024 non possono essere utilizzate da programmi eseguiti da utenti normali (non con privilegi di root).

Ricorda quale porta stai utilizzando. Questo valore sarà necessario in seguito.

Passaggio 2: prepara il computer per la connessione al dispositivo

Avrai bisogno di alcuni programmi per effettuare la connessione al dispositivo e inviare file ad esso.

Installa l'ambiente Python e pip (se non ce l'hai):

apt-get install python3

apt-get install python3-dev curl "https://bootstrap.pypa.io/get-pip.py" -o "get-pip.py" python3 get-pip.py

Installa picocom:

apt-get install picocom

Questo programma è necessario per connettersi al dispositivo ed eseguire comandi su di esso. Installa mpfshell:

pip install mpfshell

Questo programma consente di inviare file al dispositivo.

Puoi anche installarlo dai sorgenti. Fare riferimento a questa pagina:

Passaggio 3: preparare il dispositivo e connettersi ad esso

Per collegare il dispositivo Moduino o Pycom al PC è necessaria una porta o un convertitore RS-232/RS-485. Controlla la versione del tuo dispositivo (quale tipo di porta utilizza) e trova la porta o il convertitore appropriato.

1. Connetti il dispositivo al PC
2. Quindi collegare l'alimentazione ad esso

Collegare il dispositivo al PC e quindi collegare l'alimentatore. Puoi anche collegare il cavo ethernet a Moduino ESP32 (se ha quella porta).

La connessione dovrebbe essere come nelle foto sopra

Trova il percorso per la porta, che viene utilizzata per la connessione del dispositivo. Può essere ad esempio: /dev/ttyS1, /dev/ttyUSB0.

Per i convertitori USB, il percorso conterrà la parola USB.

Puoi connetterti al dispositivo con il programma picocom:

picocom /dev/ttyUSB0 -b 115200

Il prompt dei comandi del dispositivo è simile a una di queste immagini qui sotto.

Moduino ESP32: Vedi qui

Moduino Pycom: Vedi qui

Passaggio 4: caricare la libreria master Modbus

github.com/pycom/pycom-modbus/Per comunicare con Modbus Slave è necessaria una libreria appropriata. Le librerie per Pycom non sono compatibili con Moduino. Controlla le istruzioni conformi al tuo dispositivo.

Chiudi picocom prima di inviare i file: premi Ctrl+A e poi i tasti Ctrl+X.

La libreria uModBus per Moduino ESP32 si basa sulla libreria pycom-modbus per Moduino Pycom. È modificato per funzionare su un normale dispositivo ESP32. Ha anche metodi close() aggiuntivi per le classi di connettori.

1) Modulo ESP32

Scarica la libreria da https://github.com/techbase123/micropython-modbus. Decomprimi l'archivio e invia tutti e 4 i file al dispositivo Moduino.

Usa mpfshell per caricarli. Esegui questo programma nella directory con quei file.

Connettiti al dispositivo eseguendo: QUESTO

ttyUSB0 è un nome della porta seriale a cui è connesso il dispositivo.

Cambia la directory in /flash/lib con il comando:

cd /flash/lib

Metti tutti i file con i comandi:

mettere uModBusConst.py

metti uModBusFunctions.py metti uModBusTCP.py metti uModBusSerial.py

ESEMPIO

Quindi esci dalla console con il comando exit e riavvia il dispositivo con il pulsante Reset.

2) Moduino Pycom

Scarica la libreria da https://github.com/pycom/pycom-modbus/. Decomprimi l'archivio e invia il contenuto della directory uModbus al dispositivo. Usa mpfshell per caricarli. Esegui questo programma nella directory con quei file.

Connettiti al dispositivo eseguendo:

apri ttyUSB0

ttyUSB0 è un nome della porta seriale a cui è connesso il dispositivo.

Cambia la directory in /flash/lib, crea la directory uModbus e inseriscila con i comandi:

cd /flash/libmd uModbus cd uModbus

Metti tutti i file con i comandi:

mettere const.py

put functions.py put tcp.py put serial.py

Quindi esci dalla console con il comando exit e riavvia il dispositivo con il pulsante Reset.

ESEMPIO

Passaggio 5: connettersi alla rete

I comandi per stabilire la connessione differiscono tra Moduino e Pycom.

Connettiti al dispositivo con picocom per eseguire i comandi appropriati. Puoi connettere il dispositivo Moduino alla rete via cavo o wireless. Gli esempi seguenti presuppongono che la rete abbia un server DHCP funzionante.

In altri casi, il dispositivo non riceverà l'indirizzo IP. Il supporto Wi-Fi è disponibile in ogni Moduino. La porta Ethernet è un'opzione e non tutti i dispositivi ce l'hanno.

1) Modulo ESP32

Connessione al WiFi

Eseguire i seguenti comandi sul dispositivo:

from netWiFi import netWiFiwifi = netWiFi(netWiFi. WIFI_STA, 'ESSID', 'PASS')wifi.start()

Sostituisci ESSID con il nome della tua rete WiFi e PASS con la relativa password.

Dopo un po' di tempo dall'esecuzione di start() dovresti ottenere un indirizzo IP che è stato assegnato al tuo dispositivo.

Connessione alla rete Ethernet

Collegare il dispositivo alla rete cablata con cavo ethernet.

Quindi esegui i seguenti comandi:

from netETH import netETHeth = netETH()eth.start()

Dopo un po' di tempo dall'esecuzione di start() dovresti ottenere l'indirizzo IP che è stato assegnato al tuo dispositivo.

2) Moduino Pycom

Connettiti al WiFi

Eseguire i seguenti comandi sul dispositivo:

from network import WLANwlan = WLAN(mode=WLAN. STA) nets = wlan.scan() for net in nets:if net.ssid == 'ESSID': print('Network found!') wlan.connect(net.ssid, auth=(net.sec, 'PASS'), timeout=5000) mentre non wlan.isconnected(): machine.idle() print('Connessione WLAN riuscita!') break

Sostituisci ESSID con il nome della tua rete WiFi e PASS con la relativa password.

Passaggio 6: inizializzare la comunicazione con lo slave Modbus

Le librerie Modbus Master sono simili per entrambi i dispositivi

Variano nell'inizializzazione.

1) Inizializzare uModBus su Moduino ESP32

Eseguire:

da uModBusTCP importa uModBusTCP come TCP

2) Inizializzare uModBus su Pycom

Eseguire:

da uModbus.tcp importa TCP

Connessione aperta

Quindi apri la connessione con:

modbus=TCP('IP', PORTA, 60)

dove:

• IP - indirizzo ip del tuo PC con simulatore Modbus Slave
• PORT - porta di Modbus Slave
• 60 è un timeout

Se si verifica il seguente errore durante l'esecuzione dei comandi di lettura/scrittura: ESEMPIO

eseguire:

per Moduino ESP32:

modbus.close()

per Moduino Pycom:

modbus._sock.close()

e quindi ricreare la connessione:

modbus=TCP('IP', PORTA, 60)

Questo è importante per chiudere il socket prima di ricreare la connessione. Il dispositivo ha una quantità limitata di connessione socket disponibile.

Passaggio 7: leggere e scrivere registri

Modbus supporta diverse funzioni per leggere e scrivere registri.

La libreria uModBus ha un metodo per ogni funzione:

1. read_coils
2. read_discrete_inputs
3. read_holding_registers
4. read_input_registers
5. write_single_coil
6. write_single_register

Innanzitutto, scriviamo alcuni valori.

1) Scrivi bobine (funzione: 5)

Scrivi 1 valore nel registro 200 dallo slave 1:

modbus.write_single_coil(1, 200, 0xFF00)

Il primo argomento è per l'id dello slave, nel nostro caso 1.

Il secondo è il numero di registro e il terzo è un valore. Per 1 devi mettere 0xFF00 qui. Scrivi da 0 a 201 registro dallo slave 1:

modbus.write_single_coil(, 201, 0)

Questo metodo consente di scrivere solo valori booleani: 0 o 1.

2) Scrivi registri (funzione: 6)

Ora scrivi alcuni valori interi in diversi registri.

Scrivi il valore 111 con segno nel registro 100 dallo slave 1:

modbus.write_single_register(1, 100, 111, True)

Il primo argomento è l'id dello slave, il secondo numero di registro e il terzo è il nuovo valore. L'ultimo argomento definisce se il valore deve essere impostato come numero con segno. Il valore predefinito per esso è True. Non è necessario impostarlo.

Scrivi il valore -457 con segno nel registro 101 dallo slave 1:

modbus.write_single_register(1, 101, -457)

Scrivi il valore 50 non firmato nel registro 100 dallo slave 3:

modbus.write_single_register(3, 100, 50, False)

Questo metodo consente di scrivere valori interi su un singolo registro.

Un singolo registro può contenere valori a 16 bit.

Il metodo restituisce True se il valore di input è valido e False in caso contrario. Il valore viene scritto anche se non valido (troppo grande per il registro)

3) Leggi bobine/ingressi discreti

Ora leggiamo i valori booleani scritti. Per leggere il registro con la bobina di lettura della funzione 1, eseguire:

modbus.read_coils(slaveId, register, count)[0:count]

Per leggere il registro con la funzione 2 read discreti input, eseguire:

modbus.read_discrete_inputs(slaveId, registro, conteggio)[0:count]

dove:

• slave-id - id dello slave virtuale (il simulatore di slave accetta tutti gli id validi)
• registro - numero di registro per la lettura
• count - quantità di registri da leggere (metti la quantità desiderata in entrambi i posti)

Questi metodi restituiscono array con valori booleani. Ogni valore corrisponde a ciascun registro.

Il frammento: [0:count] è necessario, perché questo metodo restituisce più valori di count. Restituisce sempre una quantità di valori divisibile per 8. I valori aggiuntivi sono False e non corrispondono ad alcun registro.

Leggi i nostri valori booleani con entrambi i metodi:

modbus.read_coils(1, 200, 2)[0:2]modbus.read_discrete_inputs(1, 200, 2)[0:2]

Il risultato sarà così: ESEMPIO

True si riferisce a 1 valore, False a 0.

4) Leggi i registri

Ora leggi i valori dai registri scritti con la funzione 6.

Per leggere i registri con la funzione 3 read holding registers, eseguire:

modbus.read_holding_registers (slaveId, registro, conteggio, firmato = vero)

Per leggere i registri con la funzione 4 read input registers, eseguire:

modbus.read_input_registers(slaveId, register, count, firmato=True)

dove:

• slave-id - id dello schiavo virtuale
• registro - numero di registro per la lettura
• count - quantità di registri da leggere
• firmato - indica se i valori letti devono essere trattati come numeri con segno o meno. Stato predefinito: Vero

Il valore restituito è una tupla con la quantità desiderata di registri.

Leggi i registri impostati al punto precedente:

modbus.read_holding_registers(1, 100, 2, True)modbus.read_input_registers(1, 100, 2, True)modbus.read_holding_registers(3, 100, 1, False)modbus.read_input_registers(3, 100, 1, False)

I risultati dovrebbero apparire come in questo screenshot: ESEMPIO

Nella prossima lezione imparerai come creare Modbus RTU Master su un dispositivo abilitato per ESP32.