Novo

Delphi Modbus TCP e RTU: componentes cliente e servidor

Componentes nativos Modbus TCP e Modbus RTU para Delphi e C++Builder. Consulte CLPs, inversores, medidores de energia e gateways, ou publique seus próprios dados como servidor Modbus, com helpers tipados Float32, Int32 e string em qualquer ordem de palavras.

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

Dois clientes, dois servidores, uma única API Modbus

Mestres e escravos Modbus TCP e Modbus RTU como componentes não visuais, escritos em Pascal e compilados na sua aplicação.

Uma biblioteca Delphi Modbus permite que uma aplicação VCL, FMX, serviço ou console converse com os dispositivos presentes em todo chão de fábrica: CLPs, inversores de frequência, medidores de energia, controladores de temperatura e gateways de protocolo. O sgcWebSockets a entrega como quatro componentes: TsgcModbusTCPClient e TsgcModbusRTUClient consultam dispositivos, enquanto TsgcModbusTCPServer e TsgcModbusRTUServer expõem seus próprios dados a sistemas SCADA, IHMs e qualquer outro mestre Modbus.

Os dois clientes descendem de TsgcModbusClient_Base, então o código que lê um registrador via Ethernet o lê também via RS-485: você troca o componente, não as chamadas. Cada chamada bloqueia até a resposta chegar ou Timeout expirar, retorna os valores como arrays Delphi e levanta uma exceção tipada quando o dispositivo informa um erro. Uma única linha uses sgcIndustrial; traz todas as classes.

Classes de componente

TsgcModbusTCPClient, TsgcModbusRTUClient, TsgcModbusTCPServer, TsgcModbusRTUServer, TsgcModbusDataModel

Transportes

Modbus TCP na porta 502 com TLS e proxy opcionais; Modbus RTU via RS-232 e RS-485 através de TsgcSerialPort

Códigos de função

01 a 08, 15, 16, 22, 23 e 43/14 (read device identification)

Plataformas

Delphi 7 a Delphi 13 e C++Builder; Windows, Linux e macOS

Todas as funções Modbus comuns, um método para cada

O cliente verifica as quantidades conforme a especificação antes de enviar qualquer coisa; os servidores respondem a todos os códigos desta tabela.

FCFunçãoMétodo do cliente
01Read CoilsReadCoils
02Read Discrete InputsReadDiscreteInputs
03Read Holding RegistersReadHoldingRegisters, ReadInt32, ReadUInt32, ReadFloat32, ReadString
04Read Input RegistersReadInputRegisters, ReadInputInt32, ReadInputUInt32, ReadInputFloat32
05Write Single CoilWriteSingleCoil
06Write Single RegisterWriteSingleRegister
07Read Exception Status (linha serial)ReadExceptionStatus no cliente RTU
08Diagnostics (linha serial)Diagnostics no cliente RTU
15Write Multiple CoilsWriteMultipleCoils
16Write Multiple RegistersWriteMultipleRegisters, WriteInt32, WriteUInt32, WriteFloat32, WriteString
22Mask Write RegisterMaskWriteRegister
23Read/Write Multiple RegistersReadWriteMultipleRegisters
43/14Read Device IdentificationReadDeviceIdentification (básico, regular, estendido e objeto único)

Leia um CLP em poucas linhas de Delphi

Crie o componente, defina o endereço, chame um método. Todo exemplo desta página compila com Delphi 7 e Delphi 13.

uses
  sgcIndustrial;

procedure TForm1.FormCreate(Sender: TObject);
begin
  Modbus := TsgcModbusTCPClient.Create(Self);
  Modbus.Host := '192.168.1.50';
  Modbus.Port := 502;
  Modbus.UnitId := 1;
  Modbus.Timeout := 2000;          // ms per attempt
  Modbus.Retries := 2;             // extra attempts after a timeout
  Modbus.WatchDog.Enabled := True; // reconnect after a network drop
  Modbus.OnConnect := ModbusConnect;
  Modbus.OnError := ModbusError;
  Modbus.Active := True;
end;

procedure TForm1.ModbusConnect(Sender: TObject);
begin
  Memo1.Lines.Add('connected');
end;

procedure TForm1.ModbusError(Sender: TObject; const aError: string);
begin
  Memo1.Lines.Add('error: ' + aError);
end;

procedure TForm1.btnReadClick(Sender: TObject);
var
  vRegisters: TsgcModbusRegisters;
  vCoils: TsgcModbusBits;
  i: Integer;
