Yeni

Delphi Modbus TCP ve RTU: İstemci ve Sunucu Bileşenleri

Delphi ve C++Builder için yerel Modbus TCP ve Modbus RTU bileşenleri. PLC'leri, sürücüleri, enerji sayaçlarını ve ağ geçitlerini yoklayın ya da kendi verinizi bir Modbus sunucusu olarak yayımlayın; her sözcük sırasında tipli Float32, Int32 ve dize yardımcılarıyla.

sgcWebSockets Enterprise (Delphi ve .NET) ve All-Access ya da bağımsız sgcIndustrial paketi içinde yer alır.

İki istemci, iki sunucu, tek Modbus API'si

Pascal ile yazılmış ve uygulamanıza derlenen, görsel olmayan bileşenler olarak Modbus TCP ve Modbus RTU ana ve köle cihazları.

Bir Delphi Modbus kitaplığı, bir VCL, FMX, servis ya da konsol uygulamasının her fabrika zemininde bulunan cihazlarla konuşmasını sağlar: PLC'ler, frekans sürücüleri, enerji sayaçları, sıcaklık denetleyicileri ve protokol ağ geçitleri. sgcWebSockets bunu dört bileşen olarak sunar: TsgcModbusTCPClient ve TsgcModbusRTUClient cihazları yoklar, TsgcModbusTCPServer ve TsgcModbusRTUServer ise kendi verinizi SCADA sistemlerine, HMI'lara ve diğer her Modbus ana cihazına açar.

Her iki istemci de TsgcModbusClient_Base sınıfından türer, bu yüzden bir yazmacı Ethernet üzerinden okuyan kod onu RS-485 üzerinden de okur: çağrıları değil, bileşeni değiştirirsiniz. Her çağrı, yanıt gelene ya da Timeout dolana kadar engeller, değerleri Delphi dizileri olarak döndürür ve cihaz bir hata bildirdiğinde tipli bir istisna oluşturur. Tek bir uses sgcIndustrial; satırı tüm sınıfları getirir.

Bileşen sınıfları

TsgcModbusTCPClient, TsgcModbusRTUClient, TsgcModbusTCPServer, TsgcModbusRTUServer, TsgcModbusDataModel

Taşımalar

İsteğe bağlı TLS ve proxy ile 502 portunda Modbus TCP; TsgcSerialPort üzerinden RS-232 ve RS-485 ile Modbus RTU

İşlev kodları

01 ile 08 arası, 15, 16, 22, 23 ve 43/14 (cihaz tanımlamayı okuma)

Platformlar

Delphi 7 ile Delphi 13 ve C++Builder; Windows, Linux ve macOS

Yaygın her Modbus işlevi, her biri için bir metot

İstemci, hiçbir şey gönderilmeden önce miktarları spesifikasyona göre denetler; sunucular bu tablodaki her koda yanıt verir.

FCİşlevİstemci metodu
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 (seri hat)RTU istemcisinde ReadExceptionStatus
08Diagnostics (seri hat)RTU istemcisinde Diagnostics
15Write Multiple CoilsWriteMultipleCoils
16Write Multiple RegistersWriteMultipleRegisters, WriteInt32, WriteUInt32, WriteFloat32, WriteString
22Mask Write RegisterMaskWriteRegister
23Read/Write Multiple RegistersReadWriteMultipleRegisters
43/14Read Device IdentificationReadDeviceIdentification (temel, normal, genişletilmiş ve tek nesne)

Birkaç satır Delphi ile bir PLC'yi okuyun

Bileşeni oluşturun, adresi ayarlayın, bir metot çağırın. Bu sayfadaki her örnek Delphi 7 ve Delphi 13 ile derlenir.

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;

Herhangi bir iş parçacığından çağırabileceğiniz bir Modbus ana cihazı

TCP üzerinde ve seri hatta engelleyen çağrılar, tipli değerler ve açık hatalar.

Tipli 32 bit değerler ve dizeler

ReadFloat32, ReadInt32, ReadUInt32 ve bunların yazma ve giriş yazmacı karşılıkları iki yazmacı tek bir değerde birleştirir. WordOrder, cihazların kullandığı dört düzeni kapsar: mwoABCD (big endian, Modbus varsayılanı), mwoCDAB, mwoBADC ve mwoDCBA. ReadString ve WriteString yazmaç başına iki karakter paketler.

İş parçacığı güvenli engelleyen çağrılar

İstemci başına aynı anda bir istek çalışır; tüm yeniden denemelerini kapsayan bir kilitle korunur, böylece birden çok iş parçacığı tek bir bağlantıyı paylaşabilir. TCP üzerinde yanıtı alma iş parçacığı eşleştirir, bu yüzden ana iş parçacığından yapılan bir çağrı kilitlenemez.

Zaman aşımları ve yeniden denemeler

Timeout deneme başına bekleme süresidir, Retries ise ek denemelerdir. Bir TCP yeniden denemesi yeni bir işlem kimliği kullanır ve geç ya da yinelenen yanıtlar bir sonraki yanıt sanılmak yerine atılır.

