Servidor Modbus TCP e RTU

Transforme uma aplicação Delphi, C++Builder ou .NET em um dispositivo Modbus. Responda a sistemas SCADA, IHMs e clientes Modbus via TCP/IP ou linha serial, a partir de um modelo de dados thread-safe.

Novo

TsgcModbusTCPServer e TsgcModbusRTUServer

Dois servidores que respondem a partir do mesmo TsgcModbusDataModel: um escuta na porta TCP 502, o outro é um escravo Modbus RTU em uma linha serial.

Classes de componente

TsgcModbusTCPServer
TsgcModbusRTUServer
TsgcModbusDataModel

Protocolo

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

Plataformas

TCP: todas as plataformas do sgcWebSockets. RTU: Windows, Linux e macOS

Edição

Incluído no sgcWebSockets Enterprise (Delphi e .NET) e All-Access, ou no pacote independente sgcIndustrial

Inicie um servidor Modbus TCP

Preencha o modelo de dados, atribua os eventos e coloque Active como True. OnReadRequest atualiza um valor ao vivo antes de ele ser lido, e OnWriteRequest rejeita setpoints fora da faixa.

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

O que tem por dentro

Um dispositivo Modbus em um componente: o servidor interpreta as requisições, as verifica e responde a partir do modelo de dados.

Códigos de função

01 a 08 (08 com subfunção 0), 15, 16, 22 (mask write, aplicado de forma atômica), 23 (read/write multiple registers) e 43/14 (identificação do dispositivo, paginada com More Follows).

Modelo de dados

Coils, discrete inputs, holding registers e input registers, 10000 de cada por padrão e até 65536. Todo método Get e Set é thread-safe, e uma requisição além de uma tabela recebe a exceção 02.

Eventos de leitura e gravação

OnReadRequest dispara antes de os dados serem lidos, para carregar valores ao vivo. OnWriteRequest dispara antes de os dados serem gravados, para alterar os valores ou rejeitar a requisição com um código de exceção Modbus.

Conexões

Cada conexão TCP é atendida de forma independente, e várias requisições em um mesmo pacote são respondidas em ordem. Um cabeçalho malformado dispara OnError e fecha essa conexão. OnClientConnect e OnClientDisconnect informam os pares.

Ids de unidade

Por padrão, o servidor TCP responde a todos os ids de unidade. Defina UnitId para responder a um único id: as requisições para outros ids não recebem resposta e a conexão permanece aberta, como faz um gateway com um dispositivo ausente.

Identificação do dispositivo

VendorName, ProductCode e MajorMinorRevision são os objetos básicos, e VendorUrl, ProductName e ModelName os regulares, respondidos à função 43/14.

Um escravo RTU em RS-232 e RS-485

Vincule um TsgcSerialPort e defina o endereço do escravo em UnitId (1 a 247). O servidor abre a porta ao iniciar e responde a partir do seu modelo de dados.

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

Especificações e referências

Fontes autoritativas do protocolo que este componente implementa.

Perguntas sobre o servidor Modbus

Na thread que atende a conexão TCP, ou na thread de quadros do servidor RTU. Eles nunca são sincronizados com a thread principal, porque o servidor precisa da resposta do manipulador para montar a resposta. Não acesse a interface do usuário diretamente a partir deles e não defina Active como False a partir de um manipulador de evento do servidor TCP.

Grave os valores no modelo de dados sempre que mudarem, ou carregue-os em OnReadRequest, que dispara antes de cada leitura com o código de função, o endereço e a quantidade. Os métodos do modelo de dados podem ser chamados a partir do evento e de qualquer outra thread.

Defina aExceptionCode em OnWriteRequest, por exemplo como CS_MODBUS_EX_ILLEGAL_DATA_VALUE (03). O cliente recebe essa exceção Modbus e as tabelas permanecem intactas. O evento também pode alterar os valores antes de eles serem gravados.

Ele está incluído no sgcWebSockets Enterprise (Delphi e .NET) e All-Access, como parte do pacote sgcIndustrial. No Delphi, adicione sgcIndustrial à cláusula uses.

Documentação e demos

Acesse diretamente a referência do componente, abra o projeto de demonstração e leia o documento técnico.

Online Help: TsgcModbusTCPServer Referência completa de propriedades, métodos e eventos do servidor Modbus TCP.
Online Help: TsgcModbusRTUServer Referência completa de propriedades, métodos e eventos do servidor Modbus RTU.
Online Help: TsgcModbusDataModel As tabelas, os objetos de identificação do dispositivo e os eventos do modelo de dados.
Projeto de demonstração: Industrial\03.Modbus_TCP_Server Um servidor Modbus TCP para Delphi, C++Builder e .NET. Ele acompanha o pacote sgcWebSockets.
Documento técnico (PDF) Recursos, início rápido, exemplos de código e referências de fontes primárias somente para este componente.
Manual do usuário (PDF) Manual abrangente cobrindo todos os componentes da biblioteca.
Melhor custo-benefício: All-AccessTodos os produtos da eSeGeCe, com Suporte Premium incluído, a partir de €1,059/ano.
Ver preços do All-Access

Incluído no sgcWebSockets Enterprise

Incluído no sgcWebSockets Enterprise (Delphi e .NET) e All-Access, ou no pacote independente sgcIndustrial.