begin
  vRegisters := Modbus.ReadHoldingRegisters(0, 10); // FC 03
  for i := 0 to Length(vRegisters) - 1 do
    Memo1.Lines.Add(Format('HR%d = %d', [i, vRegisters[i]]));

  vCoils := Modbus.ReadCoils(0, 8);                 // FC 01
  if vCoils[0] then
    Memo1.Lines.Add('coil 0 is on');

  Modbus.WriteSingleRegister(100, 1234);            // FC 06
  Modbus.WriteSingleCoil(5, True);                  // FC 05
end;
procedure TForm1.btnTypedClick(Sender: TObject);
var
  vTemperature: Single;
  vCounter: Integer;
  vName: TsgcModbusAnsiString;
begin
  Modbus.WordOrder := mwoCDAB;              // low word first
  vTemperature := Modbus.ReadFloat32(200);  // 2 holding registers
  vCounter := Modbus.ReadInt32(202);
  vName := Modbus.ReadString(300, 8);       // 8 registers, 16 characters
  Memo1.Lines.Add(Format('%s: %.1f C, %d cycles',
    [string(vName), vTemperature, vCounter]));

  Modbus.WriteFloat32(210, 21.5);
  Modbus.WriteUInt32(212, 3000000000);

  // explicit unit id, for a gateway with several devices behind it
  Memo1.Lines.Add(FloatToStr(Modbus.ReadInputFloat32(7, 0))); // unit 7, FC 04

  try
    Modbus.ReadHoldingRegisters(9000, 4);
  except
    on E: EsgcModbusException do // the device answered with an exception
      Memo1.Lines.Add(Format('exception %d, function %d',
        [E.ExceptionCode, E.FunctionCode]));
    on E: EsgcModbusTimeout do   // no answer after Retries + 1 attempts
      Memo1.Lines.Add(E.Message);
  end;
end;
procedure TForm1.FormCreate(Sender: TObject);
begin
  Serial := TsgcSerialPort.Create(Self);
  Serial.Port := 'COM3';          // '/dev/ttyUSB0' on Linux
  Serial.BaudRate := 19200;
  Serial.Parity := spEven;        // 8E1, the Modbus RTU default
  Serial.RtsControl := srcToggle; // RS-485: RTS switches the transmitter
  Serial.Active := True;

  RTU := TsgcModbusRTUClient.Create(Self);
  RTU.SerialPort := Serial;
  RTU.UnitId := 17;               // slave address
  RTU.Timeout := 500;
  RTU.Retries := 1;
end;

procedure TForm1.btnPollClick(Sender: TObject);
var
  vValues: TsgcModbusRegisters;
begin
  vValues := RTU.ReadInputRegisters(0, 4);                      // FC 04
  Memo1.Lines.Add(Format('IR0 = %d', [vValues[0]]));
  Memo1.Lines.Add(Format('status = %d', [RTU.ReadExceptionStatus])); // FC 07
  RTU.WriteSingleRegister(0, 10, 500); // unit 0: broadcast to every slave, no reply
end;
procedure TForm1.FormCreate(Sender: TObject);
begin
  Server := TsgcModbusTCPServer.Create(Self);
  Server.Port := 502;
  Server.UnitId := 0;                          // answer every unit id
  Server.DataModel.HoldingRegisterCount := 1000;
  Server.DataModel.SetHoldingRegister(0, 42);
  Server.DataModel.SetCoil(0, True);
  Server.DataModel.VendorName := 'My Company'; // FC 43/14 identification
  Server.DataModel.ProductCode := 'GW-100';
  Server.OnReadRequest := ServerReadRequest;
  Server.OnWriteRequest := ServerWriteRequest;
  Server.Active := True;
end;

// runs in the connection thread, before the table is read
procedure TForm1.ServerReadRequest(Sender: TObject; aUnitId, aFunctionCode: Byte;
  aAddress, aCount: Word; var aExceptionCode: Byte);
begin
  if aFunctionCode = CS_MODBUS_FC_READ_INPUT_REGISTERS then
    Server.DataModel.SetInputRegister(0, Random(1000)); // fresh value
end;

// registers 0..9 are read only
procedure TForm1.ServerWriteRequest(Sender: TObject; aUnitId, aFunctionCode: Byte;
  aAddress, aCount: Word; var aBits: TsgcModbusBits;
  var aRegisters: TsgcModbusRegisters; var aExceptionCode: Byte);
begin
  if (Length(aRegisters) > 0) and (aAddress < 10) then
    aExceptionCode := CS_MODBUS_EX_ILLEGAL_DATA_ADDRESS;
