C# et .NET Nouveau

Bibliothèque Modbus C# TCP et RTU pour .NET

Lis et écris des automates, variateurs et compteurs depuis C#, ou sers tes propres données comme esclave Modbus, sur Ethernet ou RS-485.

Modbus TCP et Modbus RTU
Client et serveur
Float32, Int32 et chaînes dans n'importe quel ordre de mots
Appels bloquants thread-safe

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

Lire et écrire un appareil en C# → · FAQ Modbus →

Client Modbus TCP C#
using esegece.sgcWebSockets;

var modbus = new TsgcModbusTCPClient();
modbus.Host = "192.168.1.50";
modbus.Port = 502;
modbus.Active = true;

ushort[] registers = modbus.ReadHoldingRegisters(0, 10);  // FC 03
float temperature = modbus.ReadFloat32(200);               // 2 registers
modbus.WriteSingleCoil(5, true);                           // FC 05

Clients et serveurs Modbus pour .NET

Quatre composants, une seule API pour TCP et RTU, un modèle de données thread-safe derrière les serveurs.

La bibliothèque Modbus C# de sgcWebSockets .NET se trouve dans le paquet esegece.sgcIndustrial, espace de noms esegece.sgcWebSockets. TsgcModbusTCPClient et TsgcModbusRTUClient sont des maîtres Modbus qui interrogent les appareils ; TsgcModbusTCPServer et TsgcModbusRTUServer sont des esclaves Modbus qui répondent aux systèmes SCADA, aux IHM et à d'autres maîtres à partir d'un TsgcModbusDataModel. La ligne série est un TsgcSerialPort du même paquet, construit sur System.IO.Ports.

Les deux clients partagent TsgcModbusClient_Base, donc une méthode qui lit un registre sur Ethernet le lit aussi sur RS-485. Chaque appel bloque jusqu'à l'arrivée de la réponse ou l'expiration de Timeout, renvoie de simples tableaux .NET (ushort[] pour les registres, bool[] pour les bobines) et lève une exception typée quand l'appareil signale une erreur. Le paquet cible .NET 8, .NET 9, .NET 10 et .NET Standard 2.0.

Codes de fonction

01 à 08, 15, 16, 22, 23 et 43/14, une méthode chacun.

Valeurs typées

ReadFloat32, ReadInt32, ReadUInt32, ReadString et leurs équivalents d'écriture, avec WordOrder pour les quatre dispositions de registres.

Modbus TCP

Port 502 par défaut, avec TLS en option, un proxy HTTP ou SOCKS et la reconnexion automatique.

Modbus RTU

RS-232 et RS-485 avec trame de 3,5 caractères, contrôles CRC et écritures en diffusion.

Modbus en C#, pas à pas

Référence le paquet esegece.sgcIndustrial, puis choisis le transport. Chaque exemple de cette page compile avec .NET 8.

using esegece.sgcWebSockets;

var modbus = new TsgcModbusTCPClient();
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.OnError += (sender, error) => Console.WriteLine("#error: " + error);
modbus.Active = true;

ushort[] registers = modbus.ReadHoldingRegisters(0, 10);       // FC 03
bool[] coils = modbus.ReadCoils(0, 8);                         // FC 01
Console.WriteLine("HR0 = " + registers[0] + ", coil 0 = " + coils[0]);

modbus.WriteSingleRegister(100, 1234);                         // FC 06
modbus.WriteMultipleRegisters(110, new ushort[] { 1, 2, 3 });  // FC 16
modbus.WriteSingleCoil(5, true);                               // FC 05
modbus.WordOrder = TsgcModbusWordOrder.mwoCDAB;   // low word first
float temperature = modbus.ReadFloat32(200);       // 2 holding registers
int counter = modbus.ReadInt32(202);
string name = modbus.ReadString(300, 8);           // 8 registers, 16 characters
Console.WriteLine($"{name}: {temperature:F1} C, {counter} cycles");

modbus.WriteFloat32(210, 21.5f);
modbus.WriteUInt32(212, 3000000000);

// explicit unit id, for a gateway with several devices behind it
float flow = modbus.ReadInputFloat32(7, 0);        // unit 7, FC 04
Console.WriteLine("flow = " + flow);

try
{
    modbus.ReadHoldingRegisters(9000, 4);
}
catch (EsgcModbusException e)   // the device answered with an exception
{
    Console.WriteLine($"exception {e.ExceptionCode}, function {e.FunctionCode}");
}
catch (EsgcModbusTimeout e)     // no answer after Retries + 1 attempts
{
    Console.WriteLine(e.Message);
}
using esegece.sgcWebSockets;

