Novità

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.

Due client, due server, una sola API Modbus

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.

Classi dei componenti

TsgcModbusTCPClient, TsgcModbusRTUClient, TsgcModbusTCPServer, TsgcModbusRTUServer, TsgcModbusDataModel

Trasporti

Modbus TCP sulla porta 502 con TLS e proxy opzionali; Modbus RTU su RS-232 e RS-485 tramite TsgcSerialPort

Codici funzione

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

Piattaforme

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

Ogni funzione Modbus comune, un metodo ciascuna

Il client controlla le quantità rispetto alla specifica prima di inviare qualsiasi cosa; i server rispondono a ogni codice di questa tabella.

FCFunzioneMetodo del client
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 (linea seriale)ReadExceptionStatus sul client RTU
08Diagnostics (linea seriale)Diagnostics sul client RTU
15Write Multiple CoilsWriteMultipleCoils
16Write Multiple RegistersWriteMultipleRegisters, WriteInt32, WriteUInt32, WriteFloat32, WriteString
22Mask Write RegisterMaskWriteRegister
23Read/Write Multiple RegistersReadWriteMultipleRegisters
43/14Read Device IdentificationReadDeviceIdentification (basic, regular, extended e oggetto singolo)

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 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 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 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.

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.

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.

Altri componenti industriali in sgcWebSockets

Componenti industriali

Porta seriale, Modbus e il client OPC UA in un'unica sezione, con il riferimento completo dei componenti.

Riferimento del client Modbus

Proprietà, metodi ed eventi di TsgcModbusTCPClient e TsgcModbusRTUClient.

Riferimento del server Modbus

TsgcModbusTCPServer, TsgcModbusRTUServer e gli hook di TsgcModbusDataModel.

Porta seriale Delphi

TsgcSerialPort per Windows, Linux e macOS: il trasporto di Modbus RTU, e un componente seriale a sé stante.

Client MQTT Delphi

Pubblica valori Modbus su un broker MQTT: il modo abituale per portare i dati di fabbrica nel cloud.

Anche per C# e .NET

Gli stessi client e server Modbus, con gli stessi nomi di classe, per .NET 8, 9, 10 e .NET Standard 2.0.

La scelta più conveniente: All-AccessTutti i prodotti eSeGeCe, con Supporto Premium incluso, a partire da €1,059/anno.
Vedi i prezzi All-Access

Parla con il tuo primo PLC da Delphi

Incluso in sgcWebSockets Enterprise (Delphi e .NET) e All-Access, oppure nel pacchetto standalone sgcIndustrial.