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.
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.
ReadDeviceIdentification (podstawowa, zwykła, rozszerzona i pojedynczy obiekt)
QuickStart
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 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;
Klient
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.
Serwer
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.
Współpraca z innymi implementacjami
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.
FAQ
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.