Novedad

Modbus para Delphi TCP y RTU: componentes cliente y servidor

Componentes nativos Modbus TCP y Modbus RTU para Delphi y C++Builder. Consulta PLC, variadores, contadores de energía y pasarelas, o publica tus propios datos como servidor Modbus, con métodos tipados Float32, Int32 y de cadena en cualquier orden de palabra.

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

Dos clientes, dos servidores, una API Modbus

Maestros y esclavos Modbus TCP y Modbus RTU como componentes no visuales, escritos en Pascal y compilados dentro de tu aplicación.

Una biblioteca de Modbus para Delphi permite que una aplicación VCL, FMX, de servicio o de consola hable con los dispositivos que hay en cualquier planta: PLC, variadores de frecuencia, contadores de energía, controladores de temperatura y pasarelas de protocolos. sgcWebSockets lo incluye como cuatro componentes: TsgcModbusTCPClient y TsgcModbusRTUClient consultan dispositivos, mientras que TsgcModbusTCPServer y TsgcModbusRTUServer exponen tus propios datos a sistemas SCADA, HMI y cualquier otro maestro Modbus.

Los dos clientes descienden de TsgcModbusClient_Base, así que el código que lee un registro por Ethernet lo lee también por RS-485: cambias el componente, no las llamadas. Cada llamada se bloquea hasta que llega la respuesta o vence Timeout, devuelve los valores como arrays de Delphi y lanza una excepción tipada cuando el dispositivo informa de un error. Una sola línea uses sgcIndustrial; incorpora todas las clases.

Clases de componente

TsgcModbusTCPClient, TsgcModbusRTUClient, TsgcModbusTCPServer, TsgcModbusRTUServer, TsgcModbusDataModel

Transportes

Modbus TCP en el puerto 502 con TLS y proxy opcionales; Modbus RTU sobre RS-232 y RS-485 mediante TsgcSerialPort

Códigos de función

01 a 08, 15, 16, 22, 23 y 43/14 (read device identification)

Plataformas

Delphi 7 a Delphi 13 y C++Builder; Windows, Linux y macOS

Todas las funciones Modbus habituales, un método para cada una

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 del cliente
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 (básico, regular, extendido y objeto único)

Lee un PLC en pocas líneas de Delphi

Crea el componente, indica la dirección y llama a un método. Todos los ejemplos de esta página compilan con Delphi 7 y Delphi 13.

uses
  sgcIndustrial;

procedure TForm1.FormCreate(Sender: TObject);
begin
  Modbus := TsgcModbusTCPClient.Create(Self);
  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.OnConnect := ModbusConnect;
  Modbus.OnError := ModbusError;
  Modbus.Active := True;
end;

procedure TForm1.ModbusConnect(Sender: TObject);
begin
  Memo1.Lines.Add('connected');
end;

procedure TForm1.ModbusError(Sender: TObject; const aError: string);
begin
  Memo1.Lines.Add('error: ' + aError);
end;

procedure TForm1.btnReadClick(Sender: TObject);
var
  vRegisters: TsgcModbusRegisters;
  vCoils: TsgcModbusBits;
  i: Integer;
begin
  vRegisters := Modbus.ReadHoldingRegisters(0, 10); // FC 03
  for i := 0 to Length(vRegisters) - 1 do
    Memo1.Lines.Add(Format('HR%d = %d', [i, vRegisters[i]]));

  vCoils := Modbus.ReadCoils(0, 8);                 // FC 01
  if vCoils[0] then
    Memo1.Lines.Add('coil 0 is on');

  Modbus.WriteSingleRegister(100, 1234);            // FC 06
  Modbus.WriteSingleCoil(5, True);                  // FC 05
end;
procedure TForm1.btnTypedClick(Sender: TObject);
var
  vTemperature: Single;
  vCounter: Integer;
  vName: TsgcModbusAnsiString;
