Cliente Modbus TCP y RTU

Lee y escribe las bobinas y los registros de PLC, contadores de energía y variadores desde Delphi, C++Builder y .NET, por TCP/IP o por una línea serie RS-232 o RS-485.

Novedad

TsgcModbusTCPClient y TsgcModbusRTUClient

Dos clientes con los mismos métodos: uno se conecta a un dispositivo o pasarela Modbus TCP, el otro es un maestro Modbus RTU en una línea serie.

Clases de componente

TsgcModbusTCPClient
TsgcModbusRTUClient

Protocolo

Modbus Application Protocol V1.1b3, Modbus TCP y Modbus RTU

Plataformas

TCP: todas las plataformas de sgcWebSockets. RTU: Windows, Linux y macOS

Edición

Incluido en sgcWebSockets Enterprise (Delphi y .NET) y All-Access, o en el pack independiente sgcIndustrial

Conecta, lee y escribe por Modbus TCP

Indica Host y UnitId, pon Active en True y llama a los métodos. Cada petición se bloquea hasta que llega la respuesta correspondiente, y lanza una excepción cuando el dispositivo informa de un error o no responde.

uses
  sgcIndustrial;

procedure TForm1.ConnectClient;
begin
  FClient := TsgcModbusTCPClient.Create(Self);
  FClient.Host := '192.168.1.50';
  FClient.Port := 502;
  FClient.UnitId := 1;
  FClient.Timeout := 1000;
  FClient.Retries := 2;
  FClient.OnConnect := OnModbusConnect;
  FClient.OnError := OnModbusError;
  FClient.Active := True;
end;

procedure TForm1.OnModbusConnect(Sender: TObject);
begin
  Memo1.Lines.Add('Connected');
end;

procedure TForm1.ReadValues;
var
  vRegisters: TsgcModbusRegisters;
  vTemperature: Single;
begin
  try
    vRegisters := FClient.ReadHoldingRegisters(0, 10);
    FClient.WriteSingleCoil(10, True);
    // 32-bit float stored low word first by many PLCs
    FClient.WordOrder := mwoCDAB;
    vTemperature := FClient.ReadFloat32(300);
    Memo1.Lines.Add(Format('HR0 = %d, temperature = %.1f',
      [vRegisters[0], vTemperature]));
  except
    on E: EsgcModbusException do
      Memo1.Lines.Add(Format('Device exception %d', [E.ExceptionCode]));
    on E: EsgcModbusTimeout do
      Memo1.Lines.Add('No response');
  end;
end;

procedure TForm1.OnModbusError(Sender: TObject; const aError: string);
begin
  Memo1.Lines.Add('Error: ' + aError);
end;
#include "sgcIndustrial.hpp"

void __fastcall TForm1::ConnectClient()
{
  FClient = new TsgcModbusTCPClient(this);
  FClient->Host = "192.168.1.50"; // Port is 502 by default
  FClient->UnitId = 1;
  FClient->Timeout = 1000;
  FClient->Retries = 2;
  FClient->OnConnect = OnModbusConnect;
  FClient->OnError = OnModbusError;
  FClient->Active = true;
}

void __fastcall TForm1::OnModbusConnect(TObject *Sender)
{
  Memo1->Lines->Add("Connected");
}

void __fastcall TForm1::ReadValues()
{
  try
  {
    TsgcModbusRegisters vRegisters = FClient->ReadHoldingRegisters(0, 10);
    FClient->WriteSingleCoil(10, true);
    // 32-bit float stored low word first by many PLCs
    FClient->WordOrder = mwoCDAB;
    float vTemperature = FClient->ReadFloat32(300);
    Memo1->Lines->Add("HR0 = " + IntToStr(vRegisters[0]) + ", temperature = " +
      FloatToStrF(vTemperature, ffFixed, 7, 1));
  }
  catch (EsgcModbusException &E)
  {
    Memo1->Lines->Add("Device exception " + IntToStr(E.ExceptionCode));
  }
  catch (EsgcModbusTimeout &E)
  {
    Memo1->Lines->Add("No response");
  }
}

