Nowość

Delphi Modbus TCP i RTU: komponenty klienta i serwera

Natywne komponenty Modbus TCP i Modbus RTU dla Delphi i C++Builder. Odpytuj sterowniki PLC, napędy, liczniki energii i bramki albo udostępniaj własne dane jako serwer Modbus, z typowanymi metodami Float32, Int32 i ciągów znaków w dowolnej kolejności słów.

W pakiecie sgcWebSockets Enterprise (Delphi i .NET) oraz All-Access, a także w samodzielnym pakiecie sgcIndustrial.

Dwa klienty, dwa serwery, jedno API Modbus

Mastery i urządzenia podrzędne Modbus TCP i Modbus RTU jako komponenty niewizualne, napisane w Pascalu i skompilowane w Twojej aplikacji.

Biblioteka Delphi Modbus pozwala aplikacji VCL, FMX, usłudze lub konsolowej rozmawiać z urządzeniami spotykanymi na każdej hali produkcyjnej: sterownikami PLC, falownikami, licznikami energii, regulatorami temperatury i bramkami protokołów. sgcWebSockets dostarcza ją jako cztery komponenty: TsgcModbusTCPClient i TsgcModbusRTUClient odpytują urządzenia, a TsgcModbusTCPServer i TsgcModbusRTUServer udostępniają Twoje dane systemom SCADA, panelom HMI i każdemu innemu masterowi Modbus.

Oba klienty dziedziczą z TsgcModbusClient_Base, więc kod, który odczytuje rejestr przez Ethernet, odczytuje go także przez RS-485: wymieniasz komponent, a nie wywołania. Każde wywołanie blokuje, aż nadejdzie odpowiedź lub upłynie Timeout, zwraca wartości jako tablice Delphi i zgłasza typowany wyjątek, gdy urządzenie zgłosi błąd. Jedna linia uses sgcIndustrial; dołącza wszystkie klasy.

Klasy komponentów

TsgcModbusTCPClient, TsgcModbusRTUClient, TsgcModbusTCPServer, TsgcModbusRTUServer, TsgcModbusDataModel

Transporty

Modbus TCP na porcie 502 z opcjonalnym TLS i proxy; Modbus RTU przez RS-232 i RS-485 za pośrednictwem TsgcSerialPort

Kody funkcji

Od 01 do 08, 15, 16, 22, 23 i 43/14 (odczyt identyfikacji urządzenia)

Platformy

Delphi 7 do Delphi 13 i C++Builder; Windows, Linux i macOS

Każda popularna funkcja Modbus, po jednej metodzie

Klient sprawdza ilości ze specyfikacją, zanim cokolwiek wyśle; serwery odpowiadają na każdy kod z tej tabeli.

FCFunkcjaMetoda klienta
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 (łącze szeregowe)ReadExceptionStatus w kliencie RTU
08Diagnostics (łącze szeregowe)Diagnostics w kliencie RTU
15Write Multiple CoilsWriteMultipleCoils
16Write Multiple RegistersWriteMultipleRegisters, WriteInt32, WriteUInt32, WriteFloat32, WriteString
22Mask Write RegisterMaskWriteRegister
23Read/Write Multiple RegistersReadWriteMultipleRegisters
43/14Read Device IdentificationReadDeviceIdentification (podstawowa, zwykła, rozszerzona i pojedynczy obiekt)

Odczyt sterownika PLC w kilku linijkach Delphi

Utwórz komponent, ustaw adres, wywołaj metodę. Każdy przykład na tej stronie kompiluje się w Delphi 7 i 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;

Master Modbus, który możesz wywoływać z dowolnego wątku

Wywołania blokujące, wartości typowane i czytelne błędy, przez TCP i łącze szeregowe.

Typowane wartości 32-bitowe i ciągi znaków

ReadFloat32, ReadInt32, ReadUInt32 i ich odpowiedniki zapisu oraz rejestrów wejściowych łączą dwa rejestry w jedną wartość. WordOrder obejmuje cztery układy używane przez urządzenia: mwoABCD (big endian, domyślny w Modbus), mwoCDAB, mwoBADC i mwoDCBA. ReadString i WriteString pakują dwa znaki w jednym rejestrze.

Wywołania blokujące bezpieczne wątkowo

Na klienta wykonywane jest jedno żądanie naraz, pod blokadą obejmującą wszystkie jego ponowienia, więc kilka wątków może współdzielić jedno połączenie. W TCP odpowiedź dopasowuje wątek odbiorczy, więc wywołanie z wątku głównego nie może zakleszczyć się.

Limity czasu i ponowienia

Timeout to czas oczekiwania na próbę, a Retries to dodatkowe próby. Ponowienie TCP używa nowego identyfikatora transakcji, a spóźnione lub zdublowane odpowiedzi są odrzucane, zamiast być wzięte za następną odpowiedź.

