Servidor Modbus TCP y RTU
Convierte una aplicación Delphi, C++Builder o .NET en un dispositivo Modbus. Responde a sistemas SCADA, HMI y clientes Modbus por TCP/IP o por una línea serie, desde un modelo de datos seguro para hilos.
Novedad
Convierte una aplicación Delphi, C++Builder o .NET en un dispositivo Modbus. Responde a sistemas SCADA, HMI y clientes Modbus por TCP/IP o por una línea serie, desde un modelo de datos seguro para hilos.
Novedad
Dos servidores que responden desde el mismo TsgcModbusDataModel: uno escucha en el puerto TCP 502, el otro es un esclavo Modbus RTU en una línea serie.
TsgcModbusTCPServerTsgcModbusRTUServerTsgcModbusDataModel
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
Rellena el modelo de datos, asigna los eventos y pon Active en True. OnReadRequest actualiza un valor en vivo antes de leerlo, y OnWriteRequest rechaza los valores de consigna fuera de rango.
uses
sgcIndustrial;
procedure TForm1.StartServer;
begin
FServer := TsgcModbusTCPServer.Create(Self);
FServer.Port := 502;
FServer.DataModel.HoldingRegisterCount := 1000;
FServer.DataModel.SetHoldingRegister(0, 1234);
FServer.DataModel.SetCoil(5, True);
FServer.DataModel.VendorName := 'eSeGeCe';
FServer.DataModel.ProductCode := 'PLC-1';
FServer.DataModel.MajorMinorRevision := '1.0';
FServer.OnReadRequest := OnModbusReadRequest;
FServer.OnWriteRequest := OnModbusWriteRequest;
FServer.Active := True;
end;
procedure TForm1.OnModbusReadRequest(Sender: TObject; aUnitId,
aFunctionCode: Byte; aAddress, aCount: Word; var aExceptionCode: Byte);
begin
// live value: refresh input register 0 before the client reads it
if aFunctionCode = CS_MODBUS_FC_READ_INPUT_REGISTERS then
FServer.DataModel.SetInputRegister(0, FTemperature);
end;
procedure TForm1.OnModbusWriteRequest(Sender: TObject; aUnitId,
aFunctionCode: Byte; aAddress, aCount: Word; var aBits: TsgcModbusBits;
var aRegisters: TsgcModbusRegisters; var aExceptionCode: Byte);
var
i: Integer;
begin
// connection thread: setpoints accept 0..1000 only
if (aFunctionCode = CS_MODBUS_FC_WRITE_SINGLE_REGISTER) or
(aFunctionCode = CS_MODBUS_FC_WRITE_MULTIPLE_REGISTERS) then
for i := 0 to Length(aRegisters) - 1 do
if aRegisters[i] > 1000 then
begin
aExceptionCode := CS_MODBUS_EX_ILLEGAL_DATA_VALUE;
Exit;
end;
end;
#include "sgcIndustrial.hpp"
void __fastcall TForm1::StartServer()
{
FServer = new TsgcModbusTCPServer(this);
FServer->Port = 502;
FServer->DataModel->HoldingRegisterCount = 1000;
FServer->DataModel->SetHoldingRegister(0, 1234);
FServer->DataModel->SetCoil(5, true);
FServer->DataModel->VendorName = "eSeGeCe";
FServer->DataModel->ProductCode = "PLC-1";
FServer->DataModel->MajorMinorRevision = "1.0";
FServer->OnReadRequest = OnModbusReadRequest;
FServer->OnWriteRequest = OnModbusWriteRequest;
FServer->Active = true;
}
void __fastcall TForm1::OnModbusReadRequest(TObject *Sender, Byte aUnitId,
Byte aFunctionCode, Word aAddress, Word aCount, Byte &aExceptionCode)
{
// live value: refresh input register 0 before the client reads it
if (aFunctionCode == CS_MODBUS_FC_READ_INPUT_REGISTERS)
FServer->DataModel->SetInputRegister(0, FTemperature);
}
void __fastcall TForm1::OnModbusWriteRequest(TObject *Sender, Byte aUnitId,
Byte aFunctionCode, Word aAddress, Word aCount, TsgcModbusBits &aBits,
TsgcModbusRegisters &aRegisters, Byte &aExceptionCode)
{
// connection thread: setpoints accept 0..1000 only
if ((aFunctionCode == CS_MODBUS_FC_WRITE_SINGLE_REGISTER) ||
(aFunctionCode == CS_MODBUS_FC_WRITE_MULTIPLE_REGISTERS))
for (int i = 0; i < aRegisters.Length; i++)
if (aRegisters[i] > 1000)
{
aExceptionCode = CS_MODBUS_EX_ILLEGAL_DATA_VALUE;
return;
}
}
using System;
using esegece.sgcWebSockets;
class PlcServer
{
TsgcModbusTCPServer FServer = new TsgcModbusTCPServer();
ushort FTemperature = 215;
public void StartServer()
{
FServer.Port = 502;
FServer.DataModel.HoldingRegisterCount = 1000;
FServer.DataModel.SetHoldingRegister(0, 1234);
FServer.DataModel.SetCoil(5, true);
FServer.DataModel.VendorName = "eSeGeCe";
FServer.DataModel.ProductCode = "PLC-1";
FServer.DataModel.MajorMinorRevision = "1.0";
FServer.OnReadRequest += OnModbusReadRequest;
FServer.OnWriteRequest += OnModbusWriteRequest;
FServer.Active = true;
}
void OnModbusReadRequest(object Sender, byte aUnitId, byte aFunctionCode,
ushort aAddress, ushort aCount, ref byte aExceptionCode)
{
// live value: refresh input register 0 before the client reads it
if (aFunctionCode == sgcModbus_Classes.CS_MODBUS_FC_READ_INPUT_REGISTERS)
FServer.DataModel.SetInputRegister(0, FTemperature);
}
void OnModbusWriteRequest(object Sender, byte aUnitId, byte aFunctionCode,
ushort aAddress, ushort aCount, ref bool[] aBits, ref ushort[] aRegisters,
ref byte aExceptionCode)
{
// connection thread: setpoints accept 0..1000 only
if (aFunctionCode == sgcModbus_Classes.CS_MODBUS_FC_WRITE_SINGLE_REGISTER ||
aFunctionCode == sgcModbus_Classes.CS_MODBUS_FC_WRITE_MULTIPLE_REGISTERS)
foreach (ushort vValue in aRegisters)
if (vValue > 1000)
{
aExceptionCode = sgcModbus_Classes.CS_MODBUS_EX_ILLEGAL_DATA_VALUE;
return;
}
}
}
Un dispositivo Modbus en un componente: el servidor analiza las peticiones, las comprueba y responde desde el modelo de datos.
01 a 08 (08 con subfunción 0), 15, 16, 22 (mask write, aplicado de forma atómica), 23 (read/write multiple registers) y 43/14 (identificación del dispositivo, paginada con More Follows).
Bobinas, entradas discretas, registros de retención y registros de entrada, 10000 de cada uno por defecto y hasta 65536. Todos los métodos Get y Set son seguros para hilos, y una petición más allá de una tabla recibe la excepción 02.
OnReadRequest se dispara antes de leer los datos, para cargar valores en vivo. OnWriteRequest se dispara antes de escribir los datos, para cambiar los valores o rechazar la petición con un código de excepción Modbus.
Cada conexión TCP se atiende por separado, y varias peticiones en un mismo paquete se responden en orden. Una cabecera mal formada dispara OnError y cierra esa conexión. OnClientConnect y OnClientDisconnect informan de los clientes.
Por defecto el servidor TCP responde a todos los identificadores de unidad. Indica UnitId para responder a uno solo: las peticiones para otros identificadores no reciben respuesta y la conexión sigue abierta, como hace una pasarela con un dispositivo ausente.
VendorName, ProductCode y MajorMinorRevision son los objetos básicos, y VendorUrl, ProductName y ModelName los regulares, que se responden a la función 43/14.
Enlaza un TsgcSerialPort e indica la dirección del esclavo en UnitId (1 a 247). El servidor abre el puerto al arrancar y responde desde su modelo de datos.
procedure TForm1.StartRTUServer;
begin
FPort := TsgcSerialPort.Create(Self);
FPort.Port := 'COM5';
FPort.BaudRate := 19200;
FPort.Parity := spEven;
FRTUServer := TsgcModbusRTUServer.Create(Self);
FRTUServer.SerialPort := FPort;
FRTUServer.UnitId := 17;
FRTUServer.DataModel.SetInputRegister(0, 215);
// the server opens the port when it is closed
FRTUServer.Active := True;
end;
void __fastcall TForm1::StartRTUServer()
{
FPort = new TsgcSerialPort(this);
FPort->Port = "COM5";
FPort->BaudRate = 19200;
FPort->Parity = spEven;
FRTUServer = new TsgcModbusRTUServer(this);
FRTUServer->SerialPort = FPort;
FRTUServer->UnitId = 17;
FRTUServer->DataModel->SetInputRegister(0, 215);
// the server opens the port when it is closed
FRTUServer->Active = true;
}
using System;
using esegece.sgcWebSockets;
class RtuSlave
{
TsgcSerialPort FPort = new TsgcSerialPort();
TsgcModbusRTUServer FRTUServer = new TsgcModbusRTUServer();
public void StartRTUServer()
{
FPort.Port = "COM5";
FPort.BaudRate = 19200;
FPort.Parity = TsgcSerialParity.spEven;
FRTUServer.SerialPort = FPort;
FRTUServer.UnitId = 17;
FRTUServer.DataModel.SetInputRegister(0, 215);
// the server opens the port when it is closed
FRTUServer.Active = true;
}
}
Fuentes autorizadas del protocolo que implementa este componente.
En el hilo que atiende la conexión TCP, o en el hilo de tramas del servidor RTU. Nunca se sincronizan con el hilo principal, porque el servidor necesita la respuesta del manejador para construir la respuesta. No accedas directamente a la interfaz de usuario desde ellos, y no pongas Active en False desde un manejador de evento del servidor TCP.
Escribe los valores en el modelo de datos cada vez que cambien, o cárgalos en OnReadRequest, que se dispara antes de cada lectura con el código de función, la dirección y la cantidad. Los métodos del modelo de datos se pueden llamar desde el evento y desde cualquier otro hilo.
Establece aExceptionCode en OnWriteRequest, por ejemplo en CS_MODBUS_EX_ILLEGAL_DATA_VALUE (03). El cliente recibe esa excepción Modbus y las tablas quedan intactas. El evento también puede cambiar los valores antes de escribirlos.
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: TsgcModbusTCPServer Referencia completa de propiedades, métodos y eventos del servidor Modbus TCP. | Abrir | |
| Online Help: TsgcModbusRTUServer Referencia completa de propiedades, métodos y eventos del servidor Modbus RTU. | Abrir | |
| Online Help: TsgcModbusDataModel Las tablas, los objetos de identificación del dispositivo y los eventos del modelo de datos. | Abrir | |
| Proyecto de demostración: Industrial\03.Modbus_TCP_Server Un servidor 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 |