Client OPC UA

Connecte tes applications Delphi, C++Builder et .NET aux PLC, aux systèmes SCADA et aux passerelles qui exécutent un serveur OPC UA : parcours l'espace d'adressage, lis et écris des variables, appelle des méthodes et abonne-toi aux changements de données et aux événements via une connexion opc.tcp signée et chiffrée.

Nouveau

TsgcOPCUAClient

Un seul composant pour tout le côté client d'OPC UA : canal sécurisé, session, services et abonnements.

Classe de composant

TsgcOPCUAClient

Protocole

OPC UA binary over opc.tcp (UA TCP, UA Secure Conversation, encodage UA Binary)

Sécurité

Sign et SignAndEncrypt avec Basic256Sha256, Aes128_Sha256_RsaOaep et Aes256_Sha256_RsaPss ; identités Anonymous, nom d'utilisateur et X.509

Édition

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

Se connecter, lire et écrire

Indique EndpointUrl, choisis la security policy et le mode, puis appelle Connect. Chaque appel de service bloque jusqu'à la réponse du serveur et lève EsgcOPCUAError, avec le code d'état OPC UA, en cas d'échec.

uses
  sgcIndustrial;

procedure TForm1.ConnectAndRead;
begin
  FClient := TsgcOPCUAClient.Create(Self);
  FClient.EndpointUrl := 'opc.tcp://192.168.1.60:4840';
  FClient.SecurityPolicy := opcspNone;
  FClient.SecurityMode := opcsmNone;
  FClient.OnError := OnOPCUAError;
  FClient.Connect;
  // read the Value attribute of a variable
  Memo1.Lines.Add('Temperature: ' + VarToStr(FClient.ReadValue('ns=2;s=Line1.Temperature')));
  // the data type of the node is read first and used for the written value
  FClient.WriteValue('ns=2;s=Line1.Setpoint', 75.5);
end;

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

void __fastcall TForm1::ConnectAndRead()
{
  FClient = new TsgcOPCUAClient(this);
  FClient->EndpointUrl = "opc.tcp://192.168.1.60:4840";
  FClient->SecurityPolicy = opcspNone;
  FClient->SecurityMode = opcsmNone;
  FClient->OnError = OnOPCUAError;
  FClient->Connect();
  // read the Value attribute of a variable
  Memo1->Lines->Add("Temperature: " + VarToStr(FClient->ReadValue("ns=2;s=Line1.Temperature")));
  // the data type of the node is read first and used for the written value
  FClient->WriteValue("ns=2;s=Line1.Setpoint", 75.5);
}

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

class PlantReader
{
    TsgcOPCUAClient FClient = new TsgcOPCUAClient();

