Nouveau

Modbus pour Delphi TCP et RTU : composants client et serveur

Composants natifs Modbus TCP et Modbus RTU pour Delphi et C++Builder. Interroge des PLC, des variateurs, des compteurs d'énergie et des passerelles, ou publie tes propres données comme serveur Modbus, avec des méthodes typées Float32, Int32 et chaîne dans tous les ordres de mots.

Inclus dans sgcWebSockets Enterprise (Delphi et .NET) et All-Access, ou dans le pack autonome sgcIndustrial.

Deux clients, deux serveurs, une seule API Modbus

Des maîtres et des esclaves Modbus TCP et Modbus RTU sous forme de composants non visuels, écrits en Pascal et compilés dans ton application.

Une bibliothèque Modbus pour Delphi permet à une application VCL, FMX, service ou console de dialoguer avec les appareils présents dans toutes les usines : PLC, variateurs de fréquence, compteurs d'énergie, régulateurs de température et passerelles de protocoles. sgcWebSockets la livre sous forme de quatre composants : TsgcModbusTCPClient et TsgcModbusRTUClient interrogent les appareils, tandis que TsgcModbusTCPServer et TsgcModbusRTUServer exposent tes propres données aux systèmes SCADA, aux IHM et à tout autre maître Modbus.

Les deux clients descendent de TsgcModbusClient_Base, si bien que le code qui lit un registre sur Ethernet le lit aussi sur RS-485 : tu changes de composant, pas d'appels. Chaque appel bloque jusqu'à l'arrivée de la réponse ou l'expiration de Timeout, renvoie les valeurs sous forme de tableaux Delphi et lève une exception typée quand l'appareil signale une erreur. Une seule ligne uses sgcIndustrial; apporte toutes les classes.

Classes de composants

TsgcModbusTCPClient, TsgcModbusRTUClient, TsgcModbusTCPServer, TsgcModbusRTUServer, TsgcModbusDataModel

Transports

Modbus TCP sur le port 502 avec TLS et proxy facultatifs ; Modbus RTU sur RS-232 et RS-485 via TsgcSerialPort

Codes de fonction

01 à 08, 15, 16, 22, 23 et 43/14 (lecture de l'identification de l'appareil)

Plateformes

Delphi 7 à Delphi 13 et C++Builder ; Windows, Linux et macOS

Chaque fonction Modbus courante, une méthode chacune

Le client vérifie les quantités par rapport à la spécification avant tout envoi ; les serveurs répondent à tous les codes de ce tableau.

FCFonctionMéthode du client
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 (ligne série)ReadExceptionStatus sur le client RTU
08Diagnostics (ligne série)Diagnostics sur le client RTU
15Write Multiple CoilsWriteMultipleCoils
16Write Multiple RegistersWriteMultipleRegisters, WriteInt32, WriteUInt32, WriteFloat32, WriteString
22Mask Write RegisterMaskWriteRegister
23Read/Write Multiple RegistersReadWriteMultipleRegisters
43/14Read Device IdentificationReadDeviceIdentification (objet de base, régulier, étendu et objet unique)

Lire un PLC en quelques lignes de Delphi

Crée le composant, indique l'adresse, appelle une méthode. Chaque exemple de cette page se compile avec Delphi 7 et 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;

Un maître Modbus que tu peux appeler depuis n'importe quel thread

Appels bloquants, valeurs typées et erreurs claires, sur TCP et sur la ligne série.

Valeurs 32 bits typées et chaînes

ReadFloat32, ReadInt32, ReadUInt32 et leurs équivalents d'écriture et d'input register combinent deux registres en une seule valeur. WordOrder couvre les quatre dispositions qu'utilisent les appareils : mwoABCD (big endian, la valeur par défaut de Modbus), mwoCDAB, mwoBADC et mwoDCBA. ReadString et WriteString placent deux caractères par registre.

Appels bloquants thread-safe

Une seule requête s'exécute à la fois par client, protégée par un verrou qui couvre toutes ses nouvelles tentatives, si bien que plusieurs threads peuvent partager une même connexion. Sur TCP, la réponse est associée par le thread de réception, donc un appel depuis le thread principal ne peut pas provoquer d'interblocage.

Timeouts et nouvelles tentatives

Timeout est l'attente par tentative et Retries le nombre de tentatives supplémentaires. Une nouvelle tentative TCP utilise un nouvel identifiant de transaction, et les réponses tardives ou en double sont écartées au lieu d'être prises pour la réponse suivante.

