Nieuw

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.

Twee clients, twee servers, één Modbus-API

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.

Componentklassen

TsgcModbusTCPClient, TsgcModbusRTUClient, TsgcModbusTCPServer, TsgcModbusRTUServer, TsgcModbusDataModel

Transporten

Modbus TCP op poort 502 met optionele TLS en proxy; Modbus RTU via RS-232 en RS-485 door TsgcSerialPort

Functiecodes

01 tot en met 08, 15, 16, 22, 23 en 43/14 (read device identification)

Platformen

Delphi 7 tot Delphi 13 en C++Builder; Windows, Linux en macOS

Elke gangbare Modbus-functie, één methode per functie

De client controleert hoeveelheden tegen de specificatie voordat er iets wordt verzonden; de servers beantwoorden elke code in deze tabel.

FCFunctieClientmethode
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 (seriële lijn)ReadExceptionStatus op de RTU-client
08Diagnostics (seriële lijn)Diagnostics op de RTU-client
15Write Multiple CoilsWriteMultipleCoils
16Write Multiple RegistersWriteMultipleRegisters, WriteInt32, WriteUInt32, WriteFloat32, WriteString
22Mask Write RegisterMaskWriteRegister
23Read/Write Multiple RegistersReadWriteMultipleRegisters
43/14Read Device IdentificationReadDeviceIdentification (basic, regular, extended en single object)

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

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.

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.

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.

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.

Meer industriële componenten in sgcWebSockets

Industriële componenten

Seriële poort, Modbus en de OPC UA-client in één sectie, met de volledige componentreferentie.

Referentie Modbus-client

Eigenschappen, methoden en events van TsgcModbusTCPClient en TsgcModbusRTUClient.

Referentie Modbus-server

TsgcModbusTCPServer, TsgcModbusRTUServer en de hooks van TsgcModbusDataModel.

Delphi seriële poort

TsgcSerialPort voor Windows, Linux en macOS: het transport van Modbus RTU, en ook een eigen seriële component.

Delphi MQTT-client

Publiceer Modbus-waarden naar een MQTT-broker: de gebruikelijke manier om fabrieksgegevens naar de cloud te brengen.

Ook voor C# en .NET

Dezelfde Modbus-clients en -servers, met dezelfde klassenamen, voor .NET 8, 9, 10 en .NET Standard 2.0.

De beste deal: All-AccessElk eSeGeCe-product, inclusief Premium-ondersteuning, vanaf €1,059 per jaar.
Bekijk de All-Access-prijzen

Praat vanuit Delphi met je eerste PLC

Inbegrepen in sgcWebSockets Enterprise (Delphi en .NET) en All-Access, of in het standalone pakket sgcIndustrial.