Modbus TCP und RTU Client

Lies und schreibe die Coils und Register von SPS-Steuerungen, Energiezählern und Antrieben aus Delphi, C++Builder und .NET, über TCP/IP oder über eine serielle RS-232- oder RS-485-Leitung.

Neu

TsgcModbusTCPClient und TsgcModbusRTUClient

Zwei Clients mit denselben Methoden: Der eine verbindet sich mit einem Modbus TCP Gerät oder Gateway, der andere ist ein Modbus RTU Master an einer seriellen Leitung.

Komponentenklassen

TsgcModbusTCPClient
TsgcModbusRTUClient

Protokoll

Modbus Application Protocol V1.1b3, Modbus TCP und Modbus RTU

Plattformen

TCP: alle Plattformen von sgcWebSockets. RTU: Windows, Linux und macOS

Edition

Enthalten in sgcWebSockets Enterprise (Delphi und .NET) und All-Access oder im eigenständigen Paket sgcIndustrial

Verbinden, lesen und schreiben über Modbus TCP

Setze Host und UnitId, setze Active auf True und rufe die Methoden auf. Jede Anfrage blockiert, bis die passende Antwort eintrifft, und löst eine Exception aus, wenn das Gerät einen Fehler meldet oder nicht antwortet.

uses
  sgcIndustrial;

procedure TForm1.ConnectClient;
begin
  FClient := TsgcModbusTCPClient.Create(Self);
  FClient.Host := '192.168.1.50';
  FClient.Port := 502;
  FClient.UnitId := 1;
  FClient.Timeout := 1000;
  FClient.Retries := 2;
  FClient.OnConnect := OnModbusConnect;
  FClient.OnError := OnModbusError;
  FClient.Active := True;
end;

procedure TForm1.OnModbusConnect(Sender: TObject);
begin
  Memo1.Lines.Add('Connected');
end;

procedure TForm1.ReadValues;
var
  vRegisters: TsgcModbusRegisters;
  vTemperature: Single;
begin
  try
    vRegisters := FClient.ReadHoldingRegisters(0, 10);
    FClient.WriteSingleCoil(10, True);
    // 32-bit float stored low word first by many PLCs
    FClient.WordOrder := mwoCDAB;
    vTemperature := FClient.ReadFloat32(300);
    Memo1.Lines.Add(Format('HR0 = %d, temperature = %.1f',
      [vRegisters[0], vTemperature]));
  except
    on E: EsgcModbusException do
      Memo1.Lines.Add(Format('Device exception %d', [E.ExceptionCode]));
    on E: EsgcModbusTimeout do
      Memo1.Lines.Add('No response');
  end;
end;

procedure TForm1.OnModbusError(Sender: TObject; const aError: string);
begin
  Memo1.Lines.Add('Error: ' + aError);
end;
#include "sgcIndustrial.hpp"

void __fastcall TForm1::ConnectClient()
{
  FClient = new TsgcModbusTCPClient(this);
  FClient->Host = "192.168.1.50"; // Port is 502 by default
  FClient->UnitId = 1;
  FClient->Timeout = 1000;
  FClient->Retries = 2;
  FClient->OnConnect = OnModbusConnect;
  FClient->OnError = OnModbusError;
  FClient->Active = true;
}

void __fastcall TForm1::OnModbusConnect(TObject *Sender)
{
  Memo1->Lines->Add("Connected");
}

void __fastcall TForm1::ReadValues()
{
  try
  {
    TsgcModbusRegisters vRegisters = FClient->ReadHoldingRegisters(0, 10);
    FClient->WriteSingleCoil(10, true);
    // 32-bit float stored low word first by many PLCs
    FClient->WordOrder = mwoCDAB;
    float vTemperature = FClient->ReadFloat32(300);
    Memo1->Lines->Add("HR0 = " + IntToStr(vRegisters[0]) + ", temperature = " +
      FloatToStrF(vTemperature, ffFixed, 7, 1));
  }
  catch (EsgcModbusException &E)
  {
    Memo1->Lines->Add("Device exception " + IntToStr(E.ExceptionCode));
  }
  catch (EsgcModbusTimeout &E)
  {
    Memo1->Lines->Add("No response");
  }
}

void __fastcall TForm1::OnModbusError(TObject *Sender, const String aError)
{
  Memo1->Lines->Add("Error: " + aError);
}
using System;
using esegece.sgcWebSockets;

