PLCcom.Opc.Ua.Sdk 10.5.6

PLCcom.Opc.Ua.Sdk

A comprehensive .NET SDK for building OPC UA client and server applications. The SDK is delivered as a single assembly — no API calls or COM registration necessary. It runs cross-platform on .NET Framework 4.7.2+, .NET Standard 2.1, .NET 8, .NET 9, and .NET 10.

What PLCcom.Opc.Ua.Sdk has to offer

The PLCcom.Opc.Ua.Sdk is a highly optimized library for .NET developers that provides both a full OPC UA Client SDK and a full OPC UA Server SDK in a single assembly.

Key advantages:

• Easy to use — many operations require just a single line of code
• Path-based node addressing — access nodes by browse path instead of cryptic NodeIds (see below)
• Automatic connect, reconnect, and disconnect — no manual connection state management needed
• Active keep-alive monitoring of the server state
• opc.tcp and opc.https transport protocols supported

Supported OPC UA specifications:

• Data Access (read, write, browse, monitor)
• Alarm and Conditions
• Historical Data and Historical Events
• Complex / Structured Data Types
• Simple Events
• Reverse Connect

Path-based Node Addressing

A unique feature of PLCcom.Opc.Ua.Sdk is the ability to address nodes by their browse path — just like navigating a folder structure — instead of using numeric NodeIds:

// Resolve a node by path — no cryptic NodeId needed
NodeId nodeId = client.GetNodeIdByPath("Objects.Plant.Line1.Machine1.Temperature");

// Read a value
DataValue value = client.ReadValue(nodeId);

// Write a value
client.WriteValue(nodeId, 23.5);

' Resolve a node by path
Dim nodeId As NodeId = client.GetNodeIdByPath("Objects.Plant.Line1.Machine1.Temperature")

' Read a value
Dim value As DataValue = client.ReadValue(nodeId)

' Write a value
client.WriteValue(nodeId, 23.5)

This makes your code readable, maintainable, and independent of server-specific NodeId assignments. Classic NodeId-based access (ns=2;i=12345) is of course fully supported too.

OPC UA Client SDK

Getting started

1. Install the NuGet package

Install-Package PLCcom.Opc.Ua.Sdk

2. Import namespaces

using PLCcom.Opc.Ua;
using PLCcom.Opc.Ua.Client.Sdk;

3. Discover endpoints and connect

string LicenseUserName = "<Enter your UserName here>";
string LicenseSerial   = "<Enter your Serial here>";

// Discover available endpoints
EndpointDescriptionCollection endpoints = UaClient.GetEndpoints(
    new Uri("opc.tcp://localhost:48410"));

// Build a session configuration from the selected endpoint
SessionConfiguration sessionConfig = SessionConfiguration.Build(
    "MyApplication", endpoints[0]);

// Create the client
UaClient client = new UaClient(LicenseUserName, LicenseSerial, sessionConfig);

// Register events
client.ServerConnected      += (s, e) => Console.WriteLine("Connected");
client.ServerConnectionLost += (s, e) => Console.WriteLine("Connection lost");
client.CertificateValidation += (sender, e) => e.Accept = true;

// Connect (auto-reconnects on connection loss)
client.Connect();

Reading data

// Read a single value by path
DataValue value = client.ReadValue(
    client.GetNodeIdByPath("Objects.Plant.Machine1.Temperature"));

// Read multiple values in one call
ReadValueIdCollection nodesToRead = new ReadValueIdCollection
{
    new ReadValueId
    {
        NodeId      = client.GetNodeIdByPath("Objects.Plant.Machine1.Temperature"),
        AttributeId = Attributes.Value
    },
    new ReadValueId
    {
        NodeId      = client.GetNodeIdByPath("Objects.Plant.Machine1.RPM"),
        AttributeId = Attributes.Value
    }
};
DataValueCollection results = client.Read(nodesToRead);

Writing data

// Write a single value by path
client.WriteValue(client.GetNodeIdByPath("Objects.Plant.Machine1.Setpoint"), 42.0);

// Write multiple values in one call
WriteValueCollection nodesToWrite = new WriteValueCollection
{
    new WriteValue
    {
        NodeId      = client.GetNodeIdByPath("Objects.Plant.Machine1.Setpoint"),
        AttributeId = Attributes.Value,
        Value       = new DataValue(42.0)
    },
    new WriteValue
    {
        NodeId      = client.GetNodeIdByPath("Objects.Plant.Machine1.Running"),
        AttributeId = Attributes.Value,
        Value       = new DataValue(true)
    }
};
StatusCodeCollection writeResults = client.Write(nodesToWrite);

Subscribing to data changes

// Create a subscription
Subscription subscription = new Subscription
{
    PublishingInterval = 1000,
    DisplayName        = "MySubscription"
};
client.AddSubscription(subscription);

