Modbus TCP en RTU-server

Maak van een Delphi-, C++Builder- of .NET-toepassing een Modbus-apparaat. Beantwoord SCADA-systemen, HMI's en Modbus-clients via TCP/IP of een seriële lijn, vanuit een thread-safe gegevensmodel.

Nieuw

TsgcModbusTCPServer en TsgcModbusRTUServer

Twee servers die antwoorden vanuit hetzelfde TsgcModbusDataModel: de ene luistert op TCP-poort 502, de andere is een Modbus RTU-slave op een seriële lijn.

Componentklassen

TsgcModbusTCPServer
TsgcModbusRTUServer
TsgcModbusDataModel

Protocol

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

Platformen

TCP: elk platform van sgcWebSockets. RTU: Windows, Linux en macOS

Editie

Inbegrepen in sgcWebSockets Enterprise (Delphi en .NET) en All-Access, of in het standalone pakket sgcIndustrial

Een Modbus TCP-server starten

Vul het gegevensmodel, wijs de events toe en zet Active op True. OnReadRequest ververst een live waarde voordat die wordt gelezen, en OnWriteRequest weigert setpoints buiten het bereik.

uses
  sgcIndustrial;

procedure TForm1.StartServer;
begin
  FServer := TsgcModbusTCPServer.Create(Self);
  FServer.Port := 502;
  FServer.DataModel.HoldingRegisterCount := 1000;
  FServer.DataModel.SetHoldingRegister(0, 1234);
  FServer.DataModel.SetCoil(5, True);
  FServer.DataModel.VendorName := 'eSeGeCe';
  FServer.DataModel.ProductCode := 'PLC-1';
  FServer.DataModel.MajorMinorRevision := '1.0';
  FServer.OnReadRequest := OnModbusReadRequest;
  FServer.OnWriteRequest := OnModbusWriteRequest;
  FServer.Active := True;
end;

procedure TForm1.OnModbusReadRequest(Sender: TObject; aUnitId,
  aFunctionCode: Byte; aAddress, aCount: Word; var aExceptionCode: Byte);
begin
  // live value: refresh input register 0 before the client reads it
  if aFunctionCode = CS_MODBUS_FC_READ_INPUT_REGISTERS then
    FServer.DataModel.SetInputRegister(0, FTemperature);
end;

procedure TForm1.OnModbusWriteRequest(Sender: TObject; aUnitId,
  aFunctionCode: Byte; aAddress, aCount: Word; var aBits: TsgcModbusBits;
  var aRegisters: TsgcModbusRegisters; var aExceptionCode: Byte);
var
  i: Integer;
begin
  // connection thread: setpoints accept 0..1000 only
  if (aFunctionCode = CS_MODBUS_FC_WRITE_SINGLE_REGISTER) or
    (aFunctionCode = CS_MODBUS_FC_WRITE_MULTIPLE_REGISTERS) then
    for i := 0 to Length(aRegisters) - 1 do
      if aRegisters[i] > 1000 then
      begin
        aExceptionCode := CS_MODBUS_EX_ILLEGAL_DATA_VALUE;
        Exit;
      end;
end;
#include "sgcIndustrial.hpp"

void __fastcall TForm1::StartServer()
{
  FServer = new TsgcModbusTCPServer(this);
  FServer->Port = 502;
  FServer->DataModel->HoldingRegisterCount = 1000;
  FServer->DataModel->SetHoldingRegister(0, 1234);
  FServer->DataModel->SetCoil(5, true);
  FServer->DataModel->VendorName = "eSeGeCe";
  FServer->DataModel->ProductCode = "PLC-1";
  FServer->DataModel->MajorMinorRevision = "1.0";
  FServer->OnReadRequest = OnModbusReadRequest;
  FServer->OnWriteRequest = OnModbusWriteRequest;
  FServer->Active = true;
}

void __fastcall TForm1::OnModbusReadRequest(TObject *Sender, Byte aUnitId,
  Byte aFunctionCode, Word aAddress, Word aCount, Byte &aExceptionCode)
{
  // live value: refresh input register 0 before the client reads it
  if (aFunctionCode == CS_MODBUS_FC_READ_INPUT_REGISTERS)
    FServer->DataModel->SetInputRegister(0, FTemperature);
}