Tipli istisnalar

EsgcModbusException cihazın ExceptionCode ve FunctionCode değerlerini taşır, EsgcModbusTimeout eksik yanıtı bildirir ve EsgcModbusError kapalı bir bağlantıdan hatalı CRC'li bir RTU çerçevesine kadar geri kalan her şeyi kapsar.

Çağrı başına birim kimliği

Her metodun ayrıca başında bir birim kimliği olan bir aşırı yüklemesi vardır, böylece bir ağ geçidine tek bağlantı arkasındaki tüm cihazlara ulaşır. UnitId, bu parametresiz çağrılar için varsayılandır.

TCP üzerinde TLS, proxy ve yeniden bağlanma

TLS ve TLSOptions Modbus TCP akışını TLS içine alır, Proxy bir cihaza HTTP ya da SOCKS proxy üzerinden ulaşır ve WatchDog bir ağ kopmasından sonra yeniden bağlanır. Üçü de bileşenin üzerine kurulu olduğu sgcWebSockets TCP istemcisinden gelir.

Doğru RTU çerçevelemesi

RTU istemcisi göndermeden önce 3,5 karakterlik sessizliği bekler, yanıtı beklenen uzunluğuna göre okur (USB adaptörleri baytları kümeler halinde iletir), her çerçevenin CRC değerini denetler ve diğer köle adreslerinden gelen çerçeveleri yok sayar.

RS-485 ve yayın

Seri portta RtsControl := srcToggle ayarlayın; RTS her yazmada RS-485 vericisini değiştirir, Windows'ta sürücü üzerinden, Linux'ta çekirdeğin RS-485 modu üzerinden. Birim kimliği 0, her köleye bir yayın yazması gönderir ve yanıt yerine TurnaroundDelay kadar bekler.

Olaylar istediğiniz yerde

OnConnect, OnDisconnect ve OnError, NotifyEvents ile iletilir: varsayılan olarak ana iş parçacığına kuyruğa alınır, eşzamanlanır ya da doğrudan alma iş parçacığında tetiklenir.

Canlı veri modeline sahip Modbus TCP ve RTU sunucuları

Bir Delphi uygulamasını Modbus köle cihazına dönüştürün: bir veritabanından ya da REST API'sinden değerleri sunan bir ağ geçidi, HMI ekranlarını test etmek için bir cihaz simülatörü ya da kendi denetleyicinizin Modbus yüzü. Her sunucu, dört Modbus tablosuyla (bobinler, ayrık girişler, tutma yazmaçları ve giriş yazmaçları; varsayılan olarak her birinden 10.000, en fazla 65.536), FC 43/14 ile yanıtlanan cihaz tanımlama dizeleriyle ve FC 07 ile yanıtlanan istisna durumuyla bir TsgcModbusDataModel sahiplenir.

Veri modeli iş parçacığı güvenlidir: tek bir kilit tüm tabloları korur, böylece istemciler okurken kodunuz değerleri güncelleyebilir. İki kanca kodunuzu istek yoluna koyar. OnReadRequest bir tablo okunmadan önce çalışır, böylece değerleri tam zamanında yenileyebilir ya da isteği bir istisna koduyla reddedebilir. OnWriteRequest değerleri saklanmadan önce alır, böylece onları doğrulayabilir, değiştirebilir ya da yazmayı reddedip tablolara dokunmayabilir.

TsgcModbusTCPServer

Her biri kendi iş parçacığına sahip çok sayıda eşzamanlı bağlantı. Bir pakette birlikte gelen istekler sırayla yanıtlanır, birkaç pakete bölünmüş bir istek yeniden birleştirilir ve hatalı biçimli bir başlık o bağlantıyı kapatır ve OnError olayını tetikler. UnitId = 0 her birim kimliğine yanıt verir; başka bir değer yalnızca o kimliğe yanıt verir. Bindings arayüzleri ve portları seçer, OnClientConnect ve OnClientDisconnect karşı tarafları bildirir.

TsgcModbusRTUServer

Bir TsgcSerialPort üzerinde UnitId köle adresiyle (1 ile 247) dinler. İstekleri beklenen uzunluklarına ve 3,5 karakterlik sessizliğe göre çerçeveler, hatalı CRC'li ya da başka adresli çerçeveleri yok sayar ve seri hat spesifikasyonunun gerektirdiği gibi birim kimliği 0'dan gelen yayın yazmalarını yanıtlamadan yürütür.

Bağlantı iş parçacığındaki kancalar

Sunucu olayları bağlantı iş parçacığında (TCP) ya da çerçeve iş parçacığında (RTU) çalışır ve sonuçlarını eşzamanlı olarak döndürür. Kısa tutun ve veri modeli metotlarını rahatça çağırın: kancalar hiçbir kilit tutulmadan çalışır.

Bağımsız bir Modbus yığınına karşı test edildi

