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.
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.
ReadDeviceIdentification (Basic, Regular, Extended und einzelnes Objekt)
QuickStart
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 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
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.
Server
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.
Interoperabilität
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.
FAQ
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.