C# y .NET Novedad

Biblioteca Modbus en C# TCP y RTU para .NET

Lee y escribe PLC, variadores y contadores desde C#, o sirve tus propios datos como esclavo Modbus, por Ethernet o RS-485.

Modbus TCP y Modbus RTU
Cliente y servidor
Float32, Int32 y cadenas en cualquier orden de palabras
Llamadas bloqueantes seguras para hilos

Incluido en sgcWebSockets Enterprise (Delphi y .NET) y All-Access, o en el pack independiente sgcIndustrial.

Lee y escribe un dispositivo en C# → · Preguntas frecuentes de Modbus →

Cliente Modbus TCP en 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

Clientes y servidores Modbus para .NET

Cuatro componentes, una sola API para TCP y RTU, y un modelo de datos seguro entre hilos detrás de los servidores.

La biblioteca Modbus en C# de sgcWebSockets .NET se encuentra en el paquete esegece.sgcIndustrial, espacio de nombres esegece.sgcWebSockets. TsgcModbusTCPClient y TsgcModbusRTUClient son maestros Modbus que sondean dispositivos; TsgcModbusTCPServer y TsgcModbusRTUServer son esclavos Modbus que responden a sistemas SCADA, HMI y otros maestros desde un TsgcModbusDataModel. La línea serie es un TsgcSerialPort del mismo paquete, construido sobre System.IO.Ports.

Ambos clientes comparten TsgcModbusClient_Base, de modo que un método que lee un registro por Ethernet lo lee también por RS-485. Cada llamada se bloquea hasta que llega la respuesta o vence Timeout, devuelve arrays .NET normales (ushort[] para registros, bool[] para bobinas) y lanza una excepción tipada cuando el dispositivo informa de un error. El paquete admite .NET 8, .NET 9, .NET 10 y .NET Standard 2.0.

Códigos de función

01 a 08, 15, 16, 22, 23 y 43/14, un método para cada uno.

Valores tipados

ReadFloat32, ReadInt32, ReadUInt32, ReadString y sus equivalentes de escritura, con WordOrder para las cuatro disposiciones de registros.

Modbus TCP

Puerto 502 por defecto, con TLS opcional, un proxy HTTP o SOCKS y reconexión automática.

Modbus RTU

RS-232 y RS-485 con tramas de 3.5 caracteres, comprobaciones CRC y escrituras de difusión.

Modbus en C#, paso a paso

Referencia el paquete esegece.sgcIndustrial y elige el transporte. Todos los ejemplos de esta página compilan con .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();

Las llamadas son síncronas. En una aplicación WinForms, WPF o ASP.NET, ejecuta un bucle de sondeo en un hilo de trabajo o dentro de Task.Run; el cliente es seguro entre hilos, así que varias tareas pueden compartir una conexión.

Códigos de función Modbus admitidos

El cliente comprueba las cantidades con la especificación antes de enviar nada; los servidores responden a todos los códigos de esta tabla.

FCFunciónMétodo de 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 (línea serie)ReadExceptionStatus en el cliente RTU
08Diagnostics (línea serie)Diagnostics en el cliente RTU
15Write Multiple CoilsWriteMultipleCoils
16Write Multiple RegistersWriteMultipleRegisters, WriteInt32, WriteUInt32, WriteFloat32, WriteString
22Mask Write RegisterMaskWriteRegister
23Read/Write Multiple RegistersReadWriteMultipleRegisters
43/14Read Device IdentificationReadDeviceIdentification con TsgcModbusDeviceIdCode básico, regular, extendido o específico

Un maestro Modbus preparado para producción

Orden de palabras

TsgcModbusWordOrder.mwoABCD es big endian, el valor por defecto de Modbus. mwoCDAB pone primero la palabra baja, mwoBADC intercambia los bytes de cada registro y mwoDCBA es totalmente little endian. Las cadenas empaquetan dos caracteres por registro.

Seguro entre hilos

Cada cliente ejecuta una transacción a la vez, bajo un bloqueo que cubre todos sus reintentos. En TCP, el hilo de recepción empareja la respuesta y se la entrega a la llamada en espera, de modo que una llamada desde el hilo de la interfaz no puede provocar un interbloqueo.

Tiempos de espera y reintentos

Timeout es la espera por intento y Retries los intentos adicionales. Un reintento TCP usa un nuevo id de transacción, y las respuestas obsoletas o duplicadas se descartan.

Excepciones tipadas

EsgcModbusException contiene ExceptionCode y FunctionCode, EsgcModbusTimeout informa de una respuesta que no llega y EsgcModbusError cubre las conexiones cerradas, los problemas de puerto y los errores CRC de RTU.

Pasarelas e identificadores de unidad

Cada método tiene una sobrecarga con un byte aUnitId inicial, de modo que una sola conexión TCP a una pasarela llega a todos los dispositivos que hay detrás.

TLS, proxy y reconexión

TLS, TLSOptions, Proxy y WatchDog se pasan al cliente TCP de sgcWebSockets que hay debajo, de modo que Modbus TCP obtiene la misma pila TLS, la misma compatibilidad con proxy y la misma reconexión automática que el resto de la biblioteca.

Tramas RTU

El cliente RTU espera el silencio de 3.5 caracteres antes de enviar, lee la respuesta según su longitud esperada, comprueba el CRC de cada trama e ignora las tramas de otras direcciones de esclavo. El id de unidad 0 envía una escritura de difusión y espera TurnaroundDelay en lugar de una respuesta.

Dirección RS-485

