ESP32 Modbus Master TCP: 7 passos

2024 Autora: John Day | [email protected]. Última modificació: 2024-01-30 08:14

En aquesta classe, programareu el processador ESP32 per ser Modbus TCP Master.

Utilitzarem dos dispositius que contenen aquest processador: Moduino ESP32 i Pycom. Tots dos dispositius s’executen a l’entorn MicroPytthon. El nostre Modbus Slave serà un ordinador de PC amb el programari de simulador Modbus en funcionament.

Necessitarà:

• Dispositiu Moduino ESP32 o Moduino Pycom (consulteu aquest lloc web per obtenir més informació sobre el dispositiu Moduino ESP32 i això per comprovar el dispositiu Pycom)
• PC amb sistema operatiu Linux
• Port RS-232 / RS-485 a l’ordinador o convertidor USB a RS-232 / RS-485

Pas 1: baixeu i inicieu Modbus TCP Slave Simulator

Descarregueu el simulador Modbus Slave des de https://www.modbusdriver.com/diagslave.html. A continuació, obriu l’arxiu descarregat i descomprimiu la versió per al sistema operatiu Linux.

Executeu el programa des de la consola amb l'argument -p:

./diagslave -p

és un port on funcionarà el servidor Modbus Slave. Per al protocol Modbus és per defecte 502, però podeu utilitzar-ne un altre.

Als ports Linux inferiors a 1024 no es poden utilitzar els programes executats per un usuari normal (no privilegis d’arrel).

Recordeu quin port feu servir. Aquest valor serà necessari més endavant.

Pas 2: prepareu l'ordinador per connectar-vos al dispositiu

Necessitareu alguns programes per connectar-vos al dispositiu i enviar-hi fitxers.

Instal·leu l'entorn Python i pip (si no el teniu):

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

Instal·leu picocom:

apt-get install picocom

Aquest programa és necessari per connectar-se al dispositiu i executar-hi ordres. Instal·leu mpfshell:

pip instal·lar mpfshell

Aquest programa us permet enviar fitxers al dispositiu.

També podeu instal·lar-lo a les fonts del formulari. Consulteu aquesta pàgina:

Pas 3: prepareu el dispositiu i connecteu-vos-hi

Per connectar el dispositiu Moduino o Pycom al PC, necessiteu un port o convertidor RS-232 / RS-485. Comproveu la versió del dispositiu (quin tipus de port utilitza) i cerqueu el port o convertidor adequat.

1. Connecteu el dispositiu a l'ordinador
2. A continuació, connecteu-hi la font d'alimentació

Connecteu el dispositiu a l'ordinador i, a continuació, connecteu-hi la font d'alimentació. També podeu connectar un cable Ethernet a Moduino ESP32 (si té aquest port).

La connexió hauria de ser com a les fotos anteriors

Cerca el camí per al port, que s’utilitza per a la connexió del dispositiu. Pot ser, per exemple: / dev / ttyS1, / dev / ttyUSB0.

Per als convertidors USB, la ruta contindrà una paraula USB.

Podeu connectar-vos al dispositiu amb el programa picocom:

picocom / dev / ttyUSB0 -b 115200

L'indicador d'ordres del dispositiu té un aspecte similar a una d'aquestes imatges a continuació.

Moduino ESP32: veure aquí

Moduino Pycom: vegeu aquí

Pas 4: pengeu la biblioteca principal Modbus

github.com/pycom/pycom-modbus/ Per comunicar-vos amb Modbus Slave necessiteu una biblioteca adequada. Les biblioteques de Pycom no són compatibles amb Moduino. Consulteu les instruccions que compleixen el vostre dispositiu.

Tanqueu picocom abans d’enviar fitxers: premeu Ctrl + A i després Ctrl + X tecles.

La biblioteca uModBus per a Moduino ESP32 es basa en la biblioteca pycom-modbus per a Moduino Pycom. Es modifica per funcionar en un dispositiu ESP32 normal. També té mètodes close () addicionals per a classes de connectors.

1) Moduino ESP32

