C# en .NET Nieuw

C# Modbus TCP- en RTU-bibliotheek voor .NET

Lees en schrijf PLC's, aandrijvingen en meters vanuit C#, of bied je eigen data aan als Modbus-slave, via Ethernet of RS-485.

Modbus TCP en Modbus RTU
Client en server
Float32, Int32 en strings in elke woordvolgorde
Thread-safe blokkerende aanroepen

Inbegrepen in sgcWebSockets Enterprise (Delphi en .NET) en All-Access, of in het standalone pakket sgcIndustrial.

Een apparaat lezen en schrijven in C# → · Modbus FAQ →

C# Modbus TCP-client
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

Modbus-clients en -servers voor .NET

Vier componenten, één API voor TCP en RTU, een thread-safe datamodel achter de servers.

De C# Modbus-bibliotheek in sgcWebSockets .NET zit in het pakket esegece.sgcIndustrial, namespace esegece.sgcWebSockets. TsgcModbusTCPClient en TsgcModbusRTUClient zijn Modbus-masters die apparaten pollen; TsgcModbusTCPServer en TsgcModbusRTUServer zijn Modbus-slaves die SCADA-systemen, HMI's en andere masters beantwoorden vanuit een TsgcModbusDataModel. De seriële lijn is een TsgcSerialPort uit hetzelfde pakket, gebouwd op System.IO.Ports.

Beide clients delen TsgcModbusClient_Base, zodat een methode die een register via Ethernet leest het ook via RS-485 leest. Elke aanroep blokkeert tot het antwoord binnenkomt of Timeout verloopt, geeft gewone .NET-arrays terug (ushort[] voor registers, bool[] voor coils) en geeft een getypeerde exception als het apparaat een fout meldt. Het pakket richt zich op .NET 8, .NET 9, .NET 10 en .NET Standard 2.0.

Functiecodes

01 tot 08, 15, 16, 22, 23 en 43/14, elk één methode.

Getypeerde waarden

ReadFloat32, ReadInt32, ReadUInt32, ReadString en hun schrijftegenhangers, met WordOrder voor de vier registerindelingen.

Modbus TCP

Standaard poort 502, met optionele TLS, een HTTP- of SOCKS-proxy en automatisch opnieuw verbinden.

Modbus RTU

RS-232 en RS-485 met framing van 3,5 tekens, CRC-controles en broadcast-schrijfacties.

Modbus in C#, stap voor stap

Verwijs naar het pakket esegece.sgcIndustrial en kies daarna het transport. Elk voorbeeld op deze pagina compileert met .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();

De aanroepen zijn synchroon. Draai in een WinForms-, WPF- of ASP.NET-toepassing een pollinglus op een worker-thread of binnen Task.Run; de client is thread-safe, dus meerdere taken kunnen één verbinding delen.

Ondersteunde Modbus-functiecodes

De client controleert hoeveelheden tegen de specificatie voordat er iets wordt verzonden; de servers beantwoorden elke code in deze tabel.

FCFunctieC#-methode
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 (seriële lijn)ReadExceptionStatus op de RTU-client
08Diagnostics (seriële lijn)Diagnostics op de RTU-client
15Write Multiple CoilsWriteMultipleCoils
16Write Multiple RegistersWriteMultipleRegisters, WriteInt32, WriteUInt32, WriteFloat32, WriteString
22Mask Write RegisterMaskWriteRegister
23Read/Write Multiple RegistersReadWriteMultipleRegisters
43/14Read Device IdentificationReadDeviceIdentification met TsgcModbusDeviceIdCode basic, regular, extended of specific

Een Modbus-master gebouwd voor productie

Woordvolgorde

TsgcModbusWordOrder.mwoABCD is big endian, de Modbus-standaard. mwoCDAB zet het lage woord eerst, mwoBADC verwisselt de bytes in elk register en mwoDCBA is volledig little endian. Strings bevatten twee tekens per register.

Thread-safe

Per client loopt één transactie tegelijk, onder een lock die al zijn herpogingen omvat. Bij TCP wordt het antwoord door de ontvangstthread gekoppeld en doorgegeven aan de wachtende aanroep, zodat een aanroep vanuit een UI-thread geen deadlock kan veroorzaken.

Timeouts en nieuwe pogingen

Timeout is de wachttijd per poging, Retries het aantal extra pogingen. Een TCP-herpoging gebruikt een nieuwe transactie-id, en verouderde of dubbele antwoorden worden genegeerd.

Getypeerde exceptions

EsgcModbusException bevat ExceptionCode en FunctionCode, EsgcModbusTimeout meldt een ontbrekend antwoord en EsgcModbusError dekt gesloten verbindingen, poortproblemen en RTU-CRC-fouten.

Gateways en unit-id's

Elke methode heeft een overload met een voorafgaande byte aUnitId, zodat één TCP-verbinding met een gateway elk apparaat erachter bereikt.

TLS, proxy en opnieuw verbinden

TLS, TLSOptions, Proxy en WatchDog worden doorgegeven aan de sgcWebSockets TCP-client eronder, zodat Modbus TCP dezelfde TLS-stack, proxyondersteuning en automatische herverbinding krijgt als de rest van de bibliotheek.

RTU-framing

De RTU-client wacht voor het verzenden op de stilte van 3,5 tekens, leest het antwoord op basis van de verwachte lengte, controleert de CRC van elk frame en negeert frames van andere slave-adressen. Unit-id 0 verstuurt een broadcast-schrijfactie en wacht TurnaroundDelay in plaats van op een antwoord.

RS-485-richting