Typowane wyjątki

EsgcModbusException niesie ExceptionCode i FunctionCode urządzenia, EsgcModbusTimeout zgłasza brak odpowiedzi, a EsgcModbusError obejmuje wszystko inne, od zamkniętego połączenia po ramkę RTU z błędną sumą CRC.

Identyfikator jednostki w każdym wywołaniu

Każda metoda ma też przeciążenie z identyfikatorem jednostki na początku, więc jedno połączenie z bramką dociera do wszystkich urządzeń za nią. UnitId jest wartością domyślną dla wywołań bez niego.

TLS, proxy i ponowne połączenie w TCP

TLS i TLSOptions opakowują strumień Modbus TCP w TLS, Proxy łączy z urządzeniem przez proxy HTTP lub SOCKS, a WatchDog łączy się ponownie po zerwaniu sieci. Wszystkie trzy pochodzą z klienta TCP sgcWebSockets, na którym zbudowany jest komponent.

Ramkowanie RTU zrobione poprawnie

Klient RTU czeka na ciszę o długości 3,5 znaku przed wysłaniem, czyta odpowiedź według oczekiwanej długości (adaptery USB dostarczają bajty seriami), sprawdza sumę CRC każdej ramki i ignoruje ramki z innych adresów urządzeń podrzędnych.

RS-485 i rozgłaszanie

Ustaw RtsControl := srcToggle na porcie szeregowym, a RTS przełącza nadajnik RS-485 przy każdym zapisie, przez sterownik w systemie Windows i tryb RS-485 jądra w systemie Linux. Identyfikator jednostki 0 wysyła zapis rozgłoszeniowy do każdego urządzenia podrzędnego i zamiast odpowiedzi czeka TurnaroundDelay.

Zdarzenia tam, gdzie ich potrzebujesz

OnConnect, OnDisconnect i OnError są dostarczane przez NotifyEvents: domyślnie kolejkowane do wątku głównego, synchronizowane albo wywoływane bezpośrednio w wątku odbiorczym.

Serwery Modbus TCP i RTU z modelem danych na żywo

Zamień aplikację Delphi w urządzenie podrzędne Modbus: bramkę udostępniającą wartości z bazy danych lub REST API, symulator urządzenia do testowania ekranów HMI albo interfejs Modbus własnego sterownika. Każdy serwer ma własny TsgcModbusDataModel z czterema tabelami Modbus (cewki, wejścia dyskretne, rejestry przechowujące i rejestry wejściowe, domyślnie po 10 000 pozycji, do 65 536), ciągami identyfikacji urządzenia zwracanymi na FC 43/14 i statusem wyjątku zwracanym na FC 07.

Model danych jest bezpieczny wątkowo: jedna blokada chroni wszystkie tabele, więc Twój kod może aktualizować wartości, gdy klienci je odczytują. Dwa haki wprowadzają Twój kod w ścieżkę żądania. OnReadRequest działa przed odczytem tabeli, więc może odświeżyć wartości w ostatniej chwili albo odrzucić żądanie kodem wyjątku. OnWriteRequest otrzymuje wartości przed ich zapisaniem, więc może je zweryfikować, zmienić albo odrzucić zapis i zostawić tabele nietknięte.

TsgcModbusTCPServer

Wiele równoczesnych połączeń, każde we własnym wątku. Żądania, które przychodzą razem w jednym pakiecie, otrzymują odpowiedzi po kolei, żądanie rozdzielone na kilka pakietów jest składane, a nieprawidłowy nagłówek zamyka to połączenie i wywołuje OnError. UnitId = 0 odpowiada na dowolny identyfikator jednostki; inna wartość odpowiada tylko na ten jeden. Bindings wybierają interfejsy i porty, a OnClientConnect i OnClientDisconnect informują o klientach.

TsgcModbusRTUServer

Nasłuchuje na TsgcSerialPort jako urządzenie podrzędne UnitId (od 1 do 247). Rozpoznaje ramki żądań po oczekiwanej długości i ciszy o długości 3,5 znaku, ignoruje ramki z błędną sumą CRC lub innym adresem i wykonuje zapisy rozgłoszeniowe z identyfikatora jednostki 0 bez odpowiadania, zgodnie ze specyfikacją łącza szeregowego.

Haki w wątku połączenia

Zdarzenia serwera działają w wątku połączenia (TCP) lub w wątku ramek (RTU) i zwracają wynik synchronicznie. Pisz je krótko i wywołuj metody modelu danych swobodnie: haki działają bez założonej blokady.

Przetestowane z niezależnym stosem Modbus

