Neu

Delphi Modbus TCP und RTU: Client- und Server-Komponenten

Native Modbus TCP und Modbus RTU Komponenten für Delphi und C++Builder. Frage SPS-Steuerungen, Antriebe, Energiezähler und Gateways ab oder stelle eigene Daten als Modbus Server bereit, mit typisierten Helfern für Float32, Int32 und Strings in jeder Wortreihenfolge.

Enthalten in sgcWebSockets Enterprise (Delphi und .NET) und All-Access oder im eigenständigen Paket sgcIndustrial.

Zwei Clients, zwei Server, eine Modbus-API

Modbus TCP und Modbus RTU Master und Slaves als nicht visuelle Komponenten, in Pascal geschrieben und in deine Anwendung kompiliert.

Eine Delphi Modbus Bibliothek lässt eine VCL-, FMX-, Dienst- oder Konsolenanwendung mit den Geräten sprechen, die in jeder Fabrikhalle zu finden sind: SPS-Steuerungen, Frequenzumrichter, Energiezähler, Temperaturregler und Protokoll-Gateways. sgcWebSockets liefert sie als vier Komponenten: TsgcModbusTCPClient und TsgcModbusRTUClient fragen Geräte ab, während TsgcModbusTCPServer und TsgcModbusRTUServer deine eigenen Daten für SCADA-Systeme, HMIs und jeden anderen Modbus Master bereitstellen.

Beide Clients stammen von TsgcModbusClient_Base ab, sodass der Code, der ein Register über Ethernet liest, es auch über RS-485 liest: Du tauschst die Komponente, nicht die Aufrufe. Jeder Aufruf blockiert, bis die Antwort eintrifft oder Timeout abläuft, gibt die Werte als Delphi-Arrays zurück und löst eine typisierte Exception aus, wenn das Gerät einen Fehler meldet. Eine Zeile uses sgcIndustrial; bringt jede Klasse mit.

Komponentenklassen

TsgcModbusTCPClient, TsgcModbusRTUClient, TsgcModbusTCPServer, TsgcModbusRTUServer, TsgcModbusDataModel

Transporte

Modbus TCP auf Port 502 mit optionalem TLS und Proxy; Modbus RTU über RS-232 und RS-485 durch TsgcSerialPort

Funktionscodes

01 bis 08, 15, 16, 22, 23 und 43/14 (Geräteidentifikation lesen)

Plattformen

Delphi 7 bis Delphi 13 und C++Builder; Windows, Linux und macOS

Jede gängige Modbus-Funktion, eine Methode pro Funktion

Der Client prüft die Mengen gegen die Spezifikation, bevor etwas gesendet wird; die Server beantworten jeden Code dieser Tabelle.

FCFunktionClient-Methode
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 (serielle Leitung)ReadExceptionStatus am RTU Client
08Diagnostics (serielle Leitung)Diagnostics am 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 und einzelnes Objekt)

Eine SPS in wenigen Zeilen Delphi lesen

Erstelle die Komponente, setze die Adresse, rufe eine Methode auf. Jedes Beispiel auf dieser Seite lässt sich mit Delphi 7 und Delphi 13 kompilieren.

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;

Ein Modbus Master, den du aus jedem Thread aufrufen kannst

Blockierende Aufrufe, typisierte Werte und klare Fehler, über TCP und über die serielle Leitung.

Typisierte 32-Bit-Werte und Strings

ReadFloat32, ReadInt32, ReadUInt32 und ihre Schreib- und Input-Register-Gegenstücke fassen zwei Register zu einem Wert zusammen. WordOrder deckt die vier Layouts ab, die Geräte verwenden: mwoABCD (Big Endian, der Modbus-Standard), mwoCDAB, mwoBADC und mwoDCBA. ReadString und WriteString packen zwei Zeichen pro Register.

Threadsichere blockierende Aufrufe

Pro Client läuft immer nur eine Anfrage, abgesichert durch eine Sperre, die alle Wiederholungen umfasst, sodass mehrere Threads eine Verbindung teilen können. Bei TCP ordnet der Empfangsthread die Antwort zu, sodass ein Aufruf aus dem Hauptthread keinen Deadlock auslösen kann.

Timeouts und Wiederholungen

Timeout ist die Wartezeit pro Versuch und Retries die zusätzlichen Versuche. Eine TCP-Wiederholung verwendet eine neue Transaktions-ID, und späte oder doppelte Antworten werden verworfen, statt für die nächste Antwort gehalten zu werden.

Typisierte Exceptions

EsgcModbusException trägt den ExceptionCode und FunctionCode des Geräts, EsgcModbusTimeout meldet eine fehlende Antwort, und EsgcModbusError deckt alles andere ab, von einer geschlossenen Verbindung bis zu einem RTU-Frame mit falscher CRC.

