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.
ReadDeviceIdentification (básico, regular, estendido e objeto único)
QuickStart
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 03for i := 0to Length(vRegisters) - 1do
Memo1.Lines.Add(Format('HR%d = %d', [i, vRegisters[i]]));
vCoils := Modbus.ReadCoils(0, 8); // FC 01if vCoils[0] then
Memo1.Lines.Add('coil 0 is on');
Modbus.WriteSingleRegister(100, 1234); // FC 06
Modbus.WriteSingleCoil(5, True); // FC 05end;
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 04try
Modbus.ReadHoldingRegisters(9000, 4);
excepton 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 replyend;
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 readprocedure TForm1.ServerReadRequest(Sender: TObject; aUnitId, aFunctionCode: Byte;
aAddress, aCount: Word; var aExceptionCode: Byte);
beginif aFunctionCode = CS_MODBUS_FC_READ_INPUT_REGISTERS then
Server.DataModel.SetInputRegister(0, Random(1000)); // fresh valueend;
// registers 0..9 are read onlyprocedure TForm1.ServerWriteRequest(Sender: TObject; aUnitId, aFunctionCode: Byte;
aAddress, aCount: Word; var aBits: TsgcModbusBits;
var aRegisters: TsgcModbusRegisters; var aExceptionCode: Byte);
beginif (Length(aRegisters) > 0) and (aAddress < 10) then
aExceptionCode := CS_MODBUS_EX_ILLEGAL_DATA_ADDRESS;
end;
Cliente
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.
Servidor
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.
Interoperabilidade
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.
FAQ
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.