    public void ConnectAndRead()
    {
        FClient.EndpointUrl = "opc.tcp://192.168.1.60:4840";
        FClient.SecurityPolicy = TsgcOPCUASecurityPolicy.opcspNone;
        FClient.SecurityMode = TsgcOPCUAMessageSecurityMode.opcsmNone;
        FClient.OnError += OnOPCUAError;
        FClient.Connect();
        // read the Value attribute of a variable
        Console.WriteLine("Temperature: " + FClient.ReadValue("ns=2;s=Line1.Temperature"));
        // the data type of the node is read first and used for the written value
        FClient.WriteValue("ns=2;s=Line1.Setpoint", 75.5);
    }

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

Sous le capot

Le canal sécurisé, la session et la boucle de publication sont gérés par le composant, ton code travaille donc avec des node ids et des valeurs.

Services

GetEndpoints, Browse et BrowseNext (les points de continuation sont suivis pour toi), TranslateBrowsePath, Read et Write de n'importe quel attribut, et Call pour les méthodes. ReadValue et WriteValue prennent un node id sous forme de chaîne et utilisent le type de données du nœud.

Security policies

Basic256Sha256, Aes128_Sha256_RsaOaep et Aes256_Sha256_RsaPss, ainsi que Basic128Rsa15 et Basic256, dépréciés, pour les serveurs plus anciens, en mode Sign ou SignAndEncrypt. Le client vérifie la signature et le nonce du serveur et rejette une liste d'endpoints modifiée en chemin.

Identité de l'utilisateur

Anonymous, nom d'utilisateur et mot de passe (chiffrés avec la clé du serveur lorsque la token policy le demande) ou certificat utilisateur X.509 signé avec ta clé privée.

Certificats

Le certificat d'instance d'application est chargé depuis des fichiers DER ou PEM, créé à la première connexion et enregistré dans ces fichiers, ou créé en mémoire lorsqu'aucun fichier n'est indiqué. Un certificat de serveur est rejeté sauf si OnValidateServerCertificate l'accepte.

Abonnements

Éléments de changement de données avec intervalle d'échantillonnage, taille de file, deadband absolue ou en pourcentage et déclencheur ; éléments d'événement avec clauses select et clause where facultative. Les acquittements et la republication des notifications manquantes sont assurés par le client.

Reconnexion automatique

WatchDog se reconnecte après une coupure réseau, en Delphi, C++Builder et .NET : il réactive la même session et republie ce qui a été manqué, ou transfère ou recrée les abonnements dans une nouvelle session. OnReconnect indique le chemin qui a été pris.

Changements de données et événements, poussés par le serveur

Crée un abonnement, ajoute les éléments à surveiller et gère OnDataChange. Les valeurs arrivent sans interrogation périodique, à l'intervalle de publication que tu choisis.

procedure TForm1.Subscribe;
var
  oSubscription: TsgcOPCUASubscription;
begin
  FClient.OnDataChange := OnOPCUADataChange;
  // publishing interval 500 ms
  oSubscription := FClient.CreateSubscription(500);
  // sampling 250 ms, queue of 1, report changes larger than 0.5 only
  FClient.AddMonitoredItem(oSubscription, 'ns=2;s=Line1.Temperature', 250, 1, True,
    uadbtAbsolute, 0.5);
  FClient.AddMonitoredItem(oSubscription, 'ns=2;s=Line1.Pressure');
end;

procedure TForm1.OnOPCUADataChange(Sender: TObject; aSubscription: TsgcOPCUASubscription;
  aMonitoredItem: TsgcOPCUAMonitoredItem; const aValue: TsgcOPCUADataValue);
begin
  if (aValue.StatusCode and $80000000) = 0 then
    Memo1.Lines.Add('Item ' + IntToStr(aMonitoredItem.ClientHandle) + ': ' +
      VarToStr(aValue.Value.Value));
end;
void __fastcall TForm1::Subscribe()
{
  FClient->OnDataChange = OnOPCUADataChange;
  // publishing interval 500 ms
  TsgcOPCUASubscription *oSubscription = FClient->CreateSubscription(500);
  // sampling 250 ms, queue of 1, report changes larger than 0.5 only
  FClient->AddMonitoredItem(oSubscription, "ns=2;s=Line1.Temperature", 250, 1, true,
    uadbtAbsolute, 0.5);
  FClient->AddMonitoredItem(oSubscription, "ns=2;s=Line1.Pressure");
}

void __fastcall TForm1::OnOPCUADataChange(TObject *Sender, TsgcOPCUASubscription *aSubscription,
  TsgcOPCUAMonitoredItem *aMonitoredItem, const TsgcOPCUADataValue &aValue)
{
  if ((aValue.StatusCode & 0x80000000) == 0)
    Memo1->Lines->Add("Item " + IntToStr((int)aMonitoredItem->ClientHandle) + ": " +
      VarToStr(aValue.Value.Value));
}
using System;
using esegece.sgcWebSockets;

class PlantMonitor
{
    public void Subscribe(TsgcOPCUAClient aClient)
    {
        aClient.OnDataChange += OnOPCUADataChange;
        // publishing interval 500 ms
        TsgcOPCUASubscription oSubscription = aClient.CreateSubscription(500);
        // sampling 250 ms, queue of 1, report changes larger than 0.5 only
        aClient.AddMonitoredItem(oSubscription, "ns=2;s=Line1.Temperature", 250, 1, true,
            TsgcOPCUADeadbandType.uadbtAbsolute, 0.5);
        aClient.AddMonitoredItem(oSubscription, "ns=2;s=Line1.Pressure");
    }