void __fastcall TForm1::OnModbusError(TObject *Sender, const String aError)
{
  Memo1->Lines->Add("Error: " + aError);
}
using System;
using esegece.sgcWebSockets;

class PlcClient
{
    TsgcModbusTCPClient FClient = new TsgcModbusTCPClient();

    public void ConnectClient()
    {
        FClient.Host = "192.168.1.50";
        FClient.Port = 502;
        FClient.UnitId = 1;
        FClient.Timeout = 1000;
        FClient.Retries = 2;
        FClient.OnConnect += OnModbusConnect;
        FClient.OnError += OnModbusError;
        FClient.Active = true;
    }

    void OnModbusConnect(object Sender, EventArgs e)
    {
        Console.WriteLine("Connected");
    }

    public void ReadValues()
    {
        try
        {
            ushort[] vRegisters = FClient.ReadHoldingRegisters(0, 10);
            FClient.WriteSingleCoil(10, true);
            // 32-bit float stored low word first by many PLCs
            FClient.WordOrder = TsgcModbusWordOrder.mwoCDAB;
            float vTemperature = FClient.ReadFloat32(300);
            Console.WriteLine($"HR0 = {vRegisters[0]}, temperature = {vTemperature:F1}");
        }
        catch (EsgcModbusException E)
        {
            Console.WriteLine("Device exception " + E.ExceptionCode);
        }
        catch (EsgcModbusTimeout)
        {
            Console.WriteLine("No response");
        }
    }

    void OnModbusError(object Sender, string aError)
    {
        Console.WriteLine("Error: " + aError);
    }
}

Qué incluye

El componente se encarga del entramado, los tiempos y la gestión de errores de Modbus, así que tu código solo trabaja con direcciones y valores.

Códigos de función

01 a 06, 15, 16, 22 (mask write), 23 (read/write multiple registers) y 43/14 (identificación del dispositivo, con paginación). El cliente RTU añade 07 (read exception status) y 08 (diagnostics).

Valores tipados

ReadInt32, ReadUInt32, ReadFloat32, ReadString y sus equivalentes de escritura, además de lecturas de registros de entrada. WordOrder selecciona ABCD, DCBA, BADC o CDAB para coincidir con el dispositivo.

Peticiones seguras para hilos

Llama a los métodos desde cualquier hilo: las peticiones se serializan y cada respuesta se asocia por su identificador de transacción. Timeout se aplica a cada intento y Retries añade más intentos.

Errores claros

Una respuesta de excepción Modbus lanza EsgcModbusException con los códigos de excepción y de función, la falta de respuesta lanza EsgcModbusTimeout, y cualquier otro problema lanza EsgcModbusError. Las cantidades fuera de la especificación se rechazan antes de enviar nada.

TLS, proxy y reconexión

El cliente TCP admite TLS, Proxy y WatchDog para la reconexión automática. Una petición que está esperando cuando se cae la conexión lanza la excepción al instante, sin esperar al tiempo de espera.

Pasarelas e identificadores de unidad

Cada método tiene una sobrecarga con un identificador de unidad al principio, de modo que una sola conexión TCP llega a todos los dispositivos detrás de una pasarela de Modbus TCP a RTU sin cambiar UnitId.

Un maestro RTU en RS-232 y RS-485

Abre un TsgcSerialPort, enlázalo con SerialPort e indica la dirección del esclavo en UnitId. El cliente construye la trama RTU con su CRC16 y espera al esclavo.

procedure TForm1.ReadSlave;
var
  vRegisters: TsgcModbusRegisters;
begin
  FPort := TsgcSerialPort.Create(Self);
  FPort.Port := 'COM4';
  FPort.BaudRate := 19200;
  FPort.Parity := spEven;
  FPort.Open;

  FRTU := TsgcModbusRTUClient.Create(Self);
  FRTU.SerialPort := FPort;
  FRTU.UnitId := 17;
  FRTU.Timeout := 500;
  FRTU.Retries := 2;
  vRegisters := FRTU.ReadHoldingRegisters(107, 3);
  Memo1.Lines.Add(Format('Register 107 = %d', [vRegisters[0]]));

  // unit id 0 = broadcast: every slave executes the write, none answers
  FRTU.WriteSingleRegister(0, 1, 100);