void __fastcall TForm1::OnModbusWriteRequest(TObject *Sender, Byte aUnitId,
  Byte aFunctionCode, Word aAddress, Word aCount, TsgcModbusBits &aBits,
  TsgcModbusRegisters &aRegisters, Byte &aExceptionCode)
{
  // connection thread: setpoints accept 0..1000 only
  if ((aFunctionCode == CS_MODBUS_FC_WRITE_SINGLE_REGISTER) ||
      (aFunctionCode == CS_MODBUS_FC_WRITE_MULTIPLE_REGISTERS))
    for (int i = 0; i < aRegisters.Length; i++)
      if (aRegisters[i] > 1000)
      {
        aExceptionCode = CS_MODBUS_EX_ILLEGAL_DATA_VALUE;
        return;
      }
}
using System;
using esegece.sgcWebSockets;

class PlcServer
{
    TsgcModbusTCPServer FServer = new TsgcModbusTCPServer();
    ushort FTemperature = 215;

    public void StartServer()
    {
        FServer.Port = 502;
        FServer.DataModel.HoldingRegisterCount = 1000;
        FServer.DataModel.SetHoldingRegister(0, 1234);
        FServer.DataModel.SetCoil(5, true);
        FServer.DataModel.VendorName = "eSeGeCe";
        FServer.DataModel.ProductCode = "PLC-1";
        FServer.DataModel.MajorMinorRevision = "1.0";
        FServer.OnReadRequest += OnModbusReadRequest;
        FServer.OnWriteRequest += OnModbusWriteRequest;
        FServer.Active = true;
    }

    void OnModbusReadRequest(object Sender, byte aUnitId, byte aFunctionCode,
        ushort aAddress, ushort aCount, ref byte aExceptionCode)
    {
        // live value: refresh input register 0 before the client reads it
        if (aFunctionCode == sgcModbus_Classes.CS_MODBUS_FC_READ_INPUT_REGISTERS)
            FServer.DataModel.SetInputRegister(0, FTemperature);
    }

    void OnModbusWriteRequest(object Sender, byte aUnitId, byte aFunctionCode,
        ushort aAddress, ushort aCount, ref bool[] aBits, ref ushort[] aRegisters,
        ref byte aExceptionCode)
    {
        // connection thread: setpoints accept 0..1000 only
        if (aFunctionCode == sgcModbus_Classes.CS_MODBUS_FC_WRITE_SINGLE_REGISTER ||
            aFunctionCode == sgcModbus_Classes.CS_MODBUS_FC_WRITE_MULTIPLE_REGISTERS)
            foreach (ushort vValue in aRegisters)
                if (vValue > 1000)
                {
                    aExceptionCode = sgcModbus_Classes.CS_MODBUS_EX_ILLEGAL_DATA_VALUE;
                    return;
                }
    }
}

Wat zit erin

Een Modbus-apparaat in een component: de server parseert de verzoeken, controleert ze en antwoordt vanuit het gegevensmodel.

Functiecodes

01 tot en met 08 (08 met subfunctie 0), 15, 16, 22 (mask write, atomair toegepast), 23 (read/write multiple registers) en 43/14 (apparaatidentificatie, gepagineerd met More Follows).

Gegevensmodel

Coils, discrete inputs, holding registers en input registers, standaard 10000 van elk en tot 65536. Elke Get- en Set-methode is thread-safe, en een verzoek voorbij een tabel krijgt exception 02.

Lees- en schrijfevents

OnReadRequest wordt geactiveerd voordat de gegevens worden gelezen, om live waarden te laden. OnWriteRequest wordt geactiveerd voordat de gegevens worden geschreven, om de waarden te wijzigen of het verzoek met een Modbus-exceptioncode te weigeren.

Verbindingen

Elke TCP-verbinding wordt apart bediend, en meerdere verzoeken in één pakket worden in volgorde beantwoord. Een ongeldige header activeert OnError en sluit die verbinding. OnClientConnect en OnClientDisconnect melden de peers.

Unit-id's

Standaard beantwoordt de TCP-server elk unit-id. Stel UnitId in om slechts één id te beantwoorden: de verzoeken voor andere id's krijgen geen antwoord en de verbinding blijft open, zoals een gateway doet met een ontbrekend apparaat.

Apparaatidentificatie

VendorName, ProductCode en MajorMinorRevision zijn de basisobjecten, en VendorUrl, ProductName en ModelName de reguliere, beantwoord op functie 43/14.

Een RTU-slave op RS-232 en RS-485

