Client Modbus TCP et RTU

Lis et écris les coils et les registres des PLC, des compteurs d'énergie et des variateurs depuis Delphi, C++Builder et .NET, via TCP/IP ou une ligne série RS-232 ou RS-485.

Nouveau

TsgcModbusTCPClient et TsgcModbusRTUClient

Deux clients avec les mêmes méthodes : l'un se connecte à un appareil ou une passerelle Modbus TCP, l'autre est un maître Modbus RTU sur une ligne série.

Classes de composants

TsgcModbusTCPClient
TsgcModbusRTUClient

Protocole

Modbus Application Protocol V1.1b3, Modbus TCP et Modbus RTU

Plateformes

TCP : toutes les plateformes de sgcWebSockets. RTU : Windows, Linux et macOS

Édition

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

Se connecter, lire et écrire via Modbus TCP

Indique Host et UnitId, mets Active à True et appelle les méthodes. Chaque requête bloque jusqu'à l'arrivée de la réponse correspondante, et lève une exception lorsque l'appareil signale une erreur ou ne répond pas.

uses
  sgcIndustrial;

procedure TForm1.ConnectClient;
begin
  FClient := TsgcModbusTCPClient.Create(Self);
  FClient.Host := '192.168.1.50';
  FClient.Port := 502;
  FClient.UnitId := 1;
  FClient.Timeout := 1000;
  FClient.Retries := 2;
  FClient.OnConnect := OnModbusConnect;
  FClient.OnError := OnModbusError;
  FClient.Active := True;
end;

procedure TForm1.OnModbusConnect(Sender: TObject);
begin
  Memo1.Lines.Add('Connected');
end;

procedure TForm1.ReadValues;
var
  vRegisters: TsgcModbusRegisters;
  vTemperature: Single;
begin
  try
    vRegisters := FClient.ReadHoldingRegisters(0, 10);
    FClient.WriteSingleCoil(10, True);
    // 32-bit float stored low word first by many PLCs
    FClient.WordOrder := mwoCDAB;
    vTemperature := FClient.ReadFloat32(300);
    Memo1.Lines.Add(Format('HR0 = %d, temperature = %.1f',
      [vRegisters[0], vTemperature]));
  except
    on E: EsgcModbusException do
      Memo1.Lines.Add(Format('Device exception %d', [E.ExceptionCode]));
    on E: EsgcModbusTimeout do
      Memo1.Lines.Add('No response');
  end;
end;

procedure TForm1.OnModbusError(Sender: TObject; const aError: string);
begin
  Memo1.Lines.Add('Error: ' + aError);
end;
#include "sgcIndustrial.hpp"

void __fastcall TForm1::ConnectClient()
{
  FClient = new TsgcModbusTCPClient(this);
  FClient->Host = "192.168.1.50"; // Port is 502 by default
  FClient->UnitId = 1;
  FClient->Timeout = 1000;
  FClient->Retries = 2;
  FClient->OnConnect = OnModbusConnect;
  FClient->OnError = OnModbusError;
  FClient->Active = true;
}

void __fastcall TForm1::OnModbusConnect(TObject *Sender)
{
  Memo1->Lines->Add("Connected");
}

void __fastcall TForm1::ReadValues()
{
  try
  {
    TsgcModbusRegisters vRegisters = FClient->ReadHoldingRegisters(0, 10);
    FClient->WriteSingleCoil(10, true);
    // 32-bit float stored low word first by many PLCs
    FClient->WordOrder = mwoCDAB;
    float vTemperature = FClient->ReadFloat32(300);
    Memo1->Lines->Add("HR0 = " + IntToStr(vRegisters[0]) + ", temperature = " +
      FloatToStrF(vTemperature, ffFixed, 7, 1));
  }
  catch (EsgcModbusException &E)
  {
    Memo1->Lines->Add("Device exception " + IntToStr(E.ExceptionCode));
  }
  catch (EsgcModbusTimeout &E)
  {
    Memo1->Lines->Add("No response");
  }
}