    void OnOPCUADataChange(object Sender, TsgcOPCUASubscription aSubscription,
        TsgcOPCUAMonitoredItem aMonitoredItem, TsgcOPCUADataValue aValue)
    {
        if ((aValue.StatusCode & 0x80000000) == 0)
            Console.WriteLine("Item " + aMonitoredItem.ClientHandle + ": " + aValue.Value.Value);
    }
}

Connexions signées et chiffrées

Choisis la policy et le mode, donne au client son certificat d'application et une identité utilisateur, et décide quels certificats de serveur tu acceptes.

uses
  sgcIndustrial; // Delphi 7 to 2006: add sgcBase_Helpers (TBytes)

procedure TForm1.ConnectSecure;
begin
  FClient := TsgcOPCUAClient.Create(Self);
  FClient.EndpointUrl := 'opc.tcp://192.168.1.60:4840';
  FClient.SecurityPolicy := opcspBasic256Sha256;
  FClient.SecurityMode := opcsmSignAndEncrypt;
  // application instance certificate: created and saved on the first run
  FClient.Application.ApplicationName := 'Line1 Monitor';
  FClient.Application.CertificateFile := 'C:\pki\own\client.der';
  FClient.Application.PrivateKeyFile := 'C:\pki\own\client.pem';
  // user identity
  FClient.Authentication.AuthenticationType := opcatUserName;
  FClient.Authentication.User := 'operator';
  FClient.Authentication.Password := 'secret';
  // decide which server certificates you trust
  FClient.OnValidateServerCertificate := OnOPCUAValidateServerCertificate;
  FClient.Connect;
end;

procedure TForm1.OnOPCUAValidateServerCertificate(Sender: TObject;
  const aCertificate: TBytes; var aAccept: Boolean);
begin
  // FTrusted holds the DER bytes of the server certificate you trust
  aAccept := (Length(aCertificate) > 0) and (Length(aCertificate) = Length(FTrusted)) and
    CompareMem(@aCertificate[0], @FTrusted[0], Length(aCertificate));
end;
void __fastcall TForm1::ConnectSecure()
{
  FClient = new TsgcOPCUAClient(this);
  FClient->EndpointUrl = "opc.tcp://192.168.1.60:4840";
  FClient->SecurityPolicy = opcspBasic256Sha256;
  FClient->SecurityMode = opcsmSignAndEncrypt;
  // application instance certificate: created and saved on the first run
  FClient->Application->ApplicationName = "Line1 Monitor";
  FClient->Application->CertificateFile = "C:\\pki\\own\\client.der";
  FClient->Application->PrivateKeyFile = "C:\\pki\\own\\client.pem";
  // user identity
  FClient->Authentication->AuthenticationType = opcatUserName;
  FClient->Authentication->User = "operator";
  FClient->Authentication->Password = "secret";
  // decide which server certificates you trust
  FClient->OnValidateServerCertificate = OnOPCUAValidateServerCertificate;
  FClient->Connect();
}

void __fastcall TForm1::OnOPCUAValidateServerCertificate(TObject *Sender,
  const TBytes aCertificate, bool &aAccept)
{
  // FTrusted holds the DER bytes of the server certificate you trust
  aAccept = (aCertificate.Length > 0) && (aCertificate.Length == FTrusted.Length) &&
    CompareMem((void*)&aCertificate[0], &FTrusted[0], aCertificate.Length);
}
using System.IO;
using System.Linq;
using esegece.sgcWebSockets;

class SecureClient
{
    TsgcOPCUAClient FClient = new TsgcOPCUAClient();
    // DER bytes of the server certificate you trust
    byte[] FTrusted = File.ReadAllBytes(@"C:\pki\trusted\server.der");

    public void ConnectSecure()
    {
        FClient.EndpointUrl = "opc.tcp://192.168.1.60:4840";
        FClient.SecurityPolicy = TsgcOPCUASecurityPolicy.opcspBasic256Sha256;
        FClient.SecurityMode = TsgcOPCUAMessageSecurityMode.opcsmSignAndEncrypt;
        // application instance certificate: created and saved on the first run
        FClient.Application.ApplicationName = "Line1 Monitor";
        FClient.Application.CertificateFile = @"C:\pki\own\client.der";
        FClient.Application.PrivateKeyFile = @"C:\pki\own\client.pem";
        // user identity
        FClient.Authentication.AuthenticationType = TsgcOPCUAAuthenticationType.opcatUserName;
        FClient.Authentication.User = "operator";
        FClient.Authentication.Password = "secret";
        // decide which server certificates you trust
        FClient.OnValidateServerCertificate += OnOPCUAValidateServerCertificate;
        FClient.Connect();
    }

    void OnOPCUAValidateServerCertificate(object Sender, byte[] aCertificate, ref bool aAccept)
    {
        aAccept = aCertificate != null && aCertificate.SequenceEqual(FTrusted);
    }
}

Spécifications et références

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

Questions sur le client OPC UA

À tout serveur OPC UA disposant d'un endpoint opc.tcp : PLC et contrôleurs avec serveur intégré, systèmes SCADA et MES, et passerelles de protocoles. Le client est testé contre un serveur de référence construit sur asyncua, une pile OPC UA open source indépendante, sur ses onze endpoints.

Parcours depuis le dossier Objects (i=85) avec Browse, ou résous un chemin comme /2:Line1/2:Speed avec TranslateBrowsePath. Les node ids s'écrivent sous forme de texte : ns=2;s=Line1.Speed pour un identifiant chaîne, i=2258 pour un identifiant numérique dans l'espace de noms 0.

La valeur par défaut est opcspNone, que la plupart des serveurs n'autorisent que pour les tests. Mets SecurityPolicy et SecurityMode pour signer ou chiffrer. Les certificats de serveur sont rejetés sauf si OnValidateServerCertificate les accepte, et Basic128Rsa15 et Basic256 sont dépréciés et conservés uniquement pour les serveurs plus anciens.

Oui, active WatchDog.Enabled : le client réactive la session et republie les notifications manquées, ou ouvre une nouvelle session et transfère ou recrée les abonnements. Cela fonctionne de la même façon en Delphi, C++Builder et .NET, et OnReconnect indique le chemin qui a été pris.

Le composant est un client OPC UA via opc.tcp avec l'encodage binaire. Il n'inclut pas de serveur OPC UA, ni les transports HTTPS, JSON et WebSocket, HistoryRead, PubSub, Reverse Connect et le Global Discovery Server.

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: TsgcOPCUAClient Référence complète des propriétés, méthodes et événements du client OPC UA.
Online Help: OPC UA Subscriptions Éléments surveillés, deadbands, filtres d'événements, keep-alive et comportement de reconnexion.
Projet de démo : Industrial\05.OPCUA_Client Un client OPC UA 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.