end;

Um mestre Modbus que você pode chamar de qualquer thread

Chamadas bloqueantes, valores tipados e erros claros, em TCP e na linha serial.

Valores tipados de 32 bits e strings

ReadFloat32, ReadInt32, ReadUInt32 e seus equivalentes de gravação e de input registers combinam dois registradores em um único valor. WordOrder cobre os quatro layouts que os dispositivos usam: mwoABCD (big endian, o padrão do Modbus), mwoCDAB, mwoBADC e mwoDCBA. ReadString e WriteString empacotam dois caracteres por registrador.

Chamadas bloqueantes thread-safe

Uma requisição é executada por vez em cada cliente, protegida por um lock que cobre todas as suas novas tentativas, então várias threads podem compartilhar uma conexão. No TCP, a resposta é associada pela thread de recepção, então uma chamada feita da thread principal não causa deadlock.

Timeouts e novas tentativas

Timeout é a espera por tentativa e Retries as tentativas extras. Uma nova tentativa TCP usa um novo id de transação, e respostas tardias ou duplicadas são descartadas em vez de serem confundidas com a próxima resposta.

Exceções tipadas

EsgcModbusException traz o ExceptionCode e o FunctionCode do dispositivo, EsgcModbusTimeout informa a falta de resposta e EsgcModbusError cobre todo o resto, de uma conexão fechada a um quadro RTU com CRC inválido.

Id de unidade por chamada

Todo método também tem uma sobrecarga com um id de unidade na frente, então uma conexão com um gateway alcança todos os dispositivos atrás dele. UnitId é o padrão para as chamadas sem ele.

TLS, proxy e reconexão no TCP

TLS e TLSOptions envolvem o fluxo Modbus TCP em TLS, Proxy alcança um dispositivo através de um proxy HTTP ou SOCKS e WatchDog reconecta após uma queda de rede. Os três vêm do cliente TCP do sgcWebSockets no qual o componente é construído.

Enquadramento RTU bem feito

O cliente RTU espera o silêncio de 3,5 caracteres antes de enviar, lê a resposta pelo comprimento esperado (adaptadores USB entregam os bytes em rajadas), verifica o CRC de cada quadro e ignora quadros de outros endereços de escravo.

RS-485 e broadcast

Defina RtsControl := srcToggle na porta serial e o RTS alterna o transmissor RS-485 a cada gravação, pelo driver no Windows e pelo modo RS-485 do kernel no Linux. O id de unidade 0 envia uma gravação em broadcast para todos os escravos e espera TurnaroundDelay em vez de uma resposta.

Eventos onde você precisa deles

OnConnect, OnDisconnect e OnError são entregues por NotifyEvents: enfileirados para a thread principal por padrão, sincronizados, ou disparados diretamente na thread de recepção.

Servidores Modbus TCP e RTU com um modelo de dados ao vivo

Transforme uma aplicação Delphi em um escravo Modbus: um gateway que expõe valores de um banco de dados ou de uma API REST, um simulador de dispositivo para testar telas de IHM, ou a face Modbus do seu próprio controlador. Cada servidor possui um TsgcModbusDataModel com as quatro tabelas Modbus (coils, discrete inputs, holding registers e input registers, 10.000 entradas cada por padrão e até 65.536), as strings de identificação do dispositivo respondidas na FC 43/14 e o exception status respondido na FC 07.

O modelo de dados é thread-safe: um único lock protege todas as tabelas, então seu código pode atualizar valores enquanto os clientes os leem. Dois hooks colocam seu código no caminho da requisição. OnReadRequest é executado antes de uma tabela ser lida, podendo atualizar os valores na hora certa ou recusar a requisição com um código de exceção. OnWriteRequest recebe os valores antes de serem armazenados, podendo validá-los, alterá-los ou rejeitar a gravação e deixar as tabelas intactas.

TsgcModbusTCPServer

Muitas conexões simultâneas, cada uma com sua própria thread. Requisições que chegam juntas em um pacote são respondidas em ordem, uma requisição dividida em vários pacotes é remontada, e um cabeçalho malformado fecha essa conexão e dispara OnError. UnitId = 0 responde a qualquer id de unidade; outro valor responde apenas a esse. Bindings escolhe as interfaces e portas, e OnClientConnect e OnClientDisconnect informam os pares.

TsgcModbusRTUServer

