ESP32 Modbus Master TCP: 7 pasos

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:42

En esta clase, programará el procesador ESP32 para que sea Modbus TCP Master.

Usaremos dos dispositivos, que contienen este procesador: Moduino ESP32 y Pycom. Ambos dispositivos se ejecutan en un entorno MicroPytthon. Nuestro Modbus Slave será una computadora PC con el software de simulación Modbus ejecutándose en él.

Necesitará:

• Dispositivo Moduino ESP32 o Moduino Pycom (consulte este sitio web para obtener más información sobre el dispositivo Moduino ESP32 y esto para comprobar el dispositivo Pycom)
• PC con sistema operativo Linux
• Puerto RS-232 / RS-485 en su computadora o convertidor de USB a RS-232 / RS-485

Paso 1: Descargue e inicie Modbus TCP Slave Simulator

Descargue el simulador Modbus Slave de https://www.modbusdriver.com/diagslave.html Luego abra el archivo descargado y descomprima la versión para el sistema operativo Linux.

Ejecute el programa desde la consola con el argumento -p:

./diagslave -p

es un puerto donde funcionará el servidor Modbus esclavo. Para el protocolo Modbus es 502 por defecto, pero puede utilizar otro.

En Linux, los puertos por debajo de 1024 no pueden ser utilizados por programas ejecutados por usuarios normales (no privilegios de root).

Recuerde qué puerto está utilizando. Este valor será necesario más adelante.

Paso 2: prepare su computadora para conectarse al dispositivo

Necesitará algunos programas para conectarse al dispositivo y enviarle archivos.

Instale el entorno Python y pip (si no lo tiene):

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

Instalar picocom:

apt-get install picocom

Este programa es necesario para conectarse al dispositivo y ejecutar comandos en él. Instale mpfshell:

pip instalar mpfshell

Este programa le permite enviar archivos al dispositivo.

También puede instalarlo desde fuentes. Consulte esta página:

Paso 3: Prepare el dispositivo y conéctelo

Para conectar el dispositivo Moduino o Pycom a la PC, necesita un puerto o convertidor RS-232 / RS-485. Verifique la versión de su dispositivo (qué tipo de puerto usa) y busque el puerto o convertidor apropiado.

1. Conectar el dispositivo a la PC
2. Luego conecte la fuente de alimentación

Conecte el dispositivo a la PC y luego conecte la fuente de alimentación. También puede conectar el cable ethernet a Moduino ESP32 (si tiene ese puerto).

La conexión debe ser como en las fotos de arriba

Busque la ruta para el puerto, que se utiliza para la conexión del dispositivo. Puede ser, por ejemplo: / dev / ttyS1, / dev / ttyUSB0.

Para los convertidores USB, la ruta contendrá la palabra USB.

Puede conectarse al dispositivo con el programa picocom:

picocom / dev / ttyUSB0 -b 115200

El símbolo del sistema del dispositivo se parece a una de estas imágenes a continuación.

Moduino ESP32: ver aquí

Moduino Pycom: ver aquí

Paso 4: Cargue la biblioteca maestra de Modbus

github.com/pycom/pycom-modbus/ Para comunicarse con Modbus Slave, necesita la biblioteca adecuada. Las bibliotecas para Pycom no son compatibles con Moduino. Consulte las instrucciones que se ajusten a su dispositivo.

Cierre picocom antes de enviar archivos: presione Ctrl + A y luego Ctrl + X teclas.

Biblioteca uModBus para Moduino ESP32 se basa en la biblioteca pycom-modbus para Moduino Pycom. Está modificado para funcionar en un dispositivo ESP32 normal. También tiene métodos close () adicionales para clases de conector.

1) Moduino ESP32

Descargue la biblioteca de https://github.com/techbase123/micropython-modbus. Desempaquete el archivo y envíe los 4 archivos al dispositivo Moduino.

Utilice mpfshell para cargarlos. Ejecute este programa en el directorio con esos archivos.

Conéctese al dispositivo ejecutando: ESTO

ttyUSB0 es un nombre de puerto serie donde está conectado el dispositivo.

Cambie el directorio a / flash / lib con el comando:

cd / flash / lib

Pon todos los archivos con comandos:

poner uModBusConst.py

poner uModBusFunctions.py poner uModBusTCP.py poner uModBusSerial.py

EJEMPLO

Luego salga de la consola con el comando exit y reinicie el dispositivo con el botón Reset.

2) Moduino Pycom

Descargue la biblioteca de https://github.com/pycom/pycom-modbus/. Desempaquete el archivo y envíe el contenido del directorio uModbus al dispositivo. Use mpfshell para cargarlos. Ejecute este programa en el directorio con esos archivos.

Conéctese al dispositivo ejecutando:

abrir ttyUSB0

ttyUSB0 es un nombre de puerto serie donde está conectado el dispositivo.

Cambie el directorio a / flash / lib, cree el directorio uModbus e introdúzcalo con los comandos:

cd / flash / libmd uModbus cd uModbus

Pon todos los archivos con comandos:

poner const.py

poner functions.py poner tcp.py poner serial.py

Luego salga de la consola con el comando exit y reinicie el dispositivo con el botón Reset.

EJEMPLO

Paso 5: conéctese a la red

Los comandos para establecer la conexión difieren entre Moduino y Pycom.

Conéctese al dispositivo con picocom para ejecutar los comandos apropiados. Puede conectar el dispositivo Moduino a la red por cable o de forma inalámbrica. Los siguientes ejemplos asumen que su red tiene un servidor DHCP en funcionamiento.

En otro caso, el dispositivo no obtendrá la dirección IP. El soporte WiFi está disponible en todos los Moduino. El puerto Ethernet es una opción y no todos los dispositivos lo tienen.

1) Moduino ESP32