Con RtsControl = TsgcSerialRtsControl.srcToggle, el puerto serie activa RTS en cada escritura y lo desactiva cuando el búfer de salida se ha vaciado. En .NET esto se temporiza por software, así que, si necesitas una temporización estricta del bus, prefiere un adaptador con control automático de dirección.

Eventos

OnConnect, OnDisconnect y OnError se disparan a través de NotifyEvents, en el orden en que ocurrieron. Una conexión fallida no lanza ninguna excepción: dispara OnError y Active sigue en false.

Servidores Modbus TCP y RTU en C#

Construye una pasarela que exponga valores de una base de datos o de la nube a un sistema SCADA, un simulador para probar pantallas HMI sin hardware, o la interfaz Modbus de tu propio dispositivo. Cada servidor tiene su propio TsgcModbusDataModel con las cuatro tablas (bobinas, entradas discretas, registros de retención y registros de entrada, 10,000 entradas cada una por defecto y hasta 65,536), las cadenas de identificación para FC 43/14 y el estado de excepción para FC 07. Todos los miembros del modelo de datos son seguros entre hilos.

OnReadRequest se ejecuta antes de leer una tabla, de modo que puede actualizar valores o responder con un código de excepción. OnWriteRequest recibe los valores antes de almacenarlos y puede cambiarlos o rechazar la escritura, dejando las tablas intactas. Ambos se ejecutan en el hilo del servidor que atiende la petición (la conexión TCP o el lector de tramas RTU) sin ningún bloqueo retenido.

TsgcModbusTCPServer

Muchas conexiones simultáneas, peticiones respondidas en orden de llegada, peticiones fragmentadas reensambladas y cabeceras mal formadas que cierran la conexión con OnError. UnitId = 0 responde a cualquier id de unidad. Bindings selecciona los puntos finales, Port = 0 elige un puerto libre y OnClientConnect y OnClientDisconnect informan de los pares.

TsgcModbusRTUServer

Responde como esclavo UnitId (1 a 247) en un TsgcSerialPort, delimita las peticiones por longitud y por el silencio de 3.5 caracteres, ignora los CRC incorrectos y otras direcciones, y ejecuta las escrituras de difusión sin responder.

Probado en ambos sentidos

El cliente y el servidor .NET superan las mismas comprobaciones de interoperabilidad frente a pymodbus por TCP y frente a los componentes Modbus de sgcWebSockets para Delphi, 35 de 35 en cada sentido.

Parte de sgcWebSockets Enterprise

Los componentes Modbus y de puerto serie están incluidos en sgcWebSockets Enterprise (Delphi y .NET) y All-Access, como el paquete esegece.sgcIndustrial junto a los demás paquetes de sgcWebSockets .NET. Compara las ediciones en la página de precios (pestaña .NET) o en la matriz de funciones de .NET.

Preguntas sobre Modbus en C#

Crea un TsgcModbusTCPClient, establece Host, Port y UnitId, asigna Active = true y llama a ReadHoldingRegisters(address, count). Devuelve un ushort[] con un valor por registro. Las direcciones empiezan en cero, tal como viajan por el cable.

Llama a ReadFloat32(address) para registros de retención o a ReadInputFloat32(address) para registros de entrada. Si el número parece incorrecto, el dispositivo guarda los dos registros en otro orden: establece WordOrder a mwoCDAB, mwoBADC o mwoDCBA.

Sí. Abre un TsgcSerialPort en el adaptador RS-485 y asígnalo a TsgcModbusRTUClient.SerialPort o a TsgcModbusRTUServer.SerialPort. Usa un adaptador con control automático de dirección, o establece RtsControl a srcToggle para adaptadores conmutados por RTS.

Sí. Crea un TsgcModbusTCPServer, rellena DataModel con SetHoldingRegister, SetCoil y los demás métodos de asignación, y asigna Active = true. Gestiona OnReadRequest y OnWriteRequest para calcular valores bajo demanda o rechazar escrituras con un código de excepción Modbus.

No, los métodos del cliente son síncronos y seguros entre hilos. Llámalos desde un hilo de trabajo o envuélvelos en Task.Run; varios hilos o tareas pueden compartir un cliente, y cada llamada espera su propia respuesta.

El paquete esegece.sgcIndustrial admite .NET 8, .NET 9, .NET 10 y .NET Standard 2.0. El puerto serie usa System.IO.Ports, así que Modbus RTU necesita una plataforma donde ese paquete pueda abrir puertos serie.

Los componentes Modbus y de puerto serie están incluidos en sgcWebSockets Enterprise (Delphi y .NET) y All-Access, o en el pack independiente sgcIndustrial.

Más sobre sgcWebSockets .NET

Componentes industriales

Puerto serie, Modbus y OPC UA, con la referencia completa de componentes.

Cliente OPC UA en C#

Lee, escribe y suscríbete a servidores OPC UA desde la misma aplicación .NET, junto a los dispositivos Modbus.

Cliente MQTT para C#

Publica lecturas Modbus en un broker MQTT desde la misma aplicación.

Biblioteca WebSocket para C#

Cliente y servidor WebSocket para paneles que muestran datos de dispositivos en directo.

También para Delphi y C++Builder

Los mismos componentes Modbus, con los mismos nombres de clase y métodos, para Delphi 7 a Delphi 13.

La mejor opción: All-AccessTodos los productos de eSeGeCe, con Premium Support incluido, desde €1,059 al año.
Ver precios de All-Access

Lee tu primer registro Modbus desde C#

Incluido en sgcWebSockets Enterprise (Delphi y .NET) y All-Access, o en el pack independiente sgcIndustrial.