Unit-ID pro Aufruf

Jede Methode hat auch eine Überladung mit vorangestellter Unit-ID, sodass eine Verbindung zu einem Gateway alle Geräte dahinter erreicht. UnitId ist der Standard für die Aufrufe ohne sie.

TLS, Proxy und Wiederverbindung über TCP

TLS und TLSOptions verpacken den Modbus-TCP-Datenstrom in TLS, Proxy erreicht ein Gerät über einen HTTP- oder SOCKS-Proxy, und WatchDog verbindet nach einem Netzwerkabbruch neu. Alle drei stammen vom sgcWebSockets TCP Client, auf dem die Komponente aufbaut.

RTU-Framing richtig gemacht

Der RTU Client wartet vor dem Senden die Stille von 3,5 Zeichen ab, liest die Antwort anhand ihrer erwarteten Länge (USB-Adapter liefern Bytes in Schüben), prüft die CRC jedes Frames und ignoriert Frames anderer Slave-Adressen.

RS-485 und Broadcast

Setze RtsControl := srcToggle am Serial Port, und RTS schaltet bei jedem Schreibvorgang den RS-485-Sender um, unter Windows über den Treiber und unter Linux über den RS-485-Modus des Kernels. Unit-ID 0 sendet einen Broadcast-Schreibvorgang an alle Slaves und wartet statt auf eine Antwort TurnaroundDelay ab.

Ereignisse dort, wo du sie willst

OnConnect, OnDisconnect und OnError werden über NotifyEvents zugestellt: standardmäßig in den Hauptthread eingereiht, synchronisiert oder direkt im Empfangsthread ausgelöst.

Modbus TCP und RTU Server mit Live-Datenmodell

Mache aus einer Delphi-Anwendung einen Modbus Slave: ein Gateway, das Werte aus einer Datenbank oder einer REST-API bereitstellt, einen Gerätesimulator zum Testen von HMI-Bildschirmen oder das Modbus-Gesicht deines eigenen Controllers. Jeder Server besitzt ein TsgcModbusDataModel mit den vier Modbus-Tabellen (Coils, Discrete Inputs, Holding-Register und Input-Register, standardmäßig je 10.000 Einträge und bis zu 65.536), den Strings der Geräteidentifikation, die auf FC 43/14 beantwortet werden, und dem Exception-Status, der auf FC 07 beantwortet wird.

Das Datenmodell ist threadsicher: Eine Sperre schützt alle Tabellen, sodass dein Code Werte aktualisieren kann, während Clients lesen. Zwei Hooks bringen deinen Code in den Anfragepfad. OnReadRequest läuft, bevor eine Tabelle gelesen wird, und kann so die Werte just in time aktualisieren oder die Anfrage mit einem Exception-Code ablehnen. OnWriteRequest erhält die Werte, bevor sie gespeichert werden, und kann sie so prüfen, ändern oder den Schreibzugriff ablehnen und die Tabellen unberührt lassen.

TsgcModbusTCPServer

Viele gleichzeitige Verbindungen, jede mit eigenem Thread. Anfragen, die gemeinsam in einem Paket eintreffen, werden der Reihe nach beantwortet, eine auf mehrere Pakete verteilte Anfrage wird zusammengesetzt, und ein fehlerhafter Header schließt diese Verbindung und löst OnError aus. UnitId = 0 beantwortet jede Unit-ID, ein anderer Wert nur diese eine. Bindings wählen Schnittstellen und Ports, und OnClientConnect und OnClientDisconnect melden die Gegenstellen.

TsgcModbusRTUServer

Lauscht an einem TsgcSerialPort als Slave UnitId (1 bis 247). Er bildet Frames anhand der erwarteten Länge und der Stille von 3,5 Zeichen, ignoriert Frames mit falscher CRC oder anderer Adresse und führt Broadcast-Schreibvorgänge von Unit-ID 0 ohne Antwort aus, wie es die Spezifikation der seriellen Leitung verlangt.

Hooks im Verbindungsthread

Die Server-Ereignisse laufen im Verbindungsthread (TCP) oder im Frame-Thread (RTU) und geben ihr Ergebnis synchron zurück. Halte sie kurz und rufe die Methoden des Datenmodells ohne Bedenken auf: Die Hooks laufen ohne gehaltene Sperre.

Getestet gegen einen unabhängigen Modbus-Stack