end;
void __fastcall TForm1::ReadSlave()
{
  FPort = new TsgcSerialPort(this);
  FPort->Port = "COM4";
  FPort->BaudRate = 19200;
  FPort->Parity = spEven;
  FPort->Open();

  FRTU = new TsgcModbusRTUClient(this);
  FRTU->SerialPort = FPort;
  FRTU->UnitId = 17;
  FRTU->Timeout = 500;
  FRTU->Retries = 2;
  TsgcModbusRegisters vRegisters = FRTU->ReadHoldingRegisters(107, 3);
  Memo1->Lines->Add("Register 107 = " + IntToStr(vRegisters[0]));

  // unit id 0 = broadcast: every slave executes the write, none answers
  FRTU->WriteSingleRegister(0, 1, 100);
}
using System;
using esegece.sgcWebSockets;

class RtuMaster
{
    TsgcSerialPort FPort = new TsgcSerialPort();
    TsgcModbusRTUClient FRTU = new TsgcModbusRTUClient();

    public void ReadSlave()
    {
        FPort.Port = "COM4";
        FPort.BaudRate = 19200;
        FPort.Parity = TsgcSerialParity.spEven;
        FPort.Open();

        FRTU.SerialPort = FPort;
        FRTU.UnitId = 17;
        FRTU.Timeout = 500;
        FRTU.Retries = 2;
        ushort[] vRegisters = FRTU.ReadHoldingRegisters(107, 3);
        Console.WriteLine("Register 107 = " + vRegisters[0]);

        // unit id 0 = broadcast: every slave executes the write, none answers
        FRTU.WriteSingleRegister(0, 1, 100);
    }
}

Especificaciones y referencias

Fuentes autorizadas del protocolo que implementa este componente.

Preguntas sobre el cliente Modbus

Los métodos toman la dirección del protocolo, que empieza en 0. El registro que muchos manuales documentan como 40001 es el registro de retención 0, así que llama a ReadHoldingRegisters(0, 1).

Llama a ReadFloat32 con la dirección del primero de sus dos registros. Si el valor parece incorrecto, el dispositivo guarda los bytes en otro orden: indica en WordOrder el orden que usa el dispositivo. Muchos PLC guardan primero la palabra baja, que es mwoCDAB.

Cada intento espera Timeout milisegundos. Tras Retries + 1 intentos sin una respuesta válida, la petición lanza EsgcModbusTimeout, con el código de función, el identificador de unidad y el número de intentos en el mensaje.

No. Abre tú mismo el TsgcSerialPort y deja vacío su evento OnData, porque el cliente lee las respuestas con Read. Una petición lanza EsgcModbusError cuando el puerto no está asignado, no está abierto o tiene OnData asignado.

Está incluido en sgcWebSockets Enterprise (Delphi y .NET) y All-Access, como parte del paquete sgcIndustrial. En Delphi, añade sgcIndustrial a la cláusula uses.

Documentación y demos

Enlace directo a la referencia del componente, abre el proyecto de demostración y lee el documento técnico.

Online Help: TsgcModbusTCPClient Referencia completa de propiedades, métodos y eventos del cliente Modbus TCP.
Online Help: TsgcModbusRTUClient Referencia completa de propiedades, métodos y eventos del cliente Modbus RTU.
Proyecto de demostración: Industrial\02.Modbus_TCP_Client Un cliente Modbus TCP para Delphi, C++Builder y .NET. Se incluye dentro del paquete sgcWebSockets.
Documento técnico (PDF) Características, inicio rápido, ejemplos de código y referencias de fuentes primarias solo para este componente.
Manual de usuario (PDF) Manual completo que cubre cada componente de la biblioteca.
La mejor opción: All-AccessTodos los productos de eSeGeCe, con Premium Support incluido, desde €1,059 al año.
Ver precios de All-Access

Incluido en sgcWebSockets Enterprise

Incluido en sgcWebSockets Enterprise (Delphi y .NET) y All-Access, o en el pack independiente sgcIndustrial.