Delphi Modbus TCP e RTU: componenti client e server
Componenti nativi Modbus TCP e Modbus RTU per Delphi e C++Builder. Interroga PLC, azionamenti, contatori di energia e gateway, oppure pubblica i tuoi dati come server Modbus, con helper tipizzati Float32, Int32 e stringa in qualsiasi ordine di word.
Incluso in sgcWebSockets Enterprise (Delphi e .NET) e All-Access, oppure nel pacchetto standalone sgcIndustrial.
Master e slave Modbus TCP e Modbus RTU come componenti non visuali, scritti in Pascal e compilati nella tua applicazione.
Una libreria Delphi Modbus permette a un'applicazione VCL, FMX, servizio o console di dialogare con i dispositivi presenti in ogni fabbrica: PLC, inverter, contatori di energia, regolatori di temperatura e gateway di protocollo. sgcWebSockets la fornisce come quattro componenti: TsgcModbusTCPClient e TsgcModbusRTUClient interrogano i dispositivi, mentre TsgcModbusTCPServer e TsgcModbusRTUServer espongono i tuoi dati a sistemi SCADA, HMI e a qualsiasi altro master Modbus.
Entrambi i client discendono da TsgcModbusClient_Base, quindi il codice che legge un registro via Ethernet lo legge anche via RS-485: cambi il componente, non le chiamate. Ogni chiamata si blocca finché arriva la risposta o scade Timeout, restituisce i valori come array Delphi e solleva un'eccezione tipizzata quando il dispositivo segnala un errore. Una riga uses sgcIndustrial; importa tutte le classi.
ReadDeviceIdentification (basic, regular, extended e oggetto singolo)
QuickStart
Leggi un PLC in poche righe di Delphi
Crea il componente, imposta l'indirizzo, chiama un metodo. Ogni esempio di questa pagina compila con Delphi 7 e 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;
Client
Un master Modbus che puoi chiamare da qualsiasi thread
Chiamate bloccanti, valori tipizzati ed errori chiari, su TCP e sulla linea seriale.
Valori a 32 bit e stringhe tipizzati
ReadFloat32, ReadInt32, ReadUInt32 e i corrispondenti di scrittura e di input register combinano due registri in un solo valore. WordOrder copre i quattro layout usati dai dispositivi: mwoABCD (big endian, il valore predefinito di Modbus), mwoCDAB, mwoBADC e mwoDCBA. ReadString e WriteString impacchettano due caratteri per registro.
Chiamate bloccanti thread-safe
Per ogni client viene eseguita una richiesta alla volta, protetta da un lock che copre tutti i suoi tentativi, quindi più thread possono condividere una connessione. Su TCP la risposta è abbinata dal thread di ricezione, quindi una chiamata dal thread principale non può causare un deadlock.
Timeout e tentativi
Timeout è l'attesa per tentativo e Retries i tentativi aggiuntivi. Un nuovo tentativo TCP usa un nuovo id di transazione, e le risposte in ritardo o duplicate vengono scartate invece di essere scambiate per la risposta successiva.
Eccezioni tipizzate
EsgcModbusException porta con sé ExceptionCode e FunctionCode del dispositivo, EsgcModbusTimeout segnala una risposta mancante, e EsgcModbusError copre tutto il resto, da una connessione chiusa a un frame RTU con CRC errato.
Unit id per chiamata
Ogni metodo ha anche un overload con un unit id iniziale, così una sola connessione a un gateway raggiunge tutti i dispositivi che ci sono dietro. UnitId è il valore predefinito per le chiamate che non lo specificano.
TLS, proxy e riconnessione su TCP
TLS e TLSOptions avvolgono il flusso Modbus TCP in TLS, Proxy raggiunge un dispositivo tramite un proxy HTTP o SOCKS, e WatchDog si riconnette dopo una caduta di rete. Tutti e tre derivano dal client TCP di sgcWebSockets su cui è costruito il componente.
Framing RTU fatto bene
Il client RTU attende il silenzio di 3,5 caratteri prima di inviare, legge la risposta in base alla lunghezza attesa (gli adattatori USB consegnano i byte a raffiche), controlla il CRC di ogni frame e ignora i frame di altri indirizzi slave.
RS-485 e broadcast
Imposta RtsControl := srcToggle sulla porta seriale e RTS commuta il trasmettitore RS-485 a ogni scrittura, tramite il driver su Windows e la modalità RS-485 del kernel su Linux. L'unit id 0 invia una scrittura broadcast a ogni slave e attende TurnaroundDelay invece di una risposta.
Eventi dove vuoi tu
OnConnect, OnDisconnect e OnError vengono consegnati tramite NotifyEvents: accodati al thread principale per impostazione predefinita, sincronizzati, oppure sollevati direttamente nel thread di ricezione.
Server
Server Modbus TCP e RTU con un modello dati in tempo reale
Trasforma un'applicazione Delphi in uno slave Modbus: un gateway che espone valori da un database o da un'API REST, un simulatore di dispositivo per testare le schermate HMI, o la faccia Modbus del tuo controllore. Ogni server possiede un TsgcModbusDataModel con le quattro tabelle Modbus (coil, discrete input, holding register e input register, 10.000 voci ciascuna per impostazione predefinita e fino a 65.536), le stringhe di identificazione del dispositivo restituite alla FC 43/14 e l'exception status restituito alla FC 07.
Il modello dati è thread-safe: un lock protegge tutte le tabelle, così il tuo codice può aggiornare i valori mentre i client li leggono. Due hook portano il tuo codice nel percorso della richiesta. OnReadRequest viene eseguito prima della lettura di una tabella, così può aggiornare i valori al momento giusto o rifiutare la richiesta con un codice di eccezione. OnWriteRequest riceve i valori prima che vengano memorizzati, così può validarli, modificarli o rifiutare la scrittura lasciando le tabelle intatte.
TsgcModbusTCPServer
Molte connessioni simultanee, ciascuna con il proprio thread. Le richieste che arrivano insieme in un pacchetto ricevono risposta in ordine, una richiesta divisa su più pacchetti viene riassemblata, e un header malformato chiude quella connessione e fa scattare OnError. UnitId = 0 risponde a qualsiasi unit id; un altro valore risponde solo a quello. Bindings sceglie interfacce e porte, e OnClientConnect e OnClientDisconnect segnalano i peer.
TsgcModbusRTUServer
Resta in ascolto su un TsgcSerialPort come slave UnitId (da 1 a 247). Delimita le richieste in base alla lunghezza attesa e al silenzio di 3,5 caratteri, ignora i frame con CRC errato o con un altro indirizzo, ed esegue le scritture broadcast dall'unit id 0 senza rispondere, come richiede la specifica della linea seriale.
Hook nel thread della connessione
Gli eventi del server vengono eseguiti nel thread della connessione (TCP) o nel thread dei frame (RTU) e restituiscono il risultato in modo sincrono. Mantienili brevi e chiama liberamente i metodi del modello dati: gli hook vengono eseguiti senza alcun lock acquisito.
Interoperabilità
Testato con uno stack Modbus indipendente
Il client e il server Modbus sono testati sul cavo con pymodbus, un'implementazione open source indipendente, su Modbus TCP: codici funzione da 01 a 06, 15, 16, 22, 23 e 43/14, risposte di eccezione, valori Float32 e identificazione del dispositivo. Gli helper tipizzati sono verificati con vettori di byte noti in tutti e quattro gli ordini di word. I componenti Delphi sono testati anche con i componenti Modbus .NET di sgcWebSockets in entrambe le direzioni, client contro server, con 35 controlli su 35 superati in ciascuna direzione.
La porta seriale è testata su una vera porta COM su Windows e su pseudo terminali su Linux, inclusa la chiusura della porta mentre una lettura è in attesa. Il client e il server Modbus RTU sono testati con slave e master simulati: frame divisi, errori CRC, altri indirizzi slave e broadcast. Lo stesso codice compila per macOS.
FAQ
Domande su Delphi Modbus
Crea un TsgcModbusTCPClient, imposta Host, Port (502 per impostazione predefinita) e UnitId, imposta Active := True e chiama ReadHoldingRegisters(Address, Count). Restituisce un array TsgcModbusRegisters con un Word per registro. Gli indirizzi partono da zero, come viaggiano sul cavo.
Chiama ReadFloat32, ReadInt32 o ReadUInt32 con l'indirizzo del primo dei due registri, oppure le varianti ReadInput... per gli input register. Se il valore sembra errato, il dispositivo usa un altro ordine di word: imposta WordOrder su mwoCDAB, mwoBADC o mwoDCBA invece del predefinito mwoABCD.
Sì. Apri un TsgcSerialPort sull'adattatore e assegnalo alla proprietà SerialPort di TsgcModbusRTUClient o TsgcModbusRTUServer. Gli adattatori con controllo automatico della direzione non richiedono altro. Per gli adattatori che commutano il trasmettitore con RTS, imposta RtsControl := srcToggle: Windows usa la modalità di commutazione RTS del driver e Linux la modalità RS-485 del kernel.
Sì. Il client esegue una transazione alla volta e mantiene un lock per l'intera richiesta, tentativi inclusi, quindi le chiamate di più thread si mettono in coda e ciascuna riceve la propria risposta. Le chiamate dal thread principale non causano deadlock: su TCP la risposta viene ricevuta da un thread separato.
Inserisci un TsgcModbusTCPServer (o TsgcModbusRTUServer con una porta seriale), riempi il suo DataModel con SetHoldingRegister, SetCoil e gli altri setter, e imposta Active := True. Usa OnReadRequest e OnWriteRequest per calcolare i valori su richiesta o per rifiutare le scritture con un codice di eccezione Modbus.
Da Delphi 7 a Delphi 13 e C++Builder, su Windows (32 e 64 bit), Linux 64 bit e macOS. La porta seriale, e con essa Modbus RTU, non è disponibile su Android e iOS.
I componenti Modbus e porta seriale sono inclusi in sgcWebSockets Enterprise (Delphi e .NET) e All-Access, oppure nel pacchetto standalone sgcIndustrial.