Modbus istemcisi ve sunucusu, bağımsız bir açık kaynaklı gerçekleştirme olan pymodbus'a karşı Modbus TCP üzerinden hat üzerinde test edilir: 01 ile 06 arası, 15, 16, 22, 23 ve 43/14 işlev kodları, istisna yanıtları, Float32 değerleri ve cihaz tanımlama. Tipli yardımcılar, dört sözcük sırasının tümünde bilinen bayt vektörlerine karşı denetlenir. Delphi bileşenleri ayrıca sgcWebSockets .NET Modbus bileşenlerine karşı iki yönde, istemciye karşı sunucu, her yönde 35 denetimin 35'i geçerek test edilir.

Seri port, Windows'ta gerçek bir COM portunda ve Linux'ta sözde terminallerde test edilir; bir okuma beklerken portun kapatılması da buna dahildir. Modbus RTU istemcisi ve sunucusu, simüle edilmiş köle ve ana cihazlara karşı test edilir: bölünmüş çerçeveler, CRC hataları, diğer köle adresleri ve yayınlar. Aynı kod macOS için de derlenir.

Delphi Modbus soruları

Bir TsgcModbusTCPClient oluşturun, Host, Port (varsayılan 502) ve UnitId değerlerini ayarlayın, Active := True yapın ve ReadHoldingRegisters(Address, Count) çağırın. Yazmaç başına bir Word içeren bir TsgcModbusRegisters dizisi döndürür. Adresler, hat üzerinde taşındıkları gibi sıfırdan başlar.

İki yazmacın ilkinin adresiyle ReadFloat32, ReadInt32 veya ReadUInt32 çağırın, giriş yazmaçları için de ReadInput... varyantlarını kullanın. Değer yanlış görünüyorsa cihaz başka bir sözcük sırası kullanıyordur: WordOrder değerini varsayılan mwoABCD yerine mwoCDAB, mwoBADC veya mwoDCBA yapın.

Evet. Adaptörde bir TsgcSerialPort açın ve onu TsgcModbusRTUClient ya da TsgcModbusRTUServer bileşeninin SerialPort özelliğine atayın. Otomatik yön denetimli adaptörler için başka bir şey gerekmez. Vericiyi RTS ile değiştiren adaptörler için RtsControl := srcToggle ayarlayın: Windows sürücünün RTS geçiş modunu, Linux çekirdeğin RS-485 modunu kullanır.

Evet. İstemci aynı anda bir işlem çalıştırır ve yeniden denemeler dahil tüm istek boyunca bir kilit tutar, böylece birkaç iş parçacığından gelen çağrılar sıraya girer ve her biri kendi yanıtını alır. Ana iş parçacığından yapılan çağrılar kilitlenmez: TCP üzerinde yanıtı ayrı bir iş parçacığı alır.

Forma bir TsgcModbusTCPServer (ya da seri portlu TsgcModbusRTUServer) bırakın, DataModel bileşenini SetHoldingRegister, SetCoil ve diğer ayarlayıcılarla doldurun ve Active := True yapın. Değerleri isteğe göre hesaplamak ya da yazmaları bir Modbus istisna koduyla reddetmek için OnReadRequest ve OnWriteRequest kullanın.

Windows (32 ve 64 bit), Linux 64 bit ve macOS üzerinde Delphi 7 ile Delphi 13 ve C++Builder. Seri port ve onunla birlikte Modbus RTU, Android ve iOS'ta kullanılamaz.

Modbus ve seri port bileşenleri sgcWebSockets Enterprise (Delphi ve .NET) ve All-Access ya da bağımsız sgcIndustrial paketi içinde yer alırlar.

sgcWebSockets içinde daha fazla endüstriyel bileşen

Endüstriyel bileşenler

Seri port, Modbus ve OPC UA istemcisi tek bir bölümde, tam bileşen başvurusuyla.

Modbus istemcisi başvurusu

TsgcModbusTCPClient ve TsgcModbusRTUClient bileşenlerinin özellikleri, metotları ve olayları.

Modbus sunucusu başvurusu

TsgcModbusTCPServer, TsgcModbusRTUServer ve TsgcModbusDataModel kancaları.

Delphi seri port

Windows, Linux ve macOS için TsgcSerialPort: Modbus RTU'nun taşıması ve kendi başına bir seri bileşen.

Delphi MQTT istemcisi

Modbus değerlerini bir MQTT aracısına yayımlayın: fabrika verisini buluta taşımanın olağan yolu.

C# ve .NET için de

Aynı Modbus istemcileri ve sunucuları, aynı sınıf adlarıyla, .NET 8, 9, 10 ve .NET Standard 2.0 için.

En avantajlı seçenek: All-AccessTüm eSeGeCe ürünleri, Premium Destek dahil, yılda €1,059'dan itibaren.
All-Access fiyatlarına bakın

Delphi'den ilk PLC'nizle konuşun

sgcWebSockets Enterprise (Delphi ve .NET) ve All-Access ya da bağımsız sgcIndustrial paketi içinde yer alır.