begin
  Modbus.WordOrder := mwoCDAB;              // low word first
  vTemperature := Modbus.ReadFloat32(200);  // 2 holding registers
  vCounter := Modbus.ReadInt32(202);
  vName := Modbus.ReadString(300, 8);       // 8 registers, 16 characters
  Memo1.Lines.Add(Format('%s: %.1f C, %d cycles',
    [string(vName), vTemperature, vCounter]));

  Modbus.WriteFloat32(210, 21.5);
  Modbus.WriteUInt32(212, 3000000000);

  // explicit unit id, for a gateway with several devices behind it
  Memo1.Lines.Add(FloatToStr(Modbus.ReadInputFloat32(7, 0))); // unit 7, FC 04

  try
    Modbus.ReadHoldingRegisters(9000, 4);
  except
    on E: EsgcModbusException do // the device answered with an exception
      Memo1.Lines.Add(Format('exception %d, function %d',
        [E.ExceptionCode, E.FunctionCode]));
    on E: EsgcModbusTimeout do   // no answer after Retries + 1 attempts
      Memo1.Lines.Add(E.Message);
  end;
end;
procedure TForm1.FormCreate(Sender: TObject);
begin
  Serial := TsgcSerialPort.Create(Self);
  Serial.Port := 'COM3';          // '/dev/ttyUSB0' on Linux
  Serial.BaudRate := 19200;
  Serial.Parity := spEven;        // 8E1, the Modbus RTU default
  Serial.RtsControl := srcToggle; // RS-485: RTS switches the transmitter
  Serial.Active := True;

  RTU := TsgcModbusRTUClient.Create(Self);
  RTU.SerialPort := Serial;
  RTU.UnitId := 17;               // slave address
  RTU.Timeout := 500;
  RTU.Retries := 1;
end;

procedure TForm1.btnPollClick(Sender: TObject);
var
  vValues: TsgcModbusRegisters;
begin
  vValues := RTU.ReadInputRegisters(0, 4);                      // FC 04
  Memo1.Lines.Add(Format('IR0 = %d', [vValues[0]]));
  Memo1.Lines.Add(Format('status = %d', [RTU.ReadExceptionStatus])); // FC 07
  RTU.WriteSingleRegister(0, 10, 500); // unit 0: broadcast to every slave, no reply
end;
procedure TForm1.FormCreate(Sender: TObject);
begin
  Server := TsgcModbusTCPServer.Create(Self);
  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';
  Server.OnReadRequest := ServerReadRequest;
  Server.OnWriteRequest := ServerWriteRequest;
  Server.Active := True;
end;

// runs in the connection thread, before the table is read
procedure TForm1.ServerReadRequest(Sender: TObject; aUnitId, aFunctionCode: Byte;
  aAddress, aCount: Word; var aExceptionCode: Byte);
begin
  if aFunctionCode = CS_MODBUS_FC_READ_INPUT_REGISTERS then
    Server.DataModel.SetInputRegister(0, Random(1000)); // fresh value
end;

// registers 0..9 are read only
procedure TForm1.ServerWriteRequest(Sender: TObject; aUnitId, aFunctionCode: Byte;
  aAddress, aCount: Word; var aBits: TsgcModbusBits;
  var aRegisters: TsgcModbusRegisters; var aExceptionCode: Byte);
begin
  if (Length(aRegisters) > 0) and (aAddress < 10) then
    aExceptionCode := CS_MODBUS_EX_ILLEGAL_DATA_ADDRESS;
end;

Un maestro Modbus al que puedes llamar desde cualquier hilo

Llamadas bloqueantes, valores tipados y errores claros, por TCP y por la línea serie.

Valores de 32 bits y cadenas tipados

ReadFloat32, ReadInt32, ReadUInt32 y sus equivalentes de escritura y de registros de entrada combinan dos registros en un solo valor. WordOrder cubre las cuatro disposiciones que usan los dispositivos: mwoABCD (big endian, el valor por defecto de Modbus), mwoCDAB, mwoBADC y mwoDCBA. ReadString y WriteString empaquetan dos caracteres por registro.

Llamadas bloqueantes seguras para hilos

Cada cliente ejecuta una petición a la vez, protegida por un bloqueo que cubre todos sus reintentos, de modo que varios hilos pueden compartir una conexión. En TCP la respuesta la asocia el hilo de recepción, así que una llamada desde el hilo principal no puede provocar un bloqueo mutuo.