var port = new TsgcSerialPort();
port.Port = "COM3";                              // "/dev/ttyUSB0" on Linux
port.BaudRate = 19200;
port.Parity = TsgcSerialParity.spEven;           // 8E1, the Modbus RTU default
port.Open();

var rtu = new TsgcModbusRTUClient();
rtu.SerialPort = port;
rtu.UnitId = 17;                                 // slave address
rtu.Timeout = 500;
rtu.Retries = 1;

ushort[] values = rtu.ReadInputRegisters(0, 4);  // FC 04
byte status = rtu.ReadExceptionStatus();         // FC 07
Console.WriteLine($"IR0 = {values[0]}, status = {status}");

rtu.WriteSingleRegister(0, 10, 500);             // unit 0: broadcast, no reply
using esegece.sgcWebSockets;

var server = new TsgcModbusTCPServer();
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";

var random = new Random();

// runs on the connection thread, before the table is read
server.OnReadRequest += (object sender, byte unitId, byte functionCode,
    ushort address, ushort count, ref byte exceptionCode) =>
{
    if (functionCode == sgcModbus_Classes.CS_MODBUS_FC_READ_INPUT_REGISTERS)
        server.DataModel.SetInputRegister(0, (ushort)random.Next(1000));
};

// registers 0..9 are read only
server.OnWriteRequest += (object sender, byte unitId, byte functionCode,
    ushort address, ushort count, ref bool[] bits, ref ushort[] registers,
    ref byte exceptionCode) =>
{
    if (registers.Length > 0 && address < 10)
        exceptionCode = sgcModbus_Classes.CS_MODBUS_EX_ILLEGAL_DATA_ADDRESS;
};

server.Active = true;
Console.ReadLine();

Les appels sont synchrones. Dans une application WinForms, WPF ou ASP.NET, exécute une boucle d'interrogation dans un thread de travail ou dans Task.Run ; le client est thread-safe, donc plusieurs tâches peuvent partager une même connexion.

Codes fonction Modbus pris en charge

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 C#
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 avec TsgcModbusDeviceIdCode basic, regular, extended ou specific

Un maître Modbus conçu pour la production

Ordre des mots

TsgcModbusWordOrder.mwoABCD est big endian, la valeur par défaut de Modbus. mwoCDAB place le mot de poids faible en premier, mwoBADC échange les octets de chaque registre et mwoDCBA est entièrement little endian. Les chaînes sont empaquetées à raison de deux caractères par registre.

Thread-safe

Une seule transaction à la fois par client, sous un verrou qui couvre toutes ses nouvelles tentatives. En TCP, la réponse est associée par le thread de réception et remise à l'appel en attente, si bien qu'un appel depuis un thread d'interface ne peut pas provoquer d'interblocage.

Timeouts et nouvelles tentatives

Timeout est l'attente par tentative, Retries les tentatives supplémentaires. Une nouvelle tentative TCP utilise un nouvel identifiant de transaction, et les réponses périmées ou en double sont ignorées.

Exceptions typées

EsgcModbusException porte ExceptionCode et FunctionCode, EsgcModbusTimeout signale une réponse manquante, et EsgcModbusError couvre les connexions fermées, les problèmes de port et les erreurs CRC en RTU.

Passerelles et identifiants d'unité

Chaque méthode a une surcharge avec un byte aUnitId en tête, si bien qu'une seule connexion TCP vers une passerelle atteint tous les appareils situés derrière elle.

TLS, proxy et reconnexion

TLS, TLSOptions, Proxy et WatchDog sont transmis au client TCP de sgcWebSockets en dessous, de sorte que Modbus TCP profite de la même pile TLS, de la même prise en charge des proxys et de la même reconnexion automatique que le reste de la bibliothèque.

Trame RTU

Le client RTU attend le silence de 3,5 caractères avant d'envoyer, lit la réponse selon sa longueur attendue, vérifie le CRC de chaque trame et ignore les trames d'autres adresses d'esclave. L'identifiant d'unité 0 envoie une écriture en diffusion et attend TurnaroundDelay au lieu d'une réponse.

Direction RS-485

Avec RtsControl = TsgcSerialRtsControl.srcToggle, le port série lève RTS à chaque écriture et le relâche quand le tampon de sortie est vidé. En .NET, cela est temporisé par logiciel ; pour un timing de bus strict, préfère donc un adaptateur à contrôle de direction automatique.

Événements

OnConnect, OnDisconnect et OnError sont déclenchés via NotifyEvents, dans l'ordre où ils se sont produits. Une connexion qui échoue ne lève pas d'exception : elle déclenche OnError et Active reste à false.

Serveurs Modbus TCP et RTU en C#

