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
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
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.
TsgcModbusTCPClientTsgcModbusRTUClient
Modbus Application Protocol V1.1b3, Modbus TCP y Modbus RTU
TCP: todas las plataformas de sgcWebSockets. RTU: Windows, Linux y macOS
Incluido en sgcWebSockets Enterprise (Delphi y .NET) y All-Access, o en el pack independiente sgcIndustrial
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);
}
}
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.
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).
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.
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.
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.
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.
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.
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);
}
}
TurnaroundDelay
Fuentes autorizadas del protocolo que implementa este componente.
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.
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. | Abrir | |
| Online Help: TsgcModbusRTUClient Referencia completa de propiedades, métodos y eventos del cliente Modbus RTU. | Abrir | |
| 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. | Abrir | |
| Documento técnico (PDF) Características, inicio rápido, ejemplos de código y referencias de fuentes primarias solo para este componente. | Abrir | |
| Manual de usuario (PDF) Manual completo que cubre cada componente de la biblioteca. | Abrir |