Conexión a WiFi

Ejecute los siguientes comandos en el dispositivo:

de netWiFi importar netWiFiwifi = netWiFi (netWiFi. WIFI_STA, 'ESSID', 'PASS') wifi.start ()

Reemplace ESSID con el nombre de su red WiFi y PASS con la contraseña.

Después de un tiempo después de ejecutar start (), debería obtener una dirección IP que se asignó a su dispositivo.

Conexión a la red Ethernet

Conecte el dispositivo a la red cableada con un cable ethernet.

Luego ejecute los siguientes comandos:

de netETH importar netETHeth = netETH () eth.start ()

Después de un tiempo después de ejecutar start (), debería obtener la dirección IP que se asignó a su dispositivo.

2) Moduino Pycom

Conectarse a WiFi

Ejecute los siguientes comandos en el dispositivo:

desde la importación de red WLANwlan = WLAN (modo = WLAN. STA) nets = wlan.scan () para red en redes: if net.ssid == 'ESSID': print ('¡Red encontrada!') wlan.connect (net.ssid, auth = (net.sec, 'PASS'), timeout = 5000) while not wlan.isconnected (): machine.idle () print ('¡Conexión WLAN exitosa!') break

Reemplace ESSID con el nombre de su red WiFi y PASS con la contraseña.

Paso 6: inicializar la comunicación con Modbus esclavo

Las bibliotecas de Modbus Master son similares para ambos dispositivos

Varían en inicialización.

1) Inicializar uModBus en Moduino ESP32

Ejecutar:

desde uModBusTCP importar uModBusTCP como TCP

2) Inicializar uModBus en Pycom

Ejecutar:

desde uModbus.tcp importar TCP

Conexión abierta

Luego abra la conexión con:

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

dónde:

• IP: dirección IP de su PC con el simulador Modbus Slave
• PUERTO - puerto del esclavo Modbus
• 60 es un tiempo de espera

Si se produce el siguiente error durante la ejecución de comandos de lectura / escritura: EJEMPLO

ejecutar:

para Moduino ESP32:

modbus.close ()

para Moduino Pycom:

modbus._sock.close ()

y luego volver a crear la conexión:

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

Esto es importante para cerrar el socket antes de recrear la conexión. El dispositivo tiene una cantidad limitada de conexión de socket disponible.

Paso 7: leer y escribir registros

Modbus admite varias funciones para leer y escribir registros.

La biblioteca uModBus tiene un método para cada función:

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

En primer lugar, escriba algunos valores.

1) Escribir bobinas (función: 5)

Escriba 1 valor en el registro 200 del esclavo 1:

modbus.write_single_coil (1, 200, 0xFF00)

El primer argumento es para la identificación del esclavo, en nuestro caso 1.

El segundo es el número de registro y el tercero es un valor. Para 1 tienes que poner 0xFF00 aquí. Escriba 0 a 201 registro desde esclavo 1:

modbus.write_single_coil (1, 201, 0)

Este método permite escribir solo valores booleanos: 0 o 1.

2) Escribir registros (función: 6)

Ahora escriba algunos valores enteros en varios registros.

Escriba el valor 111 con signo para registrar 100 desde el esclavo 1:

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

El primer argumento es la identificación del esclavo, el segundo número de registro y el tercero es el nuevo valor. El último argumento define si el valor debe establecerse como un número con signo. El valor predeterminado es Verdadero. No es necesario configurarlo.

Escriba el valor -457 con signo en el registro 101 del esclavo 1:

modbus.write_single_register (1, 101, -457)

Escriba el valor 50 no firmado en el registro 100 del esclavo 3:

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

Este método permite escribir valores enteros en un solo registro.

El registro único puede contener valores de 16 bits.

El método devuelve Verdadero si el valor de entrada es válido y Falso si no. El valor se escribe incluso si no es válido (demasiado grande para registrarlo)

3) Leer bobinas / entradas discretas

Ahora leamos los valores booleanos escritos. Para leer el registro con la función 1 leer bobina, ejecute:

modbus.read_coils (slaveId, registro, recuento) [0: recuento]

Para leer el registro con la función 2 leer entrada discreta, ejecute:

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

dónde:

• esclavo-id - id del esclavo virtual (el simulador esclavo acepta todos los identificadores válidos)
• registro - número de registro para lectura
• count: cantidad de registros que se leerán (coloque la cantidad deseada en ambos lugares)

Estos métodos devuelven una matriz con valores booleanos. Cada valor corresponde a cada registro.

El fragmento: [0: count] es necesario, porque este método devuelve más valores que count. Devuelve siempre una cantidad de valores que es divisible por 8. Los valores adicionales son falsos y no corresponden a ningún registro.

Lea nuestros valores booleanos con ambos métodos:

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

El resultado será así: EJEMPLO

Verdadero se refiere a 1 valor, Falso a 0.

4) Leer registros

Ahora lea los valores de los registros escritos con la función 6.

Para leer registros con la función 3 leer registros de retención, ejecute:

modbus.read_holding_registers (slaveId, registro, recuento, firmado = Verdadero)

Para leer registros con la función 4 leer registros de entrada, ejecute:

modbus.read_input_registers (slaveId, registro, recuento, firmado = Verdadero)

dónde:

• esclavo-id - id del esclavo virtual
• registro - número de registro para lectura
• count - cantidad de registros que se leerán
• firmado: indica si los valores leídos deben tratarse como números con signo o no. Estado predeterminado: verdadero

El valor de retorno es una tupla con la cantidad deseada de registros.

Leer registros establecidos en el punto anterior:

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)

Los resultados deberían verse como en esta captura de pantalla: EJEMPLO

En la siguiente lección, aprenderá cómo crear Modbus RTU Master en un dispositivo habilitado para ESP32.