Der Modbus Client und Server werden über Modbus TCP auf der Leitung gegen pymodbus getestet, eine unabhängige Open-Source-Implementierung: Funktionscodes 01 bis 06, 15, 16, 22, 23 und 43/14, Exception-Antworten, Float32-Werte und Geräteidentifikation. Die typisierten Helfer werden in allen vier Wortreihenfolgen gegen bekannte Byte-Vektoren geprüft. Die Delphi-Komponenten werden außerdem in beide Richtungen gegen die sgcWebSockets .NET Modbus-Komponenten getestet, Client gegen Server, mit jeweils 35 von 35 bestandenen Prüfungen.

Der Serial Port wird an einem echten COM-Port unter Windows und an Pseudo-Terminals unter Linux getestet, einschließlich des Schließens des Ports während ein Lesevorgang wartet. Der Modbus RTU Client und Server werden gegen simulierte Slaves und Master getestet: geteilte Frames, CRC-Fehler, andere Slave-Adressen und Broadcasts. Derselbe Code kompiliert auch für macOS.

Fragen zu Delphi Modbus

Erstelle einen TsgcModbusTCPClient, setze Host, Port (standardmäßig 502) und UnitId, setze Active := True und rufe ReadHoldingRegisters(Address, Count) auf. Es gibt ein Array TsgcModbusRegisters mit einem Word pro Register zurück. Adressen sind nullbasiert, so wie sie über die Leitung gehen.

Rufe ReadFloat32, ReadInt32 oder ReadUInt32 mit der Adresse des ersten der beiden Register auf, oder die Varianten ReadInput... für Input-Register. Wenn der Wert falsch aussieht, verwendet das Gerät eine andere Wortreihenfolge: Setze WordOrder auf mwoCDAB, mwoBADC oder mwoDCBA statt auf den Standard mwoABCD.

Ja. Öffne einen TsgcSerialPort am Adapter und weise ihn der Eigenschaft SerialPort von TsgcModbusRTUClient oder TsgcModbusRTUServer zu. Adapter mit automatischer Richtungssteuerung brauchen nichts weiter. Für Adapter, die den Sender über RTS umschalten, setze RtsControl := srcToggle: Windows verwendet den RTS-Toggle-Modus des Treibers und Linux den RS-485-Modus des Kernels.

Ja. Der Client führt jeweils eine Transaktion aus und hält für die gesamte Anfrage eine Sperre, Wiederholungen eingeschlossen, sodass Aufrufe mehrerer Threads sich einreihen und jeder seine eigene Antwort erhält. Aufrufe aus dem Hauptthread lösen keinen Deadlock aus: Bei TCP wird die Antwort von einem separaten Thread empfangen.

Platziere einen TsgcModbusTCPServer (oder TsgcModbusRTUServer mit einem Serial Port), fülle sein DataModel mit SetHoldingRegister, SetCoil und den anderen Settern und setze Active := True. Verwende OnReadRequest und OnWriteRequest, um Werte bei Bedarf zu berechnen oder Schreibzugriffe mit einem Modbus-Exception-Code abzulehnen.

Delphi 7 bis Delphi 13 und C++Builder, unter Windows (32 und 64 Bit), Linux 64 Bit und macOS. Der Serial Port und damit Modbus RTU ist unter Android und iOS nicht verfügbar.

Die Modbus- und Serial-Port-Komponenten sind in sgcWebSockets Enterprise (Delphi und .NET) und All-Access oder im eigenständigen Paket sgcIndustrial enthalten.

Weitere industrielle Komponenten in sgcWebSockets

Industrielle Komponenten

Serial Port, Modbus und der OPC UA Client in einem Bereich, mit der vollständigen Komponentenreferenz.

Modbus Client Referenz

Eigenschaften, Methoden und Ereignisse von TsgcModbusTCPClient und TsgcModbusRTUClient.

Modbus Server Referenz

TsgcModbusTCPServer, TsgcModbusRTUServer und die Hooks von TsgcModbusDataModel.

Delphi Serial Port

TsgcSerialPort für Windows, Linux und macOS: der Transport von Modbus RTU und zugleich eine eigenständige serielle Komponente.

Delphi MQTT Client

Modbus-Werte an einen MQTT-Broker veröffentlichen: der übliche Weg, Fabrikdaten in die Cloud zu bringen.

Auch für C# und .NET

Dieselben Modbus Clients und Server, mit denselben Klassennamen, für .NET 8, 9, 10 und .NET Standard 2.0.

Bestes Preis-Leistungs-Verhältnis: All-AccessAlle eSeGeCe-Produkte, inklusive Premium-Support, ab €1,059 pro Jahr.
All-Access-Preise ansehen

Sprich aus Delphi mit deiner ersten SPS

Enthalten in sgcWebSockets Enterprise (Delphi und .NET) und All-Access oder im eigenständigen Paket sgcIndustrial.