Según altos estándares industriales

Busca en nuestro Blog. Encontrarás múltiples aplicaciones, soluciones, ejemplos de código. Navega utilizando la nube de etiquetas o busca utilizando criterios específicos

Modbus TCP Master con PLCs basados en Arduino industrial

Comunicación mediante la técnica maestro-esclavo

Introducción de Modbus TCP Master con PLCs industriales basados en Arduino

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 registrar datos entre dispositivos de control y monitoreo industrial.

M-Duino Modbus TCP

Los dispositivos Modbus se comunican mediante una técnica maestro-esclavo (cliente-servidor) en la que solo un dispositivo (el maestro / cliente) puede iniciar transacciones (llamadas consultas). Los otros dispositivos (esclavos / servidores) responden suministrando los datos solicitados al maestro o realizando la acción solicitada en la consulta.

Un esclavo es cualquier dispositivo periférico (válvula transductora de E / S, unidad de red u otros dispositivos de medición) que procesa información y envía su salida al maestro mediante Modbus.

Los módulos de E / S Acromag forman dispositivos esclavos / servidores, mientras que un dispositivo maestro típico es una computadora host que ejecuta el software de aplicación adecuado. Otros dispositivos pueden funcionar como clientes (maestros) y servidores (esclavos).

Requisitos

Para trabajar con Modbus TCP, necesitarás cualquiera de nuestros controladores PLC para automatización industrial:

Controladores Industrial Shields basados en Arduino:

Requisitos para Modbus TCP Master con PLCs industriales basados en Arduino

Protocolo Modbus TCP/IP

Construcción del paquete de datos Modbus TCP 

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), con un estándar de red (TCP/IP) y un método estándar de representación de datos (Modbus como protocolo de aplicación). Esencialmente, el mensaje Modbus TCP / IP es simplemente una comunicación Modbus encapsulada en un contenedor Ethernet TCP / IP.

Hardware - Modbus TCP Master con PLCs industriales basados en Arduino

Hardware

Configuración de los interruptores

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, porque la comunicación siempre está disponible.

Software - Modbus TCP Master Library

Esta biblioteca solo está disponible para el PLC industrial de Industrial Shields, pero cualquier usuario puede modificarla, por lo que puede usarse en otros dispositivos Arduino.

The Arduino Modbus TCP/IP Library contiene las funciones para leer y escribir valores en slave:

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);

Donde

  • arduino modbus tcp client  is the EthernetClient connected to the slave.
  • slave_address es la dirección del esclavo Modbus RTU.
  • address es la bobina, entrada digital, registro de retención o dirección de registro de entrada. Por lo general, esta dirección es la bobina, entrada digital, registro de retención o número de registro de entrada menos 1: el número de registro de retención 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 valor uint16_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 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);


  • Modbus TCP Master Input registra el 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();
        }
      }
    }
  }
}

Otro 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 un PLCpero hay otras formas de utilizar el protocolo Modbus. También puedes usar Modbus RTU usando el shield RS485 para Arduino.

Ten en cuenta que si necesitas trabajar con Arduino para automatización industrial o uso industrial, también puedes usar el mismo código utilizado en una placa Arduino Uno conectada a cualquier Arduino shield MAX485 Arduino usando un controlador industrial PLC Arduino fabricado por Industrial Shields.


Controladores Lógicos Programables

Soluciones basadas en código abierto para automatización, monitoreo y control

PLC Based on Arduino, Raspberry Pi and ESP 32


¿Estás buscando tu PLC ideal?

Mira esta comparativa con otros controladores industriales

Comparamos entradas, salidas, comunicaciones y otras características con las de algunas de las marcas relevantes


Comparación de controladores PLC industriales >>

¿Quieres más información? 

¡Solo llena el formulario! 

¡Quiero saber más!  Por favor, llene el formulario correctamente.