Escuta em um TsgcSerialPort como escravo UnitId (1 a 247). Ele delimita as requisições pelo comprimento esperado e pelo silêncio de 3,5 caracteres, ignora quadros com CRC inválido ou de outro endereço e executa gravações em broadcast do id de unidade 0 sem responder, como exige a especificação da linha serial.

Hooks na thread da conexão

Os eventos do servidor são executados na thread da conexão (TCP) ou na thread de quadros (RTU) e retornam o resultado de forma síncrona. Mantenha-os curtos e chame os métodos do modelo de dados à vontade: os hooks são executados sem nenhum lock retido.

Testado contra uma pilha Modbus independente

O cliente e o servidor Modbus são testados na rede contra o pymodbus, uma implementação open source independente, via Modbus TCP: códigos de função 01 a 06, 15, 16, 22, 23 e 43/14, respostas de exceção, valores Float32 e identificação do dispositivo. Os helpers tipados são verificados contra vetores de bytes conhecidos nas quatro ordens de palavras. Os componentes Delphi também são testados contra os componentes Modbus do sgcWebSockets .NET nos dois sentidos, cliente contra servidor, com 35 de 35 verificações aprovadas em cada sentido.

A porta serial é testada em uma porta COM real no Windows e em pseudoterminais no Linux, inclusive fechando a porta enquanto uma leitura está em espera. O cliente e o servidor Modbus RTU são testados contra escravos e mestres simulados: quadros divididos, erros de CRC, outros endereços de escravo e broadcasts. O mesmo código compila para macOS.

Perguntas sobre Delphi Modbus

Crie um TsgcModbusTCPClient, defina Host, Port (502 por padrão) e UnitId, defina Active := True e chame ReadHoldingRegisters(Address, Count). Ele retorna um array TsgcModbusRegisters com um Word por registrador. Os endereços começam em zero, como trafegam na rede.

Chame ReadFloat32, ReadInt32 ou ReadUInt32 com o endereço do primeiro dos dois registradores, ou as variantes ReadInput... para input registers. Se o valor parecer errado, o dispositivo usa outra ordem de palavras: defina WordOrder como mwoCDAB, mwoBADC ou mwoDCBA em vez do padrão mwoABCD.

Sim. Abra um TsgcSerialPort no adaptador e atribua-o à propriedade SerialPort de TsgcModbusRTUClient ou TsgcModbusRTUServer. Adaptadores com controle automático de direção não precisam de mais nada. Para adaptadores que alternam o transmissor com o RTS, defina RtsControl := srcToggle: o Windows usa o modo de alternância de RTS do driver e o Linux o modo RS-485 do kernel.

Sim. O cliente executa uma transação por vez e mantém um lock durante toda a requisição, novas tentativas incluídas, então as chamadas de várias threads entram em fila e cada uma recebe a sua resposta. Chamadas da thread principal não causam deadlock: no TCP, a resposta é recebida por uma thread separada.

Coloque um TsgcModbusTCPServer (ou TsgcModbusRTUServer com uma porta serial), preencha seu DataModel com SetHoldingRegister, SetCoil e os outros setters, e defina Active := True. Use OnReadRequest e OnWriteRequest para calcular valores sob demanda ou rejeitar gravações com um código de exceção Modbus.

Delphi 7 a Delphi 13 e C++Builder, no Windows (32 e 64 bits), Linux 64 bits e macOS. A porta serial, e com ela o Modbus RTU, não está disponível para Android e iOS.

Os componentes Modbus e de porta serial estão incluídos no sgcWebSockets Enterprise (Delphi e .NET) e All-Access, ou no pacote independente sgcIndustrial.

Mais componentes industriais no sgcWebSockets

Componentes industriais

Porta serial, Modbus e o cliente OPC UA em uma única seção, com a referência completa dos componentes.

Referência do cliente Modbus

Propriedades, métodos e eventos de TsgcModbusTCPClient e TsgcModbusRTUClient.

Referência do servidor Modbus

TsgcModbusTCPServer, TsgcModbusRTUServer e os hooks de TsgcModbusDataModel.

Porta serial para Delphi

TsgcSerialPort para Windows, Linux e macOS: o transporte do Modbus RTU e também um componente serial por si só.

Cliente MQTT para Delphi

Publique valores Modbus em um broker MQTT: o caminho usual para levar os dados da fábrica para a nuvem.

Também para C# e .NET

Os mesmos clientes e servidores Modbus, com os mesmos nomes de classe, para .NET 8, 9, 10 e .NET Standard 2.0.

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

Converse com seu primeiro CLP a partir do Delphi

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