Met RtsControl = TsgcSerialRtsControl.srcToggle zet de seriële poort RTS hoog voor elke schrijfactie en laat het zakken zodra de uitvoerbuffer leeg is. In .NET gebeurt dit via software-timing, dus kies voor strikte bustiming liever een adapter met automatische richtingsbesturing.

Events

OnConnect, OnDisconnect en OnError worden via NotifyEvents geactiveerd, in de volgorde waarin ze plaatsvonden. Een mislukte verbindingspoging gooit geen exception: die activeert OnError en Active blijft false.

Modbus TCP- en RTU-servers in C#

Bouw een gateway die database- of cloudwaarden aanbiedt aan een SCADA-systeem, een simulator om HMI-schermen zonder hardware te testen, of de Modbus-interface van je eigen apparaat. Elke server heeft een eigen TsgcModbusDataModel met de vier tabellen (coils, discrete inputs, holding registers en input registers, standaard elk 10.000 items en maximaal 65.536), de identificatiestrings voor FC 43/14 en de exception-status voor FC 07. Elk lid van het datamodel is thread-safe.

OnReadRequest draait voordat een tabel wordt gelezen, zodat het waarden kan verversen of met een exception-code kan antwoorden. OnWriteRequest ontvangt de waarden voordat ze worden opgeslagen en kan ze wijzigen of de schrijfactie afwijzen, waarbij de tabellen ongemoeid blijven. Beide draaien in de serverthread die het verzoek afhandelt (de TCP-verbinding of de RTU-framelezer) zonder actieve lock.

TsgcModbusTCPServer

Veel gelijktijdige verbindingen, verzoeken die in volgorde van binnenkomst worden beantwoord, gesplitste verzoeken die worden samengevoegd en misvormde headers die de verbinding sluiten met OnError. UnitId = 0 beantwoordt elke unit-id. Bindings selecteren de endpoints, Port = 0 kiest een vrije poort, en OnClientConnect en OnClientDisconnect melden peers.

TsgcModbusRTUServer

Antwoordt als slave UnitId (1 tot 247) op een TsgcSerialPort, bepaalt de framing van verzoeken op lengte en de stilte van 3,5 tekens, negeert foute CRC's en andere adressen, en voert broadcast-schrijfacties uit zonder te antwoorden.

In beide richtingen getest

De .NET-client en -server doorstaan dezelfde interoperabiliteitstests tegen pymodbus via TCP en tegen de Delphi Modbus-componenten van sgcWebSockets, 35 van de 35 in elke richting.

Onderdeel van sgcWebSockets Enterprise

De Modbus- en seriële poort-componenten zijn inbegrepen in sgcWebSockets Enterprise (Delphi en .NET) en All-Access, als het pakket esegece.sgcIndustrial naast de andere sgcWebSockets .NET-pakketten. Vergelijk de edities op de prijzenpagina (tabblad .NET) of in de .NET-functiematrix.

C# Modbus-vragen

Maak een TsgcModbusTCPClient, stel Host, Port en UnitId in, zet Active = true en roep ReadHoldingRegisters(address, count) aan. Het geeft een ushort[] terug met één waarde per register. Adressen beginnen bij nul, zoals ze over de lijn gaan.

Roep ReadFloat32(address) aan voor holding registers of ReadInputFloat32(address) voor input registers. Als het getal er verkeerd uitziet, slaat het apparaat de twee registers in een andere volgorde op: stel WordOrder in op mwoCDAB, mwoBADC of mwoDCBA.

Ja. Open een TsgcSerialPort op de RS-485-adapter en wijs die toe aan TsgcModbusRTUClient.SerialPort of TsgcModbusRTUServer.SerialPort. Gebruik een adapter met automatische richtingsbesturing, of stel RtsControl in op srcToggle voor adapters die via RTS worden omgeschakeld.

Ja. Maak een TsgcModbusTCPServer, vul DataModel met SetHoldingRegister, SetCoil en de andere setters, en zet Active = true. Handel OnReadRequest en OnWriteRequest af om waarden op aanvraag te berekenen of schrijfacties af te wijzen met een Modbus-exception-code.

Nee, de clientmethoden zijn synchroon en thread-safe. Roep ze aan vanuit een worker-thread of verpak ze in Task.Run; meerdere threads of taken kunnen één client delen en elke aanroep wacht op zijn eigen antwoord.

Het pakket esegece.sgcIndustrial richt zich op .NET 8, .NET 9, .NET 10 en .NET Standard 2.0. De seriële poort gebruikt System.IO.Ports, dus Modbus RTU vereist een platform waarop dat pakket seriële poorten kan openen.

De Modbus- en seriële poort-componenten zijn inbegrepen in sgcWebSockets Enterprise (Delphi en .NET) en All-Access, of in het standalone pakket sgcIndustrial.

Meer over sgcWebSockets .NET

Industriële componenten

Seriële poort, Modbus en OPC UA, met de volledige componentreferentie.

C# OPC UA-client

Lees, schrijf en abonneer op OPC UA-servers vanuit dezelfde .NET-toepassing, naast de Modbus-apparaten.

C# MQTT-client

Publiceer Modbus-metingen vanuit dezelfde toepassing naar een MQTT-broker.

C# WebSocket-bibliotheek

WebSocket-client en -server voor dashboards die live apparaatdata tonen.

Ook voor Delphi en C++Builder

Dezelfde Modbus-componenten, met dezelfde klassenamen en methoden, voor Delphi 7 tot Delphi 13.

De beste deal: All-AccessElk eSeGeCe-product, inclusief Premium-ondersteuning, vanaf €1,059 per jaar.
Bekijk de All-Access-prijzen

Lees je eerste Modbus-register vanuit C#

Inbegrepen in sgcWebSockets Enterprise (Delphi en .NET) en All-Access, of in het standalone pakket sgcIndustrial.