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

• 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();
        }
      }
    }
  }
}