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

TsgcModbusTCPServer y TsgcModbusRTUServer

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.

Clases de componente

TsgcModbusTCPServer
TsgcModbusRTUServer
TsgcModbusDataModel

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

Inicia un servidor Modbus TCP

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

Qué incluye

Un dispositivo Modbus en un componente: el servidor analiza las peticiones, las comprueba y responde desde el modelo de datos.

Códigos de función

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

Modelo de datos

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.

Eventos de lectura y escritura

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.

Conexiones

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.

Identificadores de unidad

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.

Identificación del dispositivo

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.

Un esclavo RTU en RS-232 y RS-485

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

Especificaciones y referencias

Fuentes autorizadas del protocolo que implementa este componente.

Preguntas sobre el servidor Modbus

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.

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: TsgcModbusTCPServer Referencia completa de propiedades, métodos y eventos del servidor Modbus TCP.
Online Help: TsgcModbusRTUServer Referencia completa de propiedades, métodos y eventos del servidor Modbus RTU.
Online Help: TsgcModbusDataModel Las tablas, los objetos de identificación del dispositivo y los eventos del modelo de datos.
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.
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.