Índice
Introducción
El protocolo Modbus fue desarrollado en 1979 por Modicon para sistemas de automatización industrial y controladores lógicos programables con conexión Ethernet. Se utiliza para transferir información de E/S discreta/analógica y datos de registro entre dispositivos de control y supervisión industriales.

Los dispositivos Modbus se comunican utilizando una técnica maestro-esclavo (cliente-servidor), en la que solo un dispositivo (el maestro/cliente) puede iniciar transacciones (llamadas consultas). Los demás dispositivos (ejemplo de servidores Modbus TCP con Arduino como esclavos/servidores) responden proporcionando los datos solicitados al maestro o llevando a cabo la acción solicitada en la consulta.
Un esclavo de Modbus es cualquier dispositivo periférico (válvula transductora de E/S, unidad de red u otros dispositivos de medición) que procesa la información y envía su salida al maestro utilizando Modbus.
Los Módulos de E/S Acromag de dispositivos esclavos/servidores, mientras que un dispositivo maestro típico es un ordenador anfitrión que ejecuta el software de aplicación apropiado. Otros dispositivos pueden funcionar como clientes (maestros) y servidores (esclavos).
Requisitos para trabajar con Modbus TCP
Para trabajar con Modbus TCP, necesitarás cualquiera de nuestros controladores PLC para automatización industrial:
Controladores Industrial Shields basados en Arduino:
Protocolo Modbus TCP/IP
Modbus TCP/IP utiliza TCP/IP y Ethernet para transportar los datos de la estructura de mensajes Modbus entre dispositivos compatibles. Es decir, Modbus TCP/IP combina una red física (Ethernet), un estándar de red (TCP/IP) y un método estándar de representación de datos (Modbus como protocolo de aplicación). En esencia, el mensaje Modbus TCP/IP es simplemente una comunicación Modbus encapsulada en un contenedor TCP/IP de Ethernet.
Hardware
Configuración de los switches
La mayoría de las entradas y las salidas están conectadas al PLC interno Arduino pero, en algunos casos, el usuario puede elegir entre una configuración periférica especial o un GPIO cambiando la posición de los interruptores DIP.
Cada interruptor puede seleccionar solo una de las dos configuraciones posibles al mismo tiempo, la posición derecha (ON) o la izquierda (OFF).
En este caso, la posición de los interruptores no es importante, ya que la comunicación siempre está disponible.
Software - Librería PLC Modbus TCP Master
Esta biblioteca de Arduino Modbus TCP solo está disponible para los PLC industriales de Industrial Shields, pero puede ser modificada por cualquier usuario para que sea utilizada en otros dispositivos Arduino.
La biblioteca de Arduino Modbus TCP/IP contiene las funciones para leer y escribir valores de esclavos:
readCoils(client, slave_address, address, quantity); readDiscreteInputs(client, slave_address, address, quantity); readHoldingRegisters(client, slave_address, address, quantity); readInputRegisters(client, slave_address, address, quantity); writeSingleCoil(client, slave_address, address, value); writeSingleRegister(client, slave_address, address, value); writeMultipleCoils(client, slave_address, address, values, quantity); writeMultipleRegisters(client, slave_address, address, values, quantity);
Dónde
arduino modbus tcp client
es el EthernetClient conectado al esclavo.slave_address
es la dirección del esclavo Modbus RTU.address
es la dirección de la bobina, de la entrada digital, del registro de retención o del registro de entrada. Normalmente, esta dirección es el número de la bobina, la entrada digital, el registro de retención o el registro de entrada menos 1: el registro de retención número 40009 tiene la dirección 8.quantity
es el número de bobinas, entradas digitales, registros de retención o registros de entrada para leer/escribir.value
es el valor dado de la bobina o los registros de retención en una operación de escritura. Dependiendo de la función, el tipo de datos cambia. Una bobina está representada por un valor bool y un registro de retención está representado por un valoruint16_t
.
En una función de lectura/escritura múltiple, el argumento address
es la dirección del primer argumento. En una función de escritura múltiple, el argumento values
es una matriz de valores para escribir.
Es importante tener en cuenta que estas funciones no bloquean, por lo que no devuelven el valor de lectura. Devuelven true
o false
dependiendo del estado actual del módulo. Si hay una solicitud Modbus pendiente o el cliente no está conectado, devuelven false
.
- Existe la función
available()
para verificar respuestas desde el esclavo. - El
ModbusResponse
implementa algunas funcones para obtener la información de respuesta:
hasError(); getErrorCode(); getSlave(); getFC(); isCoilSet(offset); isDiscreteInputSet(offset); isDiscreteSet(offset); getRegister(offset);
PLC Modbus TCP Master Registros de entrada Código del lector
/* Copyright (c) 2018 Boot&Work Corp., S.L. All rights reserved This program is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include <Ethernet.h> // This is the client; #include <ModbusTCPMaster.h> // This is the master; // Ethernet configuration values uint8_t mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED }; uint8_t ip[] = { 10, 10, 10, 3 }; uint8_t slaveIp[] = { 10, 10, 10, 4 }; uint16_t slavePort = 502; // Define the ModbusTCPMaster object ModbusTCPMaster master; // Ethernet client object used to connect to the slave EthernetClient slave; uint32_t lastSentTime = 0UL; //////////////////////////////////////////////////////////////////////////////////////////////////// void setup() { Serial.begin(9600UL); // Begin Ethernet Ethernet.begin(mac, ip); Serial.println(Ethernet.localIP()); // NOTE: it is not necessary to start the modbus master object } //////////////////////////////////////////////////////////////////////////////////////////////////// void loop() { // Connect to slave if not connected // The ethernet connection is managed by the application, not by the library // In this case the connection is opened once if (!slave.connected()) { slave.stop(); slave.connect(slaveIp, slavePort); } // Send a request every 1000ms if connected to slave if (slave.connected()) { if (millis() - lastSentTime > 1000) { // Send a Read Input Registers request to the slave with address 31 // It requests for 6 registers starting at address 0 // IMPORTANT: all read and write functions start a Modbus transmission, but they are not // blocking, so you can continue the program while the Modbus functions work. To check for // available responses, call master.available() function often. if (!master.readInputRegisters(slave, 31, 0, 6)) { // Failure treatment } lastSentTime = millis(); } // Check available responses often if (master.isWaitingResponse()) { ModbusResponse response = master.available(); if (response) { if (response.hasError()) { // Response failure treatment. You can use response.getErrorCode() // to get the error code. } else { // Get the input registers values from the response Serial.print("Input registers values: "); for (int i = 0; i < 6; ++i) { Serial.print(response.getRegister(i)); Serial.print(','); } Serial.println(); } } } } }
Otros PLC Arduino MODBUS
Arduino RS485 trabajando como Modbus RTU
Modbus es una forma estándar de conectar diferentes dispositivos para usos industriales. Tal y como se muestra en este post. Se puede utilizar Arduino con el protocolo Modbus TCP utilizando una Arduino Shield o trabajando con Arduino como PLCpero hay otras formas de utilizar el protocolo Modbus. También puedes usar Modbus RTU usando el escudo RS485 para Arduino.
Ten en cuenta si necesitas trabajar con Modbus utilizando Arduino para automatización industrial o uso industrial. También puedes usar el mismo código empleado en una placa Arduino Uno conectada a cualquier shield MAX485 con un controlador industrial Arduino fabricado por Industrial Shields.
Modbus TCP Master con PLCs basados en Arduino industrial