Koppel een TsgcSerialPort en stel het slave-adres in via UnitId (1 tot 247). De server opent de poort bij het starten en antwoordt vanuit zijn gegevensmodel.

procedure TForm1.StartRTUServer;
begin
  FPort := TsgcSerialPort.Create(Self);
  FPort.Port := 'COM5';
  FPort.BaudRate := 19200;
  FPort.Parity := spEven;

  FRTUServer := TsgcModbusRTUServer.Create(Self);
  FRTUServer.SerialPort := FPort;
  FRTUServer.UnitId := 17;
  FRTUServer.DataModel.SetInputRegister(0, 215);
  // the server opens the port when it is closed
  FRTUServer.Active := True;
end;
void __fastcall TForm1::StartRTUServer()
{
  FPort = new TsgcSerialPort(this);
  FPort->Port = "COM5";
  FPort->BaudRate = 19200;
  FPort->Parity = spEven;

  FRTUServer = new TsgcModbusRTUServer(this);
  FRTUServer->SerialPort = FPort;
  FRTUServer->UnitId = 17;
  FRTUServer->DataModel->SetInputRegister(0, 215);
  // the server opens the port when it is closed
  FRTUServer->Active = true;
}
using System;
using esegece.sgcWebSockets;

class RtuSlave
{
    TsgcSerialPort FPort = new TsgcSerialPort();
    TsgcModbusRTUServer FRTUServer = new TsgcModbusRTUServer();

    public void StartRTUServer()
    {
        FPort.Port = "COM5";
        FPort.BaudRate = 19200;
        FPort.Parity = TsgcSerialParity.spEven;

        FRTUServer.SerialPort = FPort;
        FRTUServer.UnitId = 17;
        FRTUServer.DataModel.SetInputRegister(0, 215);
        // the server opens the port when it is closed
        FRTUServer.Active = true;
    }
}

Specificaties & referenties

Gezaghebbende bronnen voor het protocol dat deze component implementeert.

Vragen over de Modbus-server

In de thread die de TCP-verbinding bedient, of in de framethread van de RTU-server. Ze worden nooit met de hoofdthread gesynchroniseerd, omdat de server het antwoord van de handler nodig heeft om de response op te bouwen. Benader de gebruikersinterface er niet rechtstreeks vanuit en zet Active niet op False vanuit een eventhandler van de TCP-server.

Schrijf de waarden in het gegevensmodel wanneer ze veranderen, of laad ze in OnReadRequest, dat vóór elke leesactie wordt geactiveerd met de functiecode, het adres en het aantal. De methoden van het gegevensmodel kunnen vanuit het event en vanuit elke andere thread worden aangeroepen.

Stel aExceptionCode in OnWriteRequest in, bijvoorbeeld op CS_MODBUS_EX_ILLEGAL_DATA_VALUE (03). De client ontvangt die Modbus-exception en de tabellen blijven ongewijzigd. Het event kan de waarden ook wijzigen voordat ze worden geschreven.

Het is inbegrepen in sgcWebSockets Enterprise (Delphi en .NET) en All-Access, als onderdeel van het sgcIndustrial-pakket. Voeg in Delphi sgcIndustrial toe aan de uses-clausule.

Documentatie & demo's

Spring direct naar de componentreferentie, open het demoproject en lees het technische document.

Online Help: TsgcModbusTCPServer Volledige referentie van eigenschappen, methoden en events voor de Modbus TCP-server.
Online Help: TsgcModbusRTUServer Volledige referentie van eigenschappen, methoden en events voor de Modbus RTU-server.
Online Help: TsgcModbusDataModel De tabellen, de apparaatidentificatieobjecten en de events van het gegevensmodel.
Demoproject: Industrial\03.Modbus_TCP_Server Een Modbus TCP-server voor Delphi, C++Builder en .NET. Wordt meegeleverd in het sgcWebSockets-pakket.
Technisch document (PDF) Functies, snelstart, codevoorbeelden en primaire bronnen voor alleen deze component.
Gebruikershandleiding (PDF) Uitgebreide handleiding die elke component in de bibliotheek behandelt.
De beste deal: All-AccessElk eSeGeCe-product, inclusief Premium-ondersteuning, vanaf €1,059 per jaar.
Bekijk de All-Access-prijzen

Inbegrepen in sgcWebSockets Enterprise

Inbegrepen in sgcWebSockets Enterprise (Delphi en .NET) en All-Access, of in het standalone pakket sgcIndustrial.