Delphi Modbus TCP en RTU: client- en servercomponenten
Native Modbus TCP- en Modbus RTU-componenten voor Delphi en C++Builder. Poll PLC's, aandrijvingen, energiemeters en gateways, of publiceer je eigen gegevens als Modbus-server, met getypeerde Float32-, Int32- en stringhulpmethoden in elke woordvolgorde.
Inbegrepen in sgcWebSockets Enterprise (Delphi en .NET) en All-Access, of in het standalone pakket sgcIndustrial.
Modbus TCP- en Modbus RTU-masters en -slaves als niet-visuele componenten, geschreven in Pascal en in je toepassing gecompileerd.
Met een Delphi Modbus-bibliotheek kan een VCL-, FMX-, service- of consoletoepassing praten met de apparaten die op elke fabrieksvloer te vinden zijn: PLC's, frequentieregelaars, energiemeters, temperatuurregelaars en protocolgateways. sgcWebSockets levert het als vier componenten: TsgcModbusTCPClient en TsgcModbusRTUClient pollen apparaten, terwijl TsgcModbusTCPServer en TsgcModbusRTUServer je eigen gegevens aanbieden aan SCADA-systemen, HMI's en elke andere Modbus-master.
Beide clients stammen af van TsgcModbusClient_Base, dus de code die een register via Ethernet leest, leest het ook via RS-485: je wisselt de component, niet de aanroepen. Elke aanroep blokkeert tot het antwoord binnenkomt of Timeout verloopt, geeft de waarden terug als Delphi-arrays en veroorzaakt een getypeerde exception wanneer het apparaat een fout meldt. Eén regel uses sgcIndustrial; haalt alle klassen binnen.
ReadDeviceIdentification (basic, regular, extended en single object)
QuickStart
Lees een PLC in een paar regels Delphi
Maak de component, stel het adres in, roep een methode aan. Elk voorbeeld op deze pagina compileert met Delphi 7 en 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;
Client
Een Modbus-master die je vanuit elke thread kunt aanroepen
Blokkerende aanroepen, getypeerde waarden en duidelijke fouten, via TCP en via de seriële lijn.
Getypeerde 32-bits waarden en strings
ReadFloat32, ReadInt32, ReadUInt32 en hun schrijf- en input-registerequivalenten combineren twee registers tot één waarde. WordOrder dekt de vier indelingen die apparaten gebruiken: mwoABCD (big endian, de Modbus-standaard), mwoCDAB, mwoBADC en mwoDCBA. ReadString en WriteString stoppen twee tekens per register.
Thread-safe blokkerende aanroepen
Per client loopt één verzoek tegelijk, bewaakt door een lock die al zijn nieuwe pogingen omvat, zodat meerdere threads één verbinding kunnen delen. Bij TCP wordt het antwoord door de ontvangstthread gekoppeld, dus een aanroep vanuit de hoofdthread kan niet vastlopen.
Timeouts en nieuwe pogingen
Timeout is de wachttijd per poging en Retries de extra pogingen. Een TCP-nieuwe-poging gebruikt een nieuw transactie-id, en late of dubbele antwoorden worden verworpen in plaats van voor het volgende antwoord te worden aangezien.
Getypeerde exceptions
EsgcModbusException bevat de ExceptionCode en FunctionCode van het apparaat, EsgcModbusTimeout meldt een ontbrekend antwoord, en EsgcModbusError dekt al het andere, van een gesloten verbinding tot een RTU-frame met een foute CRC.
Unit-id per aanroep
Elke methode heeft ook een overload met een unit-id vooraan, zodat één verbinding met een gateway alle apparaten erachter bereikt. UnitId is de standaardwaarde voor de aanroepen zonder.
TLS, proxy en opnieuw verbinden via TCP
TLS en TLSOptions verpakken de Modbus TCP-stream in TLS, Proxy bereikt een apparaat via een HTTP- of SOCKS-proxy, en WatchDog maakt opnieuw verbinding na een netwerkonderbreking. Alle drie komen van de sgcWebSockets TCP-client waarop de component is gebouwd.
RTU-framing zoals het hoort
De RTU-client wacht op de stilte van 3,5 tekens voordat hij verzendt, leest het antwoord op basis van de verwachte lengte (USB-adapters leveren bytes in bursts), controleert de CRC van elk frame en negeert frames van andere slave-adressen.
RS-485 en broadcast
Stel RtsControl := srcToggle in op de seriële poort en RTS schakelt de RS-485-zender bij elke schrijfactie om, via de driver op Windows en de RS-485-modus van de kernel op Linux. Unit-id 0 stuurt een broadcast-schrijfactie naar elke slave en wacht TurnaroundDelay in plaats van op een antwoord.
Events waar je ze wilt hebben
OnConnect, OnDisconnect en OnError worden geleverd via NotifyEvents: standaard in de wachtrij van de hoofdthread, gesynchroniseerd, of direct in de ontvangstthread geactiveerd.
Server
Modbus TCP- en RTU-servers met een live gegevensmodel
Maak van een Delphi-toepassing een Modbus-slave: een gateway die waarden uit een database of een REST-API aanbiedt, een apparaatsimulator om HMI-schermen te testen, of het Modbus-gezicht van je eigen controller. Elke server bezit een TsgcModbusDataModel met de vier Modbus-tabellen (coils, discrete inputs, holding registers en input registers, standaard 10.000 items elk en tot 65.536), de apparaatidentificatiestrings die op FC 43/14 worden beantwoord en de exception status die op FC 07 wordt beantwoord.
Het gegevensmodel is thread-safe: één lock bewaakt alle tabellen, zodat je code waarden kan bijwerken terwijl clients ze lezen. Twee hooks zetten je code in het verzoekpad. OnReadRequest draait voordat een tabel wordt gelezen, zodat het de waarden net op tijd kan verversen of het verzoek met een exceptioncode kan weigeren. OnWriteRequest ontvangt de waarden voordat ze worden opgeslagen, zodat het ze kan valideren, wijzigen of de schrijfactie kan weigeren en de tabellen ongemoeid laat.
TsgcModbusTCPServer
Veel gelijktijdige verbindingen, elk met zijn eigen thread. Verzoeken die samen in één pakket aankomen, worden in volgorde beantwoord, een verzoek dat over meerdere pakketten is verdeeld wordt weer samengesteld, en een ongeldige header sluit die verbinding en activeert OnError. UnitId = 0 beantwoordt elk unit-id; een andere waarde beantwoordt alleen dat id. Bindings kiezen de interfaces en poorten, en OnClientConnect en OnClientDisconnect melden de peers.
TsgcModbusRTUServer
Luistert op een TsgcSerialPort als slave UnitId (1 tot 247). Het bepaalt frames op basis van hun verwachte lengte en de stilte van 3,5 tekens, negeert frames met een foute CRC of een ander adres, en voert broadcast-schrijfacties van unit-id 0 uit zonder te antwoorden, zoals de specificatie voor de seriële lijn voorschrijft.
Hooks in de verbindingsthread
De serverevents draaien in de verbindingsthread (TCP) of de framethread (RTU) en geven hun resultaat synchroon terug. Houd ze kort en roep de methoden van het gegevensmodel gerust aan: de hooks draaien zonder dat er een lock wordt vastgehouden.
Interoperabiliteit
Getest tegen een onafhankelijke Modbus-stack
De Modbus-client en -server zijn op de draad getest tegen pymodbus, een onafhankelijke open-source implementatie, via Modbus TCP: functiecodes 01 tot en met 06, 15, 16, 22, 23 en 43/14, exceptionantwoorden, Float32-waarden en apparaatidentificatie. De getypeerde hulpmethoden zijn gecontroleerd met bekende bytevectoren in alle vier de woordvolgordes. De Delphi-componenten zijn ook getest tegen de sgcWebSockets .NET Modbus-componenten in beide richtingen, client tegen server, waarbij in elke richting 35 van de 35 controles slaagden.
De seriële poort is getest op een echte COM-poort op Windows en op pseudoterminals op Linux, inclusief het sluiten van de poort terwijl een read wacht. De Modbus RTU-client en -server zijn getest tegen gesimuleerde slaves en masters: gesplitste frames, CRC-fouten, andere slave-adressen en broadcasts. Dezelfde code compileert voor macOS.
FAQ
Vragen over Delphi Modbus
Maak een TsgcModbusTCPClient, stel Host, Port (standaard 502) en UnitId in, zet Active := True en roep ReadHoldingRegisters(Address, Count) aan. Het geeft een TsgcModbusRegisters-array terug met één Word per register. Adressen beginnen bij nul, zoals ze over de draad gaan.
Roep ReadFloat32, ReadInt32 of ReadUInt32 aan met het adres van het eerste van de twee registers, of de ReadInput...-varianten voor input registers. Als de waarde er verkeerd uitziet, gebruikt het apparaat een andere woordvolgorde: zet WordOrder op mwoCDAB, mwoBADC of mwoDCBA in plaats van de standaard mwoABCD.
Ja. Open een TsgcSerialPort op de adapter en wijs die toe aan de eigenschap SerialPort van TsgcModbusRTUClient of TsgcModbusRTUServer. Adapters met automatische richtingsbesturing hebben verder niets nodig. Stel voor adapters die de zender met RTS omschakelen RtsControl := srcToggle in: Windows gebruikt de RTS-togglemodus van de driver en Linux de RS-485-modus van de kernel.
Ja. De client voert één transactie tegelijk uit en houdt een lock vast voor het hele verzoek, nieuwe pogingen inbegrepen, zodat aanroepen vanuit meerdere threads in de rij komen en elk zijn eigen antwoord krijgt. Aanroepen vanuit de hoofdthread lopen niet vast: bij TCP wordt het antwoord door een aparte thread ontvangen.
Plaats een TsgcModbusTCPServer (of TsgcModbusRTUServer met een seriële poort), vul de DataModel met SetHoldingRegister, SetCoil en de andere setters, en zet Active := True. Gebruik OnReadRequest en OnWriteRequest om waarden op aanvraag te berekenen of schrijfacties met een Modbus-exceptioncode te weigeren.
Delphi 7 tot Delphi 13 en C++Builder, op Windows (32 en 64 bit), Linux 64 bit en macOS. De seriële poort, en daarmee Modbus RTU, is niet beschikbaar op Android en iOS.
De Modbus- en seriëlepoortcomponenten zijn inbegrepen in sgcWebSockets Enterprise (Delphi en .NET) en All-Access, of in het standalone pakket sgcIndustrial.