Descarregueu la biblioteca des de https://github.com/techbase123/micropython-modbus. Desempaqueteu l'arxiu i envieu els 4 fitxers al dispositiu Moduino.

Utilitzeu mpfshell per penjar-los. Executeu aquest programa al directori amb aquests fitxers.

Connecteu-vos al dispositiu executant: AQUEST

ttyUSB0 és un nom del port sèrie on es connecta el dispositiu.

Canvieu el directori a / flash / lib amb l'ordre:

cd / flash / lib

Col·loqueu tots els fitxers amb ordres:

posa uModBusConst.py

posa uModBusFunctions.py posa uModBusTCP.py posa uModBusSerial.py

EXEMPLE

A continuació, sortiu de la consola amb l'ordre exit i reinicieu el dispositiu amb el botó Restableix.

2) Pycom Moduino

Baixeu la biblioteca de https://github.com/pycom/pycom-modbus/. Desempaqueteu l’arxiu i envieu el contingut del directori uModbus al dispositiu. Utilitzeu mpfshell per penjar-los. Executeu aquest programa al directori amb aquests fitxers.

Connecteu-vos al dispositiu executant:

obre ttyUSB0

ttyUSB0 és un nom del port sèrie on es connecta el dispositiu.

Canvieu el directori a / flash / lib, creeu el directori uModbus i introduïu-lo amb les ordres següents:

cd / flash / libmd uModbus cd uModbus

Col·loqueu tots els fitxers amb ordres:

posa const.py

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

A continuació, sortiu de la consola amb l'ordre exit i reinicieu el dispositiu amb el botó Restableix.

EXEMPLE

Pas 5: connecteu-vos a la xarxa

Els ordres per establir la connexió difereixen entre Moduino i Pycom.

Connecteu-vos al dispositiu amb picocom per executar les ordres adequades. Podeu connectar el dispositiu Moduino a la xarxa per cable o sense fils. Els exemples següents suposen que la vostra xarxa té un servidor DHCP que funciona.

En un altre cas, el dispositiu no obtindrà l'adreça IP. El servei de Wi-Fi està disponible a tots els Moduino. El port Ethernet és una opció i no tots els dispositius en tenen.

1) Moduino ESP32

Connexió a WiFi

Executeu les ordres següents al dispositiu:

des de la importació de netWiFi netWiFiwifi = netWiFi (netWiFi. WIFI_STA, 'ESSID', 'PASS') wifi.start ()

Substituïu ESSID pel nom de la vostra xarxa WiFi i PASS amb la contrasenya.

Passat el temps després d’executar start (), haureu d’obtenir una adreça IP assignada al vostre dispositiu.

Connexió a xarxa Ethernet

Connecteu el dispositiu a la xarxa per cable amb un cable Ethernet.

A continuació, executeu les ordres següents:

des de la importació netETH netETHeth = netETH () eth.start ()

Passat el temps després d’executar start (), haureu d’obtenir l’adreça IP assignada al vostre dispositiu.

2) Pycom Moduino

Connecteu-vos a WiFi

Executeu les ordres següents al dispositiu:

des de la importació de la xarxa WLANwlan = WLAN (mode = WLAN. STA) nets = wlan.scan () per a xarxa a xarxes: si net.ssid == 'ESSID': imprimir ('S'ha trobat la xarxa!') wlan.connect (net.ssid, auth = (net.sec, 'PASS'), temps d'espera = 5000) mentre no és wlan.isconnected (): machine.idle () print ('La connexió WLAN ha funcionat correctament!')

Substituïu ESSID pel nom de la vostra xarxa WiFi i PASS amb la contrasenya.

Pas 6: inicialitzeu la comunicació amb Modbus Slave

Les biblioteques mestres Modbus són similars per a tots dos dispositius

Varien en inicialització.

1) Inicialitzeu uModBus a Moduino ESP32

Executa:

des de uModBusTCP importeu uModBusTCP com a TCP

2) Inicialitzeu uModBus a Pycom

Executa:

d'importació TCP d'uModbus.tcp

