Cliente Modbus TCP e RTU

Leia e grave os coils e registradores de CLPs, medidores de energia e inversores a partir de Delphi, C++Builder e .NET, via TCP/IP ou por uma linha serial RS-232 ou RS-485.

Novo

TsgcModbusTCPClient e TsgcModbusRTUClient

Dois clientes com os mesmos métodos: um conecta a um dispositivo ou gateway Modbus TCP, o outro é um mestre Modbus RTU em uma linha serial.

Classes de componente

TsgcModbusTCPClient
TsgcModbusRTUClient

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

Conectar, ler e gravar via Modbus TCP

Defina Host e UnitId, coloque Active como True e chame os métodos. Cada requisição bloqueia até a resposta correspondente chegar e levanta uma exceção quando o dispositivo informa um erro ou não 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);
    }
}

O que tem por dentro

O enquadramento, a temporização e o tratamento de erros do Modbus ficam por conta do componente, então seu código lida apenas com endereços e valores.

Códigos de função

01 a 06, 15, 16, 22 (mask write), 23 (read/write multiple registers) e 43/14 (identificação do dispositivo, com paginação). O cliente RTU acrescenta 07 (read exception status) e 08 (diagnostics).

Valores tipados

ReadInt32, ReadUInt32, ReadFloat32, ReadString e seus equivalentes de gravação, além de leituras de input registers. WordOrder seleciona ABCD, DCBA, BADC ou CDAB conforme o dispositivo.

Requisições thread-safe

Chame os métodos de qualquer thread: as requisições são serializadas e cada resposta é associada pelo id de transação. Timeout vale para cada tentativa e Retries adiciona mais tentativas.

Erros claros

Uma resposta de exceção Modbus levanta EsgcModbusException com os códigos de exceção e de função, a ausência de resposta levanta EsgcModbusTimeout e qualquer outro problema levanta EsgcModbusError. Quantidades fora da especificação são rejeitadas antes de qualquer envio.

TLS, proxy e reconexão

O cliente TCP suporta TLS, Proxy e WatchDog para reconexão automática. Uma requisição em espera quando a conexão cai levanta a exceção imediatamente, sem aguardar o timeout.

Gateways e ids de unidade

Todo método tem uma sobrecarga com um id de unidade na frente, então uma única conexão TCP alcança todos os dispositivos atrás de um gateway Modbus TCP para RTU sem alterar UnitId.

Um mestre RTU em RS-232 e RS-485

Abra um TsgcSerialPort, vincule-o com SerialPort e defina o endereço do escravo em UnitId. O cliente monta o quadro RTU com seu CRC16 e aguarda o escravo.

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

Especificações e referências

Fontes autoritativas do protocolo que este componente implementa.

Perguntas sobre o cliente Modbus

Os métodos recebem o endereço do protocolo, que começa em 0. O registrador que muitos manuais documentam como 40001 é o holding register 0, então chame ReadHoldingRegisters(0, 1).

Chame ReadFloat32 com o endereço do primeiro dos dois registradores. Se o valor parecer errado, o dispositivo armazena os bytes em outra ordem: defina WordOrder com a ordem que o dispositivo usa. Muitos CLPs armazenam a palavra baixa primeiro, o que corresponde a mwoCDAB.

Cada tentativa espera Timeout milissegundos. Após Retries + 1 tentativas sem uma resposta válida, a requisição levanta EsgcModbusTimeout, com o código de função, o id de unidade e o número de tentativas na mensagem.

Não. Abra o TsgcSerialPort você mesmo e deixe seu evento OnData vazio, porque o cliente lê as respostas com Read. Uma requisição levanta EsgcModbusError quando a porta não está atribuída, não está aberta ou tem OnData atribuído.

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: TsgcModbusTCPClient Referência completa de propriedades, métodos e eventos do cliente Modbus TCP.
Online Help: TsgcModbusRTUClient Referência completa de propriedades, métodos e eventos do cliente Modbus RTU.
Projeto de demonstração: Industrial\02.Modbus_TCP_Client Um cliente 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.