Exceptions typées

EsgcModbusException porte le ExceptionCode et le FunctionCode de l'appareil, EsgcModbusTimeout signale l'absence de réponse, et EsgcModbusError couvre tout le reste, d'une connexion fermée à une trame RTU avec un CRC invalide.

Identifiant d'unité par appel

Chaque méthode a aussi une surcharge avec un identifiant d'unité en premier paramètre, si bien qu'une seule connexion à une passerelle atteint tous les appareils qui se trouvent derrière. UnitId est la valeur par défaut pour les appels qui n'en ont pas.

TLS, proxy et reconnexion sur TCP

TLS et TLSOptions enveloppent le flux Modbus TCP dans TLS, Proxy atteint un appareil à travers un proxy HTTP ou SOCKS, et WatchDog se reconnecte après une coupure réseau. Les trois viennent du client TCP de sgcWebSockets sur lequel le composant est construit.

Un framing RTU bien fait

Le client RTU attend le silence de 3,5 caractères avant d'envoyer, lit la réponse selon sa longueur attendue (les adaptateurs USB livrent les octets par rafales), vérifie le CRC de chaque trame et ignore les trames des autres adresses d'esclave.

RS-485 et diffusion

Mets RtsControl := srcToggle sur le port série et RTS commute l'émetteur RS-485 à chaque écriture, via le pilote sous Windows et via le mode RS-485 du noyau sous Linux. L'identifiant d'unité 0 envoie une écriture en diffusion à tous les esclaves et attend TurnaroundDelay au lieu d'une réponse.

Des événements là où tu les veux

OnConnect, OnDisconnect et OnError sont livrés via NotifyEvents : placés par défaut dans la file du thread principal, synchronisés, ou levés directement dans le thread de réception.

Serveurs Modbus TCP et RTU avec un modèle de données en direct

