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.
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.
ReadDeviceIdentification (básico, regular, extendido y objeto único)
QuickStart
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 03for i := 0to Length(vRegisters) - 1do
Memo1.Lines.Add(Format('HR%d = %d', [i, vRegisters[i]]));
vCoils := Modbus.ReadCoils(0, 8); // FC 01if vCoils[0] then
Memo1.Lines.Add('coil 0 is on');
Modbus.WriteSingleRegister(100, 1234); // FC 06
Modbus.WriteSingleCoil(5, True); // FC 05end;
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 04try
Modbus.ReadHoldingRegisters(9000, 4);
excepton 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 replyend;
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 readprocedure TForm1.ServerReadRequest(Sender: TObject; aUnitId, aFunctionCode: Byte;
aAddress, aCount: Word; var aExceptionCode: Byte);
beginif aFunctionCode = CS_MODBUS_FC_READ_INPUT_REGISTERS then
Server.DataModel.SetInputRegister(0, Random(1000)); // fresh valueend;
// registers 0..9 are read onlyprocedure TForm1.ServerWriteRequest(Sender: TObject; aUnitId, aFunctionCode: Byte;
aAddress, aCount: Word; var aBits: TsgcModbusBits;
var aRegisters: TsgcModbusRegisters; var aExceptionCode: Byte);
beginif (Length(aRegisters) > 0) and (aAddress < 10) then
aExceptionCode := CS_MODBUS_EX_ILLEGAL_DATA_ADDRESS;
end;
Cliente
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.
Servidor
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.
Interoperabilidad
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.
FAQ
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.