Connexió oberta

A continuació, obriu la connexió amb:

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

on:

• Adreça IP - IP del vostre PC amb el simulador Modbus Slave
• PORT: port de Modbus Slave
• 60 és un temps mort

Si es produeix l'error següent durant l'execució d'ordres de lectura / escriptura: EXEMPLE

executar:

per a Moduino ESP32:

modbus.close ()

per a Moduino Pycom:

modbus._sock.close ()

i després recrear la connexió:

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

Això és important per tancar el sòcol abans de tornar a crear la connexió. El dispositiu ha restringit la quantitat de connexió de sòcol disponible.

Pas 7: llegir i escriure registres

Modbus admet diverses funcions per llegir i escriure registres.

La biblioteca uModBus té un mètode per a cada funció:

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

En primer lloc, permetem escriure alguns valors.

1) Escriure bobines (func: 5)

Escriviu 1 valor a 200 registres des de l'esclau 1:

modbus.write_single_coil (1, 200, 0xFF00)

El primer argument és per a l’identificador d’esclau, en el nostre cas 1.

El segon és el número de registre i el seu és un valor. Per a 1 heu de posar 0xFF00 aquí. Escriviu el registre 0 a 201 des de l'esclau 1:

modbus.write_single_coil (1, 201, 0)

Aquest mètode permet escriure només valors booleans: 0 o 1.

2) Escriure registres (func: 6)

Ara escriviu alguns valors enters a diversos registres.

Escriviu un valor signat 111 per registrar 100 des de l'esclau 1:

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

El primer argument és l’identificador d’esclau, el segon número de registre i el tercer és un valor nou. L’últim argument defineix si s’ha d’establir el valor com a número signat. El valor per defecte és True. No cal que ho configureu.

Escriu el valor signat -457 al registre 101 des de l'esclau 1:

modbus.write_single_register (1, 101, -457)

Escriviu un valor no signat de 50 a 100 registres des de l'esclau 3:

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

Aquest mètode permet escriure valors enters a un registre únic.

El registre únic pot contenir valors de 16 bits.

El mètode torna True si el valor d’entrada és vàlid i False si no. El valor s'escriu encara que no sigui vàlid (massa gran per registrar-se)

3) Llegiu bobines / entrades discretes

Ara permet llegir valors booleans escrits. Per llegir el registre amb la bobina de lectura de la funció 1, executeu:

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

Per llegir el registre amb la funció 2 de lectura d'entrada discreta, executeu:

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

on:

• slave-id: identificador de l'esclau virtual (el simulador d'esclaus accepta tots els identificadors vàlids)
• registre - número de registre per llegir
• recompte: quantitat de registres que cal llegir (poseu la quantitat desitjada als dos llocs)

Aquests mètodes retornen matriu amb valors booleans. Cada valor correspon a cada registre.

Es necessita el fragment: [0: count], perquè aquest mètode retorna més valors que count. Torna sempre la quantitat de valors divisible per 8. Els valors addicionals són Fals i no corresponen a cap registre.

Llegiu els nostres valors booleans amb els dos mètodes:

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

El resultat serà així: EXEMPLE

True fa referència a 1 valor, False a 0.

4) Llegiu els registres

Ara llegiu els valors dels registres escrits amb 6 funcions.

Per llegir registres amb la funció 3 de lectura de registres, executeu:

modbus.read_holding_registers (slaveId, register, count, signed = True)

Per llegir registres amb la funció 4 llegir registres d'entrada, executeu:

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

on:

• slave-id: identificador de l'esclau virtual
• registre - número de registre per llegir
• recompte: quantitat de registres que cal llegir
• signat: indica si els valors llegits s’han de tractar com a números signats o no. Estat per defecte: cert

El valor de retorn és una tupla amb la quantitat desitjada de registres.

Llegiu els registres establerts al punt anterior:

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

Els resultats haurien de ser semblants a aquesta captura de pantalla: EXEMPLE

A la següent lliçó aprendràs a crear Modbus RTU Master en un dispositiu habilitat per ESP32.