void __fastcall TForm1::OnModbusError(TObject *Sender, const String aError)
{
  Memo1->Lines->Add("Error: " + aError);
}
using System;
using esegece.sgcWebSockets;

class PlcClient
{
    TsgcModbusTCPClient FClient = new TsgcModbusTCPClient();

    public void ConnectClient()
    {
        FClient.Host = "192.168.1.50";
        FClient.Port = 502;
        FClient.UnitId = 1;
        FClient.Timeout = 1000;
        FClient.Retries = 2;
        FClient.OnConnect += OnModbusConnect;
        FClient.OnError += OnModbusError;
        FClient.Active = true;
    }

    void OnModbusConnect(object Sender, EventArgs e)
    {
        Console.WriteLine("Connected");
    }

    public void ReadValues()
    {
        try
        {
            ushort[] vRegisters = FClient.ReadHoldingRegisters(0, 10);
            FClient.WriteSingleCoil(10, true);
            // 32-bit float stored low word first by many PLCs
            FClient.WordOrder = TsgcModbusWordOrder.mwoCDAB;
            float vTemperature = FClient.ReadFloat32(300);
            Console.WriteLine($"HR0 = {vRegisters[0]}, temperature = {vTemperature:F1}");
        }
        catch (EsgcModbusException E)
        {
            Console.WriteLine("Device exception " + E.ExceptionCode);
        }
        catch (EsgcModbusTimeout)
        {
            Console.WriteLine("No response");
        }
    }

    void OnModbusError(object Sender, string aError)
    {
        Console.WriteLine("Error: " + aError);
    }
}

Sous le capot

Le framing, le timing et la gestion des erreurs de Modbus sont assurés par le composant, ton code ne manipule donc que des adresses et des valeurs.

Codes de fonction