Construis une passerelle qui expose des valeurs de base de données ou du cloud à un système SCADA, un simulateur pour tester des écrans d'IHM sans matériel, ou l'interface Modbus de ton propre appareil. Chaque serveur possède un TsgcModbusDataModel avec les quatre tables (bobines, entrées discrètes, registres de maintien et registres d'entrée, 10 000 entrées chacune par défaut et jusqu'à 65 536), les chaînes d'identification pour FC 43/14 et l'état d'exception pour FC 07. Chaque membre du modèle de données est thread-safe.

OnReadRequest s'exécute avant la lecture d'une table, il peut donc actualiser des valeurs ou répondre par un code d'exception. OnWriteRequest reçoit les valeurs avant leur stockage et peut les modifier ou rejeter l'écriture, en laissant les tables intactes. Les deux s'exécutent dans le thread du serveur qui traite la requête (la connexion TCP ou le lecteur de trames RTU), sans verrou tenu.

TsgcModbusTCPServer

Nombreuses connexions simultanées, requêtes traitées dans l'ordre d'arrivée, requêtes fragmentées réassemblées et en-têtes mal formés qui ferment la connexion avec OnError. UnitId = 0 répond à n'importe quel identifiant d'unité. Bindings sélectionne les points d'accès, Port = 0 choisit un port libre, et OnClientConnect et OnClientDisconnect signalent les pairs.

TsgcModbusRTUServer

Répond en tant qu'esclave UnitId (1 à 247) sur un TsgcSerialPort, délimite les requêtes par leur longueur et le silence de 3,5 caractères, ignore les CRC erronés et les autres adresses, et exécute les écritures en diffusion sans répondre.

Testé dans les deux sens

Le client et le serveur .NET passent les mêmes contrôles d'interopérabilité avec pymodbus en TCP et avec les composants Modbus Delphi de sgcWebSockets, 35 sur 35 dans chaque sens.

Inclus dans sgcWebSockets Enterprise

Les composants Modbus et port série sont inclus dans sgcWebSockets Enterprise (Delphi et .NET) et All-Access, sous la forme du paquet esegece.sgcIndustrial à côté des autres paquets sgcWebSockets .NET. Compare les éditions sur la page des tarifs (onglet .NET) ou dans la matrice des fonctionnalités .NET.

Questions sur Modbus C#

Crée un TsgcModbusTCPClient, renseigne Host, Port et UnitId, mets Active = true et appelle ReadHoldingRegisters(address, count). Il renvoie un ushort[] avec une valeur par registre. Les adresses commencent à zéro, comme sur le fil.

Appelle ReadFloat32(address) pour les registres de maintien ou ReadInputFloat32(address) pour les registres d'entrée. Si le nombre semble faux, l'appareil stocke les deux registres dans un autre ordre : mets WordOrder à mwoCDAB, mwoBADC ou mwoDCBA.

Oui. Ouvre un TsgcSerialPort sur l'adaptateur RS-485 et assigne-le à TsgcModbusRTUClient.SerialPort ou TsgcModbusRTUServer.SerialPort. Utilise un adaptateur à contrôle de direction automatique, ou mets RtsControl à srcToggle pour les adaptateurs commutés par RTS.

Oui. Crée un TsgcModbusTCPServer, remplis DataModel avec SetHoldingRegister, SetCoil et les autres setters, puis mets Active = true. Gère OnReadRequest et OnWriteRequest pour calculer des valeurs à la demande ou rejeter des écritures avec un code d'exception Modbus.

Non, les méthodes du client sont synchrones et thread-safe. Appelle-les depuis un thread de travail ou enveloppe-les dans Task.Run ; plusieurs threads ou tâches peuvent partager un même client, et chaque appel attend sa propre réponse.

Le paquet esegece.sgcIndustrial cible .NET 8, .NET 9, .NET 10 et .NET Standard 2.0. Le port série utilise System.IO.Ports, donc Modbus RTU nécessite une plateforme où ce paquet peut ouvrir des ports série.

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

Plus sur sgcWebSockets .NET

Composants industriels

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

Client OPC UA C#

Lis, écris et abonne-toi aux serveurs OPC UA depuis la même application .NET, à côté des appareils Modbus.

Client MQTT C#

Publie des lectures Modbus vers un broker MQTT depuis la même application.

Bibliothèque WebSocket C#

Client et serveur WebSocket pour des tableaux de bord qui affichent en direct les données des appareils.

Aussi pour Delphi et C++Builder

Les mêmes composants Modbus, avec les mêmes noms de classes et de méthodes, pour Delphi 7 à Delphi 13.

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

Lis ton premier registre Modbus depuis C#

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