Tiempos de espera y reintentos

Timeout es la espera por intento y Retries los intentos adicionales. Un reintento TCP usa un nuevo identificador de transacción, y las respuestas tardías o duplicadas se descartan en lugar de confundirse con la siguiente respuesta.

Excepciones tipadas

EsgcModbusException lleva el ExceptionCode y el FunctionCode del dispositivo, EsgcModbusTimeout informa de una respuesta que falta, y EsgcModbusError cubre todo lo demás, desde una conexión cerrada hasta una trama RTU con un CRC erróneo.

Identificador de unidad por llamada

Cada método tiene también una sobrecarga con un identificador de unidad al principio, de modo que una conexión a una pasarela llega a todos los dispositivos que hay detrás. UnitId es el valor por defecto de las llamadas que no lo llevan.

TLS, proxy y reconexión en TCP

TLS y TLSOptions envuelven el flujo Modbus TCP en TLS, Proxy llega a un dispositivo a través de un proxy HTTP o SOCKS, y WatchDog reconecta tras una caída de red. Los tres proceden del cliente TCP de sgcWebSockets sobre el que se construye el componente.

Entramado RTU bien hecho

El cliente RTU espera el silencio de 3,5 caracteres antes de enviar, lee la respuesta por su longitud esperada (los adaptadores USB entregan los bytes en ráfagas), comprueba el CRC de cada trama e ignora las tramas de otras direcciones de esclavo.

RS-485 y difusión

Indica RtsControl := srcToggle en el puerto serie y RTS conmuta el transmisor RS-485 en cada escritura, mediante el controlador en Windows y el modo RS-485 del núcleo en Linux. El identificador de unidad 0 envía una escritura de difusión a todos los esclavos y espera TurnaroundDelay en lugar de una respuesta.

Eventos donde los quieres

OnConnect, OnDisconnect y OnError se entregan mediante NotifyEvents: encolados en el hilo principal por defecto, sincronizados, o lanzados directamente en el hilo de recepción.

Servidores Modbus TCP y RTU con un modelo de datos en vivo