class PlcClient
{
    TsgcModbusTCPClient FClient = new TsgcModbusTCPClient();

    public void ConnectClient()
    {
        FClient.Host = "192.168.1.50";
        FClient.Port = 502;
        FClient.UnitId = 1;
        FClient.Timeout = 1000;
        FClient.Retries = 2;
        FClient.OnConnect += OnModbusConnect;
        FClient.OnError += OnModbusError;
        FClient.Active = true;
    }

    void OnModbusConnect(object Sender, EventArgs e)
    {
        Console.WriteLine("Connected");
    }

    public void ReadValues()
    {
        try
        {
            ushort[] vRegisters = FClient.ReadHoldingRegisters(0, 10);
            FClient.WriteSingleCoil(10, true);
            // 32-bit float stored low word first by many PLCs
            FClient.WordOrder = TsgcModbusWordOrder.mwoCDAB;
            float vTemperature = FClient.ReadFloat32(300);
            Console.WriteLine($"HR0 = {vRegisters[0]}, temperature = {vTemperature:F1}");
        }
        catch (EsgcModbusException E)
        {
            Console.WriteLine("Device exception " + E.ExceptionCode);
        }
        catch (EsgcModbusTimeout)
        {
            Console.WriteLine("No response");
        }
    }

    void OnModbusError(object Sender, string aError)
    {
        Console.WriteLine("Error: " + aError);
    }
}

Was steckt drin

Framing, Timing und Fehlerbehandlung von Modbus übernimmt die Komponente, sodass dein Code nur mit Adressen und Werten arbeitet.

Funktionscodes

01 bis 06, 15, 16, 22 (Mask Write), 23 (Read/Write Multiple Registers) und 43/14 (Geräteidentifikation, mit Paging). Der RTU Client ergänzt 07 (Read Exception Status) und 08 (Diagnostics).

Typisierte Werte

ReadInt32, ReadUInt32, ReadFloat32, ReadString und die zugehörigen Schreibmethoden, dazu Lesevorgänge aus Input-Registern. WordOrder wählt ABCD, DCBA, BADC oder CDAB passend zum Gerät.

Threadsichere Anfragen

Rufe die Methoden aus jedem Thread auf: Die Anfragen werden serialisiert, und jede Antwort wird über ihre Transaktions-ID zugeordnet. Timeout gilt für jeden Versuch, und Retries fügt weitere Versuche hinzu.

Klare Fehler

Eine Modbus-Exception-Antwort löst EsgcModbusException mit Exception- und Funktionscode aus, keine Antwort löst EsgcModbusTimeout aus, und jedes andere Problem löst EsgcModbusError aus. Mengen außerhalb der Spezifikation werden abgelehnt, bevor etwas gesendet wird.

TLS, Proxy und Wiederverbindung

Der TCP Client unterstützt TLS, Proxy und WatchDog für die automatische Wiederverbindung. Eine wartende Anfrage löst sofort eine Exception aus, wenn die Verbindung abbricht, ohne den Timeout abzuwarten.

Gateways und Unit-IDs

Jede Methode hat eine Überladung mit vorangestellter Unit-ID, sodass eine TCP-Verbindung alle Geräte hinter einem Modbus-TCP-zu-RTU-Gateway erreicht, ohne UnitId zu ändern.

Ein RTU Master an RS-232 und RS-485

Öffne einen TsgcSerialPort, verknüpfe ihn über SerialPort und setze die Slave-Adresse in UnitId. Der Client baut den RTU-Frame mit seiner CRC16 und wartet auf den Slave.

procedure TForm1.ReadSlave;
var
  vRegisters: TsgcModbusRegisters;
begin
  FPort := TsgcSerialPort.Create(Self);
  FPort.Port := 'COM4';
  FPort.BaudRate := 19200;
  FPort.Parity := spEven;
  FPort.Open;

  FRTU := TsgcModbusRTUClient.Create(Self);
  FRTU.SerialPort := FPort;
  FRTU.UnitId := 17;
  FRTU.Timeout := 500;
  FRTU.Retries := 2;
  vRegisters := FRTU.ReadHoldingRegisters(107, 3);
  Memo1.Lines.Add(Format('Register 107 = %d', [vRegisters[0]]));

  // unit id 0 = broadcast: every slave executes the write, none answers
  FRTU.WriteSingleRegister(0, 1, 100);
