Cliente OPC UA

Conecta aplicaciones Delphi, C++Builder y .NET con PLC, sistemas SCADA y pasarelas que ejecutan un servidor OPC UA: explora el espacio de direcciones, lee y escribe variables, llama a métodos y suscríbete a cambios de datos y eventos por una conexión opc.tcp firmada y cifrada.

Novedad

TsgcOPCUAClient

Un componente para todo el lado cliente de OPC UA: canal seguro, sesión, servicios y suscripciones.

Clase de componente

TsgcOPCUAClient

Protocolo

OPC UA binary sobre opc.tcp (UA TCP, UA Secure Conversation, codificación UA Binary)

Seguridad

Sign y SignAndEncrypt con Basic256Sha256, Aes128_Sha256_RsaOaep y Aes256_Sha256_RsaPss; identidades anónima, de usuario y X.509

Edición

Incluido en sgcWebSockets Enterprise (Delphi y .NET) y All-Access, o en el pack independiente sgcIndustrial

Conecta, lee y escribe

Indica EndpointUrl, elige la política y el modo de seguridad y llama a Connect. Cada llamada a un servicio se bloquea hasta que el servidor responde y lanza EsgcOPCUAError, con el código de estado OPC UA, cuando falla.

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

Qué incluye

El canal seguro, la sesión y el bucle de publicación los gestiona el componente, así que tu código trabaja con identificadores de nodo y valores.

Servicios

GetEndpoints, Browse y BrowseNext (los puntos de continuación se siguen por ti), TranslateBrowsePath, Read y Write de cualquier atributo, y Call para métodos. ReadValue y WriteValue toman una cadena con el identificador de nodo y usan el tipo de datos del nodo.

Políticas de seguridad

Basic256Sha256, Aes128_Sha256_RsaOaep y Aes256_Sha256_RsaPss, además de las obsoletas Basic128Rsa15 y Basic256 para servidores antiguos, en modo Sign o SignAndEncrypt. El cliente comprueba la firma y el nonce del servidor y rechaza una lista de endpoints que se haya modificado por el camino.

Identidad de usuario

Anónima, nombre de usuario y contraseña (cifrada con la clave del servidor cuando la política del token lo pide) o un certificado de usuario X.509 firmado con tu clave privada.

Certificados

El certificado de instancia de la aplicación se carga desde archivos DER o PEM, se crea en la primera conexión y se guarda en esos archivos, o se crea en memoria cuando no se indica ningún archivo. Un certificado de servidor se rechaza a menos que OnValidateServerCertificate lo acepte.

Suscripciones

Elementos de cambio de datos con intervalo de muestreo, tamaño de cola, banda muerta absoluta o porcentual y disparador; elementos de evento con cláusulas select y una cláusula where opcional. El cliente se encarga de los acuses de recibo y de la republicación de las notificaciones perdidas.

Reconexión automática

WatchDog reconecta tras una caída de red, en Delphi, C++Builder y .NET: reactiva la misma sesión y republica lo que se perdió, o transfiere o recrea las suscripciones en una sesión nueva. OnReconnect indica qué camino se siguió.

Cambios de datos y eventos, enviados por el servidor

Crea una suscripción, añade los elementos que quieres monitorizar y gestiona OnDataChange. Los valores llegan sin sondeo, con el intervalo de publicación que elijas.

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

Conexiones firmadas y cifradas

Elige la política y el modo, dale al cliente su certificado de aplicación y una identidad de usuario, y decide en qué certificados de servidor confías.

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

Especificaciones y referencias

Fuentes autorizadas del protocolo que implementa este componente.

Preguntas sobre el cliente OPC UA

A cualquier servidor OPC UA con un endpoint opc.tcp: PLC y controladores con servidor integrado, sistemas SCADA y MES y pasarelas de protocolos. El cliente se prueba contra un servidor de referencia basado en asyncua, una pila OPC UA de código abierto independiente, en sus once endpoints.

Explora desde la carpeta Objects (i=85) con Browse, o resuelve una ruta como /2:Line1/2:Speed con TranslateBrowsePath. Los identificadores de nodo se escriben como texto: ns=2;s=Line1.Speed para un identificador de cadena, i=2258 para un identificador numérico en el espacio de nombres 0.

El valor por defecto es opcspNone, que la mayoría de los servidores solo permiten para pruebas. Indica SecurityPolicy y SecurityMode para firmar o cifrar. Los certificados de servidor se rechazan a menos que OnValidateServerCertificate los acepte, y Basic128Rsa15 y Basic256 están obsoletas y se mantienen solo para servidores antiguos.

Sí, activa WatchDog.Enabled: el cliente reactiva la sesión y republica las notificaciones perdidas, o abre una sesión nueva y transfiere o recrea las suscripciones. Funciona igual en Delphi, C++Builder y .NET, y OnReconnect indica qué camino se siguió.

El componente es un cliente OPC UA sobre opc.tcp con la codificación binaria. No incluye un servidor OPC UA, los transportes HTTPS, JSON y WebSocket, HistoryRead, PubSub, Reverse Connect ni el Global Discovery Server.

Está incluido en sgcWebSockets Enterprise (Delphi y .NET) y All-Access, como parte del paquete sgcIndustrial. En Delphi, añade sgcIndustrial a la cláusula uses.

Documentación y demos

Enlace directo a la referencia del componente, abre el proyecto de demostración y lee el documento técnico.

Online Help: TsgcOPCUAClient Referencia completa de propiedades, métodos y eventos del cliente OPC UA.
Online Help: OPC UA Subscriptions Elementos monitorizados, bandas muertas, filtros de eventos, keep-alive y comportamiento de reconexión.
Proyecto de demostración: Industrial\05.OPCUA_Client Un cliente OPC UA para Delphi, C++Builder y .NET. Se incluye dentro del paquete sgcWebSockets.
Documento técnico (PDF) Características, inicio rápido, ejemplos de código y referencias de fuentes primarias solo para este componente.
Manual de usuario (PDF) Manual completo que cubre cada componente de la biblioteca.
La mejor opción: All-AccessTodos los productos de eSeGeCe, con Premium Support incluido, desde €1,059 al año.
Ver precios de All-Access

Incluido en sgcWebSockets Enterprise

Incluido en sgcWebSockets Enterprise (Delphi y .NET) y All-Access, o en el pack independiente sgcIndustrial.