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
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
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.
TsgcModbusTCPClientTsgcModbusRTUClient
Modbus Application Protocol V1.1b3, Modbus TCP et Modbus RTU
TCP : toutes les plateformes de sgcWebSockets. RTU : Windows, Linux et macOS
Inclus dans sgcWebSockets Enterprise (Delphi et .NET) et All-Access, ou dans le pack autonome sgcIndustrial
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);
}
}
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.
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).
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.
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.
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.
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.
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.
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);
}
}
TurnaroundDelay
Sources de référence pour le protocole implémenté par ce composant.
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.
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. | Ouvrir | |
| Online Help: TsgcModbusRTUClient Référence complète des propriétés, méthodes et événements du client Modbus RTU. | Ouvrir | |
| 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. | Ouvrir | |
| Document technique (PDF) Fonctionnalités, démarrage rapide, exemples de code et références de sources primaires pour ce seul composant. | Ouvrir | |
| Manuel utilisateur (PDF) Manuel complet couvrant tous les composants de la bibliothèque. | Ouvrir |