// Add a monitored item
NodeId nodeId = client.GetNodeIdByPath("Objects.Plant.Machine1.Temperature");
MonitoredItem monitoredItem = new MonitoredItem(subscription.DefaultItem)
{
    StartNodeId      = nodeId,
    SamplingInterval = 500,
    DisplayName      = "Temperature"
};
monitoredItem.Notification += (item, e) =>
{
    var notification = e.NotificationValue as MonitoredItemNotification;
    Console.WriteLine($"{item.DisplayName} = {notification.Value.Value}");
};

subscription.AddItem(monitoredItem);
subscription.ApplyChanges();
subscription.SetPublishingMode(true);
subscription.Modify();

OPC UA Server SDK

Getting started

1. Import the server namespace

using PLCcom.Opc.Ua.Server.Sdk;

2. Configure and start the server

string LicenseUserName = "<Enter your UserName here>";
string LicenseSerial   = "<Enter your Serial here>";

var config = new UaServerConfiguration
{
    ApplicationName = "My OPC UA Server",
    ApplicationUri  = "urn:mycompany:myserver",
    BaseAddresses   = new List<string>
    {
        "opc.tcp://localhost:48410",
        "opc.https://localhost:48411"
    },
    SecurityPolicies  = UaServer.GetRecommendedSecurityPolicies(),
    UserTokenPolicies = new List<UserTokenPolicy>
    {
        new UserTokenPolicy { TokenType = UserTokenType.Anonymous }
    }
};

using var server = new UaServer(LicenseUserName, LicenseSerial);
server.CertificateValidation += (sender, e) => e.Accept = true;
server.Start(config);

3. Build the address space

// Create a folder hierarchy
UaFolder plant   = server.CreateFolder("Plant", UaRolePermissions.WITHOUT_RESTRICTIONS);
UaFolder machine = server.CreateFolder(plant, "Machine1", UaRolePermissions.WITHOUT_RESTRICTIONS);

// Create typed variables — the generic parameter sets the OPC UA DataType
UaVariable<double> temperature = server.CreateVariable<double>(
    machine, "Temperature", UaRolePermissions.WITHOUT_RESTRICTIONS, initialValue: 20.0);
UaVariable<int>    rpm         = server.CreateVariable<int>(
    machine, "RPM", UaRolePermissions.WITHOUT_RESTRICTIONS, initialValue: 1500);
UaVariable<bool>   running     = server.CreateVariable<bool>(
    machine, "Running", UaRolePermissions.WITHOUT_RESTRICTIONS, initialValue: true);

// Push value changes — subscribed clients are notified automatically
temperature.Value = 23.5;

4. Add methods

server.CreateMethod(machine, "Reset",
    handler: (session, context, objectId, inputArgs, outputArgs) =>
    {
        temperature.Value = 0.0;
        rpm.Value         = 0;
        running.Value     = false;
        return ServiceResult.Good;
    },
    UaRolePermissions.WITHOUT_RESTRICTIONS);

5. User authentication with roles

// Disable anonymous access and add named users
config.UserTokenPolicies = new List<UserTokenPolicy>
{
    new UserTokenPolicy { TokenType = UserTokenType.UserName }
};

server.AddUser("operator", "secret123", Role.Operator);  // read + write
server.AddUser("admin",    "admin456",  Role.Engineer);  // full access

6. React to client writes

server.ValuesWritten += (s, e) =>
{
    foreach (var item in e.Items)
        Console.WriteLine($"Client wrote: {item.Path} = {item.Value}");
};

Server SDK features

• Folders, Variables (scalar + array), Objects, Methods
• Custom ObjectTypes, VariableTypes and structured DataTypes (Structs)
• NodeSet2 XML import (OPC UA companion specifications)
• Alarm & Conditions (AlarmCondition, ExclusiveLimitAlarm, DiscreteAlarm, Dialog)
• Historical Data Access and Historical Events
• Simple Events
• Reverse Connect (server-initiated connections through firewalls)
• User authentication with roles (Observer, Operator, Engineer)
• Custom credential and permission validators
• Multiple namespaces
• Configurable security policies and endpoint host normalization
• Integrated logging via LogMessage event

System Requirements

Supported platforms:

• Microsoft .NET Framework 4.7.2 or higher (up to 4.8.1)
• Microsoft .NET 5.0 to 7.0 via .NET Standard 2.1
• Microsoft .NET 8.0
• Microsoft .NET 9.0
• Microsoft .NET 10.0

To build and run the included examples:

• Visual Studio 2022 or higher (VS2026 recommended)

Additional Documentation

Online class reference: https://docs.plccom.net/help_opc_ua_sdk/net/help/html/R_Project_PLCcom_Opc_Ua_Sdk_Documentation.htm

Quick-start examples on GitHub: https://github.com/indi-an-gmbh/PLCcom-OpcUaSdk-examples-dotnet

Feedback

To provide feedback or report issues, please write to: support@indi-an.com