end;
void __fastcall TForm1::ReadSlave()
{
  FPort = new TsgcSerialPort(this);
  FPort->Port = "COM4";
  FPort->BaudRate = 19200;
  FPort->Parity = spEven;
  FPort->Open();

  FRTU = new TsgcModbusRTUClient(this);
  FRTU->SerialPort = FPort;
  FRTU->UnitId = 17;
  FRTU->Timeout = 500;
  FRTU->Retries = 2;
  TsgcModbusRegisters vRegisters = FRTU->ReadHoldingRegisters(107, 3);
  Memo1->Lines->Add("Register 107 = " + IntToStr(vRegisters[0]));

  // unit id 0 = broadcast: every slave executes the write, none answers
  FRTU->WriteSingleRegister(0, 1, 100);
}
using System;
using esegece.sgcWebSockets;

class RtuMaster
{
    TsgcSerialPort FPort = new TsgcSerialPort();
    TsgcModbusRTUClient FRTU = new TsgcModbusRTUClient();

    public void ReadSlave()
    {
        FPort.Port = "COM4";
        FPort.BaudRate = 19200;
        FPort.Parity = TsgcSerialParity.spEven;
        FPort.Open();

        FRTU.SerialPort = FPort;
        FRTU.UnitId = 17;
        FRTU.Timeout = 500;
        FRTU.Retries = 2;
        ushort[] vRegisters = FRTU.ReadHoldingRegisters(107, 3);
        Console.WriteLine("Register 107 = " + vRegisters[0]);

        // unit id 0 = broadcast: every slave executes the write, none answers
        FRTU.WriteSingleRegister(0, 1, 100);
    }
}

Spezifikationen & Referenzen

Maßgebliche Quellen für das Protokoll, das diese Komponente implementiert.

Fragen zum Modbus Client

Die Methoden erwarten die Protokolladresse, die bei 0 beginnt. Das Register, das viele Handbücher als 40001 dokumentieren, ist das Holding-Register 0, rufe also ReadHoldingRegisters(0, 1) auf.

Rufe ReadFloat32 mit der Adresse des ersten seiner beiden Register auf. Wenn der Wert falsch aussieht, speichert das Gerät die Bytes in anderer Reihenfolge: Setze WordOrder auf die Reihenfolge, die das Gerät verwendet. Viele SPS-Steuerungen speichern das niederwertige Wort zuerst, das ist mwoCDAB.

Jeder Versuch wartet Timeout Millisekunden. Nach Retries + 1 Versuchen ohne gültige Antwort löst die Anfrage EsgcModbusTimeout aus, mit Funktionscode, Unit-ID und Anzahl der Versuche in der Meldung.

Nein. Öffne den TsgcSerialPort selbst und lass sein Ereignis OnData leer, weil der Client die Antworten mit Read liest. Eine Anfrage löst EsgcModbusError aus, wenn der Port nicht zugewiesen oder nicht geöffnet ist oder OnData zugewiesen hat.

Sie ist in sgcWebSockets Enterprise (Delphi und .NET) und All-Access enthalten, als Teil des Pakets sgcIndustrial. Füge in Delphi sgcIndustrial zur uses-Klausel hinzu.

Dokumentation & Demos

Springe direkt zur Komponentenreferenz, öffne das Demoprojekt und lies das technische Dokument.

Online Help: TsgcModbusTCPClient Vollständige Referenz zu Eigenschaften, Methoden und Ereignissen des Modbus TCP Clients.
Online Help: TsgcModbusRTUClient Vollständige Referenz zu Eigenschaften, Methoden und Ereignissen des Modbus RTU Clients.
Demoprojekt: Industrial\02.Modbus_TCP_Client Ein Modbus TCP Client für Delphi, C++Builder und .NET. Er wird im Paket sgcWebSockets mitgeliefert.
Technisches Dokument (PDF) Funktionen, Schnellstart, Code-Beispiele und Primärquellen nur für diese Komponente.
Benutzerhandbuch (PDF) Umfassendes Handbuch, das jede Komponente der Bibliothek abdeckt.
Bestes Preis-Leistungs-Verhältnis: All-AccessAlle eSeGeCe-Produkte, inklusive Premium-Support, ab €1,059 pro Jahr.
All-Access-Preise ansehen

Enthalten in sgcWebSockets Enterprise

Enthalten in sgcWebSockets Enterprise (Delphi und .NET) und All-Access oder im eigenständigen Paket sgcIndustrial.