Transforme une application Delphi en esclave Modbus : une passerelle qui expose les valeurs d'une base de données ou d'une API REST, un simulateur d'appareil pour tester des écrans d'IHM, ou la face Modbus de ton propre contrôleur. Chaque serveur possède un TsgcModbusDataModel avec les quatre tables Modbus (coils, discrete inputs, holding registers et input registers, 10 000 entrées chacune par défaut et jusqu'à 65 536), les chaînes d'identification de l'appareil renvoyées sur FC 43/14 et l'exception status renvoyé sur FC 07.

Le modèle de données est thread-safe : un seul verrou protège toutes les tables, si bien que ton code peut mettre à jour les valeurs pendant que les clients les lisent. Deux hooks placent ton code dans le chemin de la requête. OnReadRequest s'exécute avant la lecture d'une table, il peut donc actualiser les valeurs au dernier moment ou refuser la requête avec un code d'exception. OnWriteRequest reçoit les valeurs avant leur stockage, il peut donc les valider, les modifier ou rejeter l'écriture en laissant les tables intactes.

TsgcModbusTCPServer

De nombreuses connexions simultanées, chacune avec son propre thread. Les requêtes qui arrivent ensemble dans un même paquet reçoivent une réponse dans l'ordre, une requête répartie sur plusieurs paquets est reconstituée, et un en-tête mal formé ferme cette connexion et déclenche OnError. UnitId = 0 répond à n'importe quel identifiant d'unité ; une autre valeur ne répond qu'à celui-là. Bindings choisit les interfaces et les ports, et OnClientConnect et OnClientDisconnect signalent les pairs.

TsgcModbusRTUServer

Écoute sur un TsgcSerialPort en tant qu'esclave UnitId (1 à 247). Il délimite les requêtes par leur longueur attendue et par le silence de 3,5 caractères, ignore les trames avec un CRC invalide ou une autre adresse, et exécute les écritures en diffusion depuis l'identifiant d'unité 0 sans répondre, comme l'exige la spécification de la ligne série.

Hooks dans le thread de connexion

Les événements du serveur s'exécutent dans le thread de connexion (TCP) ou dans le thread de trame (RTU) et renvoient leur résultat de façon synchrone. Garde-les courts, et appelle librement les méthodes du modèle de données : les hooks s'exécutent sans verrou détenu.

Testé contre une pile Modbus indépendante

Le client et le serveur Modbus sont testés sur le réseau contre pymodbus, une implémentation open source indépendante, via Modbus TCP : codes de fonction 01 à 06, 15, 16, 22, 23 et 43/14, réponses d'exception, valeurs Float32 et identification de l'appareil. Les méthodes typées sont vérifiées contre des vecteurs d'octets connus dans les quatre ordres de mots. Les composants Delphi sont aussi testés contre les composants Modbus .NET de sgcWebSockets dans les deux sens, client contre serveur, avec 35 contrôles réussis sur 35 dans chaque sens.

Le port série est testé sur un vrai port COM sous Windows et sur des pseudo-terminaux sous Linux, y compris la fermeture du port pendant qu'une lecture est en attente. Le client et le serveur Modbus RTU sont testés contre des esclaves et des maîtres simulés : trames fragmentées, erreurs de CRC, autres adresses d'esclave et diffusions. Le même code se compile pour macOS.

Questions sur Modbus pour Delphi

Crée un TsgcModbusTCPClient, indique Host, Port (502 par défaut) et UnitId, mets Active := True et appelle ReadHoldingRegisters(Address, Count). Il renvoie un tableau TsgcModbusRegisters avec un Word par registre. Les adresses commencent à zéro, comme sur le réseau.

Appelle ReadFloat32, ReadInt32 ou ReadUInt32 avec l'adresse du premier des deux registres, ou les variantes ReadInput... pour les input registers. Si la valeur semble fausse, l'appareil utilise un autre ordre de mots : mets WordOrder à mwoCDAB, mwoBADC ou mwoDCBA au lieu de la valeur par défaut mwoABCD.

Oui. Ouvre un TsgcSerialPort sur l'adaptateur et affecte-le à la propriété SerialPort de TsgcModbusRTUClient ou TsgcModbusRTUServer. Les adaptateurs avec contrôle de direction automatique n'ont besoin de rien d'autre. Pour les adaptateurs qui commutent l'émetteur avec RTS, mets RtsControl := srcToggle : Windows utilise le mode de bascule RTS du pilote et Linux le mode RS-485 du noyau.

Oui. Le client exécute une transaction à la fois et détient un verrou pendant toute la requête, nouvelles tentatives comprises, si bien que les appels de plusieurs threads font la queue et que chacun reçoit sa propre réponse. Les appels depuis le thread principal ne provoquent pas d'interblocage : sur TCP, la réponse est reçue par un thread distinct.

Dépose un TsgcModbusTCPServer (ou un TsgcModbusRTUServer avec un port série), remplis son DataModel avec SetHoldingRegister, SetCoil et les autres setters, puis mets Active := True. Utilise OnReadRequest et OnWriteRequest pour calculer des valeurs à la demande ou pour rejeter des écritures avec un code d'exception Modbus.

Delphi 7 à Delphi 13 et C++Builder, sous Windows (32 et 64 bits), Linux 64 bits et macOS. Le port série, et avec lui Modbus RTU, n'est pas disponible sous Android ni iOS.

Les composants Modbus et de port série sont inclus dans sgcWebSockets Enterprise (Delphi et .NET) et All-Access, ou dans le pack autonome sgcIndustrial.

Plus de composants industriels dans sgcWebSockets

Composants industriels

Port série, Modbus et client OPC UA dans une seule section, avec la référence complète des composants.

Référence du client Modbus

Propriétés, méthodes et événements de TsgcModbusTCPClient et TsgcModbusRTUClient.

Référence du serveur Modbus

TsgcModbusTCPServer, TsgcModbusRTUServer et les hooks de TsgcModbusDataModel.

Port série pour Delphi

TsgcSerialPort pour Windows, Linux et macOS : le transport de Modbus RTU, et aussi un composant série à part entière.

Client MQTT pour Delphi

Publie des valeurs Modbus vers un broker MQTT : la façon habituelle d'amener les données de l'usine vers le cloud.

Aussi pour C# et .NET

Les mêmes clients et serveurs Modbus, avec les mêmes noms de classes, pour .NET 8, 9, 10 et .NET Standard 2.0.

Meilleur rapport qualité-prix : All-AccessTous les produits eSeGeCe, Support Premium inclus, à partir de €1,059/an.
Voir les tarifs All-Access

Parle à ton premier PLC depuis Delphi

Inclus dans sgcWebSockets Enterprise (Delphi et .NET) et All-Access, ou dans le pack autonome sgcIndustrial.