01 à 06, 15, 16, 22 (mask write), 23 (read/write multiple registers) et 43/14 (identification de l'appareil, avec pagination). Le client RTU ajoute 07 (read exception status) et 08 (diagnostics).

Valeurs typées

ReadInt32, ReadUInt32, ReadFloat32, ReadString et leurs équivalents d'écriture, ainsi que des lectures depuis les input registers. WordOrder choisit ABCD, DCBA, BADC ou CDAB pour correspondre à l'appareil.

Requêtes thread-safe

Appelle les méthodes depuis n'importe quel thread : les requêtes sont sérialisées et chaque réponse est associée par son identifiant de transaction. Timeout s'applique à chaque tentative et Retries ajoute des tentatives.

Erreurs claires

Une réponse d'exception Modbus lève EsgcModbusException avec les codes d'exception et de fonction, l'absence de réponse lève EsgcModbusTimeout, et tout autre problème lève EsgcModbusError. Les quantités hors spécification sont rejetées avant tout envoi.

TLS, proxy et reconnexion

Le client TCP prend en charge TLS, Proxy et WatchDog pour la reconnexion automatique. Une requête en attente au moment où la connexion tombe lève immédiatement une exception, sans attendre le timeout.

Passerelles et identifiants d'unité

Chaque méthode dispose d'une surcharge avec un identifiant d'unité en premier paramètre, si bien qu'une seule connexion TCP atteint tous les appareils derrière une passerelle Modbus TCP vers RTU sans changer UnitId.

Un maître RTU sur RS-232 et RS-485

Ouvre un TsgcSerialPort, relie-le avec SerialPort et indique l'adresse de l'esclave dans UnitId. Le client construit la trame RTU avec son CRC16 et attend l'esclave.

procedure TForm1.ReadSlave;
var
  vRegisters: TsgcModbusRegisters;
begin
  FPort := TsgcSerialPort.Create(Self);
  FPort.Port := 'COM4';
  FPort.BaudRate := 19200;
  FPort.Parity := spEven;
  FPort.Open;

  FRTU := TsgcModbusRTUClient.Create(Self);
  FRTU.SerialPort := FPort;
  FRTU.UnitId := 17;
  FRTU.Timeout := 500;
  FRTU.Retries := 2;
  vRegisters := FRTU.ReadHoldingRegisters(107, 3);
  Memo1.Lines.Add(Format('Register 107 = %d', [vRegisters[0]]));

  // unit id 0 = broadcast: every slave executes the write, none answers
  FRTU.WriteSingleRegister(0, 1, 100);
end;
void __fastcall TForm1::ReadSlave()
{
  FPort = new TsgcSerialPort(this);
  FPort->Port = "COM4";
  FPort->BaudRate = 19200;
  FPort->Parity = spEven;
  FPort->Open();

  FRTU = new TsgcModbusRTUClient(this);
  FRTU->SerialPort = FPort;
  FRTU->UnitId = 17;
  FRTU->Timeout = 500;
  FRTU->Retries = 2;
  TsgcModbusRegisters vRegisters = FRTU->ReadHoldingRegisters(107, 3);
  Memo1->Lines->Add("Register 107 = " + IntToStr(vRegisters[0]));

  // unit id 0 = broadcast: every slave executes the write, none answers
  FRTU->WriteSingleRegister(0, 1, 100);
}
using System;
using esegece.sgcWebSockets;

class RtuMaster
{
    TsgcSerialPort FPort = new TsgcSerialPort();
    TsgcModbusRTUClient FRTU = new TsgcModbusRTUClient();

    public void ReadSlave()
    {
        FPort.Port = "COM4";
        FPort.BaudRate = 19200;
        FPort.Parity = TsgcSerialParity.spEven;
        FPort.Open();

        FRTU.SerialPort = FPort;
        FRTU.UnitId = 17;
        FRTU.Timeout = 500;
        FRTU.Retries = 2;
        ushort[] vRegisters = FRTU.ReadHoldingRegisters(107, 3);
        Console.WriteLine("Register 107 = " + vRegisters[0]);

        // unit id 0 = broadcast: every slave executes the write, none answers
        FRTU.WriteSingleRegister(0, 1, 100);
    }
}

Spécifications et références

Sources de référence pour le protocole implémenté par ce composant.

Questions sur le client Modbus

Les méthodes prennent l'adresse du protocole, qui commence à 0. Le registre que de nombreux manuels documentent comme 40001 est le holding register 0, donc appelle ReadHoldingRegisters(0, 1).

Appelle ReadFloat32 avec l'adresse du premier de ses deux registres. Si la valeur semble fausse, l'appareil stocke les octets dans un autre ordre : mets WordOrder à l'ordre qu'utilise l'appareil. Beaucoup de PLC stockent d'abord le mot de poids faible, ce qui correspond à mwoCDAB.

Chaque tentative attend Timeout millisecondes. Après Retries + 1 tentatives sans réponse valide, la requête lève EsgcModbusTimeout, avec le code de fonction, l'identifiant d'unité et le nombre de tentatives dans le message.

Non. Ouvre toi-même le TsgcSerialPort et laisse son événement OnData vide, car le client lit les réponses avec Read. Une requête lève EsgcModbusError quand le port n'est pas affecté, n'est pas ouvert ou a OnData affecté.

Il est inclus dans sgcWebSockets Enterprise (Delphi et .NET) et All-Access, dans le cadre du pack sgcIndustrial. En Delphi, ajoute sgcIndustrial à la clause uses.

Documentation et démos

Accède directement à la référence du composant, ouvre le projet de démo et lis le document technique.

Online Help: TsgcModbusTCPClient Référence complète des propriétés, méthodes et événements du client Modbus TCP.
Online Help: TsgcModbusRTUClient Référence complète des propriétés, méthodes et événements du client Modbus RTU.
Projet de démo : Industrial\02.Modbus_TCP_Client Un client Modbus TCP pour Delphi, C++Builder et .NET. Il est livré dans le paquet sgcWebSockets.
Document technique (PDF) Fonctionnalités, démarrage rapide, exemples de code et références de sources primaires pour ce seul composant.
Manuel utilisateur (PDF) Manuel complet couvrant tous les composants de la bibliothèque.
Meilleur rapport qualité-prix : All-AccessTous les produits eSeGeCe, Support Premium inclus, à partir de €1,059/an.
Voir les tarifs All-Access

Inclus dans sgcWebSockets Enterprise

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