Serveur Modbus TCP et RTU

Transforme une application Delphi, C++Builder ou .NET en appareil Modbus. Réponds aux systèmes SCADA, aux IHM et aux clients Modbus via TCP/IP ou une ligne série, à partir d'un modèle de données thread-safe.

Nouveau

TsgcModbusTCPServer et TsgcModbusRTUServer

Deux serveurs qui répondent à partir du même TsgcModbusDataModel : l'un écoute sur le port TCP 502, l'autre est un esclave Modbus RTU sur une ligne série.

Classes de composants

TsgcModbusTCPServer
TsgcModbusRTUServer
TsgcModbusDataModel

Protocole

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

Plateformes

TCP : toutes les plateformes de sgcWebSockets. RTU : Windows, Linux et macOS

Édition

Inclus dans sgcWebSockets Enterprise (Delphi et .NET) et All-Access, ou dans le pack autonome sgcIndustrial

Démarrer un serveur Modbus TCP

Remplis le modèle de données, affecte les événements et mets Active à True. OnReadRequest actualise une valeur en direct avant sa lecture, et OnWriteRequest rejette les consignes hors plage.

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;
                }
    }
}

Sous le capot

Un appareil Modbus dans un composant : le serveur analyse les requêtes, les vérifie et répond à partir du modèle de données.

Codes de fonction

01 à 08 (08 avec la sous-fonction 0), 15, 16, 22 (mask write, appliqué de façon atomique), 23 (read/write multiple registers) et 43/14 (identification de l'appareil, paginée avec More Follows).

Modèle de données

Coils, discrete inputs, holding registers et input registers, 10000 de chaque par défaut et jusqu'à 65536. Chaque méthode Get et Set est thread-safe, et une requête au-delà d'une table reçoit l'exception 02.

Événements de lecture et d'écriture

OnReadRequest se déclenche avant la lecture des données, pour charger les valeurs en direct. OnWriteRequest se déclenche avant l'écriture des données, pour modifier les valeurs ou rejeter la requête avec un code d'exception Modbus.

Connexions

Chaque connexion TCP est servie séparément, et plusieurs requêtes dans un même paquet reçoivent une réponse dans l'ordre. Un en-tête mal formé déclenche OnError et ferme cette connexion. OnClientConnect et OnClientDisconnect signalent les pairs.

Identifiants d'unité

Par défaut, le serveur TCP répond à tous les identifiants d'unité. Mets UnitId pour ne répondre qu'à un seul identifiant : les requêtes pour les autres identifiants ne reçoivent aucune réponse et la connexion reste ouverte, comme le fait une passerelle avec un appareil absent.

Identification de l'appareil

VendorName, ProductCode et MajorMinorRevision sont les objets de base, et VendorUrl, ProductName et ModelName les objets réguliers, renvoyés en réponse à la fonction 43/14.

Un esclave RTU sur RS-232 et RS-485

Relie un TsgcSerialPort et indique l'adresse de l'esclave dans UnitId (1 à 247). Le serveur ouvre le port à son démarrage et répond à partir de son modèle de données.

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;
    }
}

Spécifications et références

Sources de référence pour le protocole implémenté par ce composant.

Questions sur le serveur Modbus

Dans le thread qui sert la connexion TCP, ou dans le thread de trame du serveur RTU. Ils ne sont jamais synchronisés avec le thread principal, car le serveur a besoin de la réponse du gestionnaire pour construire la réponse. N'accède pas directement à l'interface utilisateur depuis ces événements, et ne mets pas Active à False depuis un gestionnaire d'événement du serveur TCP.

Écris les valeurs dans le modèle de données chaque fois qu'elles changent, ou charge-les dans OnReadRequest, qui se déclenche avant chaque lecture avec le code de fonction, l'adresse et le nombre. Les méthodes du modèle de données peuvent être appelées depuis l'événement, et depuis n'importe quel autre thread.

Affecte aExceptionCode dans OnWriteRequest, par exemple à CS_MODBUS_EX_ILLEGAL_DATA_VALUE (03). Le client reçoit cette exception Modbus et les tables restent intactes. L'événement peut aussi modifier les valeurs avant leur écriture.

Il est inclus dans sgcWebSockets Enterprise (Delphi et .NET) et All-Access, dans le cadre du pack sgcIndustrial. En Delphi, ajoute sgcIndustrial à la clause uses.

Documentation et démos

Accède directement à la référence du composant, ouvre le projet de démo et lis le document technique.

Online Help: TsgcModbusTCPServer Référence complète des propriétés, méthodes et événements du serveur Modbus TCP.
Online Help: TsgcModbusRTUServer Référence complète des propriétés, méthodes et événements du serveur Modbus RTU.
Online Help: TsgcModbusDataModel Les tables, les objets d'identification de l'appareil et les événements du modèle de données.
Projet de démo : Industrial\03.Modbus_TCP_Server Un serveur Modbus TCP pour Delphi, C++Builder et .NET. Il est livré dans le paquet sgcWebSockets.
Document technique (PDF) Fonctionnalités, démarrage rapide, exemples de code et références de sources primaires pour ce seul composant.
Manuel utilisateur (PDF) Manuel complet couvrant tous les composants de la bibliothèque.
Meilleur rapport qualité-prix : All-AccessTous les produits eSeGeCe, Support Premium inclus, à partir de €1,059/an.
Voir les tarifs All-Access

Inclus dans sgcWebSockets Enterprise

Inclus dans sgcWebSockets Enterprise (Delphi et .NET) et All-Access, ou dans le pack autonome sgcIndustrial.