Client OPC UA

Connetti applicazioni Delphi, C++Builder e .NET a PLC, sistemi SCADA e gateway che eseguono un server OPC UA: esplora lo spazio degli indirizzi, leggi e scrivi variabili, chiama metodi e sottoscrivi variazioni di dati ed eventi su una connessione opc.tcp firmata e cifrata.

Novità

TsgcOPCUAClient

Un unico componente per tutto il lato client di OPC UA: canale sicuro, sessione, servizi e sottoscrizioni.

Classe del componente

TsgcOPCUAClient

Protocollo

OPC UA binary su opc.tcp (UA TCP, UA Secure Conversation, codifica UA Binary)

Sicurezza

Sign e SignAndEncrypt con Basic256Sha256, Aes128_Sha256_RsaOaep e Aes256_Sha256_RsaPss; identità Anonymous, nome utente e X.509

Edizione

Incluso in sgcWebSockets Enterprise (Delphi e .NET) e All-Access, oppure nel pacchetto standalone sgcIndustrial

Connetti, leggi e scrivi

Imposta EndpointUrl, scegli la policy e la modalità di sicurezza e chiama Connect. Ogni chiamata di servizio si blocca finché il server risponde e solleva EsgcOPCUAError, con il codice di stato OPC UA, quando fallisce.

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

Cosa c'è all'interno

Il canale sicuro, la sessione e il ciclo di pubblicazione sono gestiti dal componente, così il tuo codice lavora con node id e valori.

Servizi

GetEndpoints, Browse e BrowseNext (i continuation point vengono seguiti per te), TranslateBrowsePath, Read e Write di qualsiasi attributo, e Call per i metodi. ReadValue e WriteValue accettano una stringa node id e usano il tipo di dati del nodo.

Policy di sicurezza

Basic256Sha256, Aes128_Sha256_RsaOaep e Aes256_Sha256_RsaPss, più le deprecate Basic128Rsa15 e Basic256 per i server meno recenti, in modalità Sign o SignAndEncrypt. Il client controlla la firma e il nonce del server e rifiuta un elenco di endpoint modificato lungo il percorso.

Identità utente

Anonymous, nome utente e password (cifrati con la chiave del server quando la token policy lo richiede) o un certificato utente X.509 firmato con la tua chiave privata.

Certificati

Il certificato dell'istanza dell'applicazione viene caricato da file DER o PEM, creato alla prima connessione e salvato in quei file, oppure creato in memoria quando non è impostato alcun file. Un certificato del server viene rifiutato a meno che OnValidateServerCertificate lo accetti.

Sottoscrizioni

Elementi di variazione dati con intervallo di campionamento, dimensione della coda, deadband assoluta o percentuale e trigger; elementi evento con select clause e una where clause opzionale. Gli acknowledgement e la ripubblicazione delle notifiche mancanti sono gestiti dal client.

Riconnessione automatica

WatchDog si riconnette dopo una caduta di rete, in Delphi, C++Builder e .NET: riattiva la stessa sessione e ripubblica ciò che è stato perso, oppure trasferisce o ricrea le sottoscrizioni in una nuova sessione. OnReconnect indica quale percorso è stato seguito.

Variazioni di dati ed eventi, inviati dal server

Crea una sottoscrizione, aggiungi gli elementi da monitorare e gestisci OnDataChange. I valori arrivano senza polling, all'intervallo di pubblicazione che scegli.

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

Connessioni firmate e cifrate

Scegli la policy e la modalità, fornisci al client il suo certificato applicativo e un'identità utente, e decidi di quali certificati server ti fidi.

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

Specifiche e riferimenti

Fonti autorevoli per il protocollo implementato da questo componente.

Domande sul client OPC UA

A qualsiasi server OPC UA con un endpoint opc.tcp: PLC e controllori con server integrato, sistemi SCADA e MES e gateway di protocollo. Il client è testato con un server di riferimento basato su asyncua, uno stack OPC UA open source indipendente, su tutti i suoi undici endpoint.

Esplora dalla cartella Objects (i=85) con Browse, oppure risolvi un percorso come /2:Line1/2:Speed con TranslateBrowsePath. I node id si scrivono come testo: ns=2;s=Line1.Speed per un id stringa, i=2258 per un id numerico nel namespace 0.

Il valore predefinito è opcspNone, che la maggior parte dei server consente solo per i test. Imposta SecurityPolicy e SecurityMode per firmare o cifrare. I certificati del server vengono rifiutati a meno che OnValidateServerCertificate li accetti, e Basic128Rsa15 e Basic256 sono deprecati e mantenuti solo per i server meno recenti.

Sì, imposta WatchDog.Enabled: il client riattiva la sessione e ripubblica le notifiche perse, oppure apre una nuova sessione e trasferisce o ricrea le sottoscrizioni. Funziona allo stesso modo in Delphi, C++Builder e .NET, e OnReconnect indica quale percorso è stato seguito.

Il componente è un client OPC UA su opc.tcp con codifica binaria. Non include un server OPC UA, i trasporti HTTPS, JSON e WebSocket, HistoryRead, PubSub, Reverse Connect e il Global Discovery Server.

È incluso in sgcWebSockets Enterprise (Delphi e .NET) e All-Access, come parte del pacchetto sgcIndustrial. In Delphi, aggiungi sgcIndustrial alla clausola uses.

Documentazione e demo

Link diretti al riferimento del componente, apri il progetto demo e leggi il documento tecnico.

Online Help: TsgcOPCUAClient Riferimento completo di proprietà, metodi ed eventi del client OPC UA.
Online Help: OPC UA Subscriptions Monitored item, deadband, filtri evento, keep-alive e comportamento di riconnessione.
Progetto demo: Industrial\05.OPCUA_Client Un client OPC UA per Delphi, C++Builder e .NET. È incluso nel pacchetto sgcWebSockets.
Documento tecnico (PDF) Funzionalità, guida rapida, esempi di codice e riferimenti a fonti primarie solo per questo componente.
Manuale utente (PDF) Manuale completo che copre ogni componente della libreria.
La scelta più conveniente: All-AccessTutti i prodotti eSeGeCe, con Supporto Premium incluso, a partire da €1,059/anno.
Vedi i prezzi All-Access

Incluso in sgcWebSockets Enterprise

Incluso in sgcWebSockets Enterprise (Delphi e .NET) e All-Access, oppure nel pacchetto standalone sgcIndustrial.