Klient i serwer Modbus są testowane na łączu z pymodbus, niezależną otwartą implementacją, przez Modbus TCP: kody funkcji od 01 do 06, 15, 16, 22, 23 i 43/14, odpowiedzi z wyjątkami, wartości Float32 i identyfikacja urządzenia. Typowane metody są sprawdzane ze znanymi wektorami bajtów we wszystkich czterech kolejnościach słów. Komponenty Delphi są też testowane z komponentami Modbus sgcWebSockets .NET w obu kierunkach, klient z serwerem, z wynikiem 35 na 35 kontroli w każdą stronę.

Port szeregowy jest testowany na prawdziwym porcie COM w systemie Windows i na pseudoterminalach w systemie Linux, łącznie z zamknięciem portu w trakcie oczekiwania odczytu. Klient i serwer Modbus RTU są testowane z symulowanymi urządzeniami podrzędnymi i masterami: ramki rozdzielone na części, błędy CRC, inne adresy urządzeń podrzędnych i rozgłaszanie. Ten sam kod kompiluje się dla macOS.

Pytania o Delphi Modbus

Utwórz TsgcModbusTCPClient, ustaw Host, Port (domyślnie 502) i UnitId, ustaw Active := True i wywołaj ReadHoldingRegisters(Address, Count). Zwraca tablicę TsgcModbusRegisters z jednym Word na rejestr. Adresy liczone są od zera, tak jak są przesyłane po łączu.

Wywołaj ReadFloat32, ReadInt32 lub ReadUInt32 z adresem pierwszego z dwóch rejestrów albo warianty ReadInput... dla rejestrów wejściowych. Jeśli wartość wygląda źle, urządzenie używa innej kolejności słów: ustaw WordOrder na mwoCDAB, mwoBADC lub mwoDCBA zamiast domyślnego mwoABCD.

Tak. Otwórz TsgcSerialPort na adapterze i przypisz go do właściwości SerialPort komponentu TsgcModbusRTUClient lub TsgcModbusRTUServer. Adapterom z automatycznym sterowaniem kierunkiem nie trzeba nic więcej. Dla adapterów, które przełączają nadajnik sygnałem RTS, ustaw RtsControl := srcToggle: Windows używa trybu przełączania RTS sterownika, a Linux trybu RS-485 jądra.

Tak. Klient wykonuje jedną transakcję naraz i trzyma blokadę przez całe żądanie, łącznie z ponowieniami, więc wywołania z kilku wątków ustawiają się w kolejce i każde dostaje własną odpowiedź. Wywołania z wątku głównego nie zakleszczają się: w TCP odpowiedź odbiera osobny wątek.

Upuść TsgcModbusTCPServer (albo TsgcModbusRTUServer z portem szeregowym), wypełnij jego DataModel przez SetHoldingRegister, SetCoil i pozostałe settery, i ustaw Active := True. Użyj OnReadRequest i OnWriteRequest, aby wyliczać wartości na żądanie lub odrzucać zapisy kodem wyjątku Modbus.

Delphi 7 do Delphi 13 i C++Builder, w systemach Windows (32 i 64 bit), Linux 64 bit i macOS. Port szeregowy, a wraz z nim Modbus RTU, nie jest dostępny na Androidzie i iOS.

Komponenty Modbus i portu szeregowego Wchodzą w skład sgcWebSockets Enterprise (Delphi i .NET) oraz All-Access, a także w samodzielnym pakiecie sgcIndustrial.

Więcej komponentów przemysłowych w sgcWebSockets

Komponenty przemysłowe

Port szeregowy, Modbus i klient OPC UA w jednej sekcji, z pełną dokumentacją komponentów.

Dokumentacja klienta Modbus

Właściwości, metody i zdarzenia TsgcModbusTCPClient i TsgcModbusRTUClient.

Dokumentacja serwera Modbus

TsgcModbusTCPServer, TsgcModbusRTUServer i haki TsgcModbusDataModel.

Port szeregowy w Delphi

TsgcSerialPort dla systemów Windows, Linux i macOS: transport Modbus RTU i samodzielny komponent szeregowy.

Klient MQTT dla Delphi

Publikuj wartości Modbus do brokera MQTT: typowy sposób, aby przenieść dane z hali produkcyjnej do chmury.

Także dla C# i .NET

Te same klienty i serwery Modbus, z tymi samymi nazwami klas, dla .NET 8, 9, 10 i .NET Standard 2.0.

Najkorzystniejsza oferta: All-AccessWszystkie produkty eSeGeCe, ze wsparciem Premium w cenie, już od €1,059 rocznie.
Zobacz cennik All-Access

Porozmawiaj ze swoim pierwszym sterownikiem PLC z Delphi

W pakiecie sgcWebSockets Enterprise (Delphi i .NET) oraz All-Access, a także w samodzielnym pakiecie sgcIndustrial.