OPC UA Client

Verbinde Delphi, C++Builder und .NET Anwendungen mit SPS-Steuerungen, SCADA-Systemen und Gateways, die einen OPC UA Server betreiben: Durchsuche den Adressraum, lies und schreibe Variablen, rufe Methoden auf und abonniere Datenänderungen und Ereignisse über eine signierte und verschlüsselte opc.tcp-Verbindung.

Neu

TsgcOPCUAClient

Eine Komponente für die gesamte Client-Seite von OPC UA: Secure Channel, Session, Services und Subscriptions.

Komponentenklasse

TsgcOPCUAClient

Protokoll

OPC UA Binary über opc.tcp (UA TCP, UA Secure Conversation, UA Binary Encoding)

Sicherheit

Sign und SignAndEncrypt mit Basic256Sha256, Aes128_Sha256_RsaOaep und Aes256_Sha256_RsaPss; Identitäten Anonymous, Benutzername und X.509

Edition

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

Verbinden, lesen und schreiben

Setze EndpointUrl, wähle Sicherheitsrichtlinie und Modus und rufe Connect auf. Jeder Service-Aufruf blockiert, bis der Server antwortet, und löst bei einem Fehler EsgcOPCUAError mit dem OPC UA Statuscode aus.

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

Was steckt drin

Secure Channel, Session und Publish-Schleife übernimmt die Komponente, sodass dein Code mit Node-IDs und Werten arbeitet.

Services

GetEndpoints, Browse und BrowseNext (Continuation Points werden für dich verfolgt), TranslateBrowsePath, Read und Write jedes Attributs sowie Call für Methoden. ReadValue und WriteValue nehmen einen Node-ID-String entgegen und verwenden den Datentyp des Knotens.

Sicherheitsrichtlinien

Basic256Sha256, Aes128_Sha256_RsaOaep und Aes256_Sha256_RsaPss, dazu die veralteten Basic128Rsa15 und Basic256 für ältere Server, im Modus Sign oder SignAndEncrypt. Der Client prüft Signatur und Nonce des Servers und lehnt eine Endpunktliste ab, die unterwegs verändert wurde.

Benutzeridentität

Anonymous, Benutzername und Passwort (mit dem Serverschlüssel verschlüsselt, wenn die Token-Richtlinie es verlangt) oder ein X.509-Benutzerzertifikat, signiert mit deinem privaten Schlüssel.

Zertifikate

Das Anwendungsinstanz-Zertifikat wird aus DER- oder PEM-Dateien geladen, beim ersten Verbinden erstellt und in diesen Dateien gespeichert, oder im Speicher erstellt, wenn keine Datei gesetzt ist. Ein Serverzertifikat wird abgelehnt, sofern OnValidateServerCertificate es nicht akzeptiert.

Subscriptions

Data-Change-Items mit Sampling-Intervall, Queue-Größe, absoluter oder prozentualer Deadband und Trigger; Event-Items mit Select-Klauseln und optionaler Where-Klausel. Bestätigungen und das erneute Veröffentlichen fehlender Benachrichtigungen übernimmt der Client.

Automatische Wiederverbindung

WatchDog verbindet nach einem Netzwerkabbruch neu, in Delphi, C++Builder und .NET: Er reaktiviert dieselbe Session und veröffentlicht Verpasstes erneut, oder überträgt bzw. erstellt die Subscriptions in einer neuen Session neu. OnReconnect zeigt, welcher Weg genommen wurde.

Datenänderungen und Ereignisse, vom Server gesendet

Erstelle eine Subscription, füge die zu überwachenden Items hinzu und behandle OnDataChange. Die Werte treffen ohne Polling ein, im Publishing-Intervall deiner Wahl.

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

Signierte und verschlüsselte Verbindungen

Wähle Richtlinie und Modus, gib dem Client sein Anwendungszertifikat und eine Benutzeridentität und entscheide, welchen Serverzertifikaten du vertraust.

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

Spezifikationen & Referenzen

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

Fragen zum OPC UA Client

Mit jedem OPC UA Server mit opc.tcp-Endpunkt: SPS-Steuerungen und Controller mit eingebautem Server, SCADA- und MES-Systeme und Protokoll-Gateways. Der Client ist gegen einen Referenzserver auf Basis von asyncua getestet, einem unabhängigen Open-Source-OPC-UA-Stack, an allen elf seiner Endpunkte.

Durchsuche mit Browse den Ordner Objects (i=85) oder löse mit TranslateBrowsePath einen Pfad wie /2:Line1/2:Speed auf. Node-IDs werden als Text geschrieben: ns=2;s=Line1.Speed für eine String-ID, i=2258 für eine numerische ID im Namespace 0.

Der Standard ist opcspNone, den die meisten Server nur zum Testen erlauben. Setze SecurityPolicy und SecurityMode, um zu signieren oder zu verschlüsseln. Serverzertifikate werden abgelehnt, sofern OnValidateServerCertificate sie nicht akzeptiert, und Basic128Rsa15 und Basic256 sind veraltet und nur für ältere Server erhalten.

Ja, setze WatchDog.Enabled: Der Client reaktiviert die Session und veröffentlicht die verpassten Benachrichtigungen erneut, oder öffnet eine neue Session und überträgt bzw. erstellt die Subscriptions neu. Es funktioniert in Delphi, C++Builder und .NET gleich, und OnReconnect zeigt, welcher Weg genommen wurde.

Die Komponente ist ein OPC UA Client über opc.tcp mit der Binärcodierung. Sie enthält keinen OPC UA Server, keine Transporte über HTTPS, JSON und WebSocket, kein HistoryRead, kein PubSub, kein Reverse Connect und keinen Global Discovery Server.

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: TsgcOPCUAClient Vollständige Referenz zu Eigenschaften, Methoden und Ereignissen des OPC UA Clients.
Online Help: OPC UA Subscriptions Monitored Items, Deadbands, Event-Filter, Keep-Alive und Verhalten bei der Wiederverbindung.
Demoprojekt: Industrial\05.OPCUA_Client Ein OPC UA 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.