Convierte una aplicación Delphi en un esclavo Modbus: una pasarela que expone valores de una base de datos o de una API REST, un simulador de dispositivos para probar pantallas HMI, o la cara Modbus de tu propio controlador. Cada servidor tiene un TsgcModbusDataModel con las cuatro tablas Modbus (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 del dispositivo que se responden en FC 43/14 y el estado de excepción que se responde en FC 07.

El modelo de datos es seguro para hilos: un solo bloqueo protege todas las tablas, así que tu código puede actualizar valores mientras los clientes los leen. Dos ganchos ponen tu código en el camino de la petición. OnReadRequest se ejecuta antes de leer una tabla, de modo que puede refrescar los valores justo a tiempo o rechazar la petición con un código de excepción. OnWriteRequest recibe los valores antes de guardarlos, de modo que puede validarlos, cambiarlos o rechazar la escritura y dejar las tablas intactas.

TsgcModbusTCPServer

Muchas conexiones simultáneas, cada una con su propio hilo. Las peticiones que llegan juntas en un paquete se responden en orden, una petición repartida en varios paquetes se reensambla, y una cabecera mal formada cierra esa conexión y dispara OnError. UnitId = 0 responde a cualquier identificador de unidad; otro valor responde solo a ese. Bindings elige las interfaces y los puertos, y OnClientConnect y OnClientDisconnect informan de los clientes.

TsgcModbusRTUServer

Escucha en un TsgcSerialPort como esclavo UnitId (1 a 247). Enmarca las peticiones por su longitud esperada y el silencio de 3,5 caracteres, ignora las tramas con un CRC erróneo o con otra dirección, y ejecuta las escrituras de difusión desde el identificador de unidad 0 sin responder, como exige la especificación de la línea serie.

Ganchos en el hilo de la conexión

Los eventos del servidor se ejecutan en el hilo de la conexión (TCP) o en el hilo de tramas (RTU) y devuelven su resultado de forma síncrona. Mantenlos cortos y llama con libertad a los métodos del modelo de datos: los ganchos se ejecutan sin ningún bloqueo retenido.

Probado contra una pila Modbus independiente

El cliente y el servidor Modbus se prueban en la red contra pymodbus, una implementación de código abierto independiente, sobre Modbus TCP: códigos de función 01 a 06, 15, 16, 22, 23 y 43/14, respuestas de excepción, valores Float32 e identificación del dispositivo. Los métodos tipados se comprueban con vectores de bytes conocidos en los cuatro órdenes de palabra. Los componentes Delphi se prueban también contra los componentes Modbus de sgcWebSockets .NET en ambos sentidos, cliente contra servidor, con 35 de 35 comprobaciones superadas en cada sentido.

El puerto serie se prueba en un puerto COM real en Windows y en pseudoterminales en Linux, incluido el cierre del puerto mientras hay una lectura en espera. El cliente y el servidor Modbus RTU se prueban contra esclavos y maestros simulados: tramas partidas, errores de CRC, otras direcciones de esclavo y difusiones. El mismo código compila para macOS.

Preguntas sobre Modbus para Delphi

Crea un TsgcModbusTCPClient, indica Host, Port (502 por defecto) y UnitId, pon Active := True y llama a ReadHoldingRegisters(Address, Count). Devuelve un array TsgcModbusRegisters con un Word por registro. Las direcciones empiezan en cero, tal como viajan por la red.

Llama a ReadFloat32, ReadInt32 o ReadUInt32 con la dirección del primero de los dos registros, o a las variantes ReadInput... para registros de entrada. Si el valor parece incorrecto, el dispositivo usa otro orden de palabra: indica en WordOrder el valor mwoCDAB, mwoBADC o mwoDCBA en lugar del mwoABCD por defecto.

Sí. Abre un TsgcSerialPort en el adaptador y asígnalo a la propiedad SerialPort de TsgcModbusRTUClient o TsgcModbusRTUServer. Los adaptadores con control automático de dirección no necesitan nada más. Para los adaptadores que conmutan el transmisor con RTS, indica RtsControl := srcToggle: Windows usa el modo de conmutación RTS del controlador y Linux el modo RS-485 del núcleo.

Sí. El cliente ejecuta una transacción a la vez y mantiene un bloqueo durante toda la petición, reintentos incluidos, de modo que las llamadas de varios hilos hacen cola y cada una recibe su propia respuesta. Las llamadas desde el hilo principal no provocan bloqueos mutuos: en TCP la respuesta la recibe un hilo aparte.

Coloca un TsgcModbusTCPServer (o un TsgcModbusRTUServer con un puerto serie), rellena su DataModel con SetHoldingRegister, SetCoil y los demás métodos Set, y pon Active := True. Usa OnReadRequest y OnWriteRequest para calcular valores bajo demanda o rechazar escrituras con un código de excepción Modbus.

Delphi 7 a Delphi 13 y C++Builder, en Windows (32 y 64 bits), Linux de 64 bits y macOS. El puerto serie, y con él Modbus RTU, no está disponible en Android ni en iOS.

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 componentes industriales en sgcWebSockets

Componentes industriales

Puerto serie, Modbus y el cliente OPC UA en una sola sección, con la referencia completa de los componentes.

Referencia del cliente Modbus

Propiedades, métodos y eventos de TsgcModbusTCPClient y TsgcModbusRTUClient.

Referencia del servidor Modbus

TsgcModbusTCPServer, TsgcModbusRTUServer y los ganchos de TsgcModbusDataModel.

Puerto serie para Delphi

TsgcSerialPort para Windows, Linux y macOS: el transporte de Modbus RTU, y un componente serie por derecho propio.

Cliente MQTT para Delphi

Publica valores Modbus en un broker MQTT: la forma habitual de llevar los datos de la fábrica a la nube.

También para C# y .NET

Los mismos clientes y servidores Modbus, con los mismos nombres de clase, para .NET 8, 9, 10 y .NET Standard 2.0.

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

Habla con tu primer PLC desde Delphi

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