PLCcom Opc Ua Sdk

Das PLCcom.Opc.Ua.Sdk ist eine speziell für .NET- oder Java- Softwareentwickler (je nach Version) bereitgestellte hoch optimierte und moderne Komponente, um Softwareentwicklern komfortabel Zugriff auf eine clientseitige OPC-UA-Schnittstelle zur Verfügung zu stellen, z.B. um Daten auszulesen oder zu schreiben.

Innovativ und schnell einsetzbar

Mit dem PLCcom.Opc.Ua.Sdk wird Ihnen ein Werkzeug für einfachste und schnelle Implementierung von OPC UA Clientfunktionalitäten in Ihre eigenen Anwendungen zur Verfügung gestellt.
Verbinden Sie Ihre Applikation schnell und einfach mit einem oder mehreren OPC-UA-Servern und Lesen, Schreiben oder Überwachen Sie dessen Daten.
Mit dem PLCcom.Opc.Ua.Sdk machen Sie Ihre Anwendungen fit für Anforderungen von Industrie 4.0.

PLCcom.Opc.Ua.Sdk wird in zwei Versionen zur Verfügung gestellt:

  1. Net Version
    Die .Net-Version unterstützt die klassische .Net Framework-Programmierung.
    Des Weiteren enthält das Auslieferungspaket eine Version für .Net-Standard Version 2.1 und eine Version für .Net 5.0
    Diese Komponente kann zur Entwicklung von .Net-Core-, Xamarin-, UWP– oder Unity– Applikationen eingesetzt werden.
    Zusätzlich wird über nuget.org ein nuget-Paket zur Verfügung gestellt.
  2. Java-Version
    Die Java-Version bietet Entwicklern eine Java-Komponente zur Java-Applikationsentwicklung z.B. mit Eclipse- oder Netbeans.
    Seit Version 9 wird zusätzlich auch die Entwicklung von Android-Apps unterstützt.

Nachfolgend einige einfache Code-Beispiele (weitere Beispiele):

//discovery endpoints
EndpointDescriptionCollection ep = UaClient.GetEndpoints(new Uri("opc.tcp://localhost:4048"));

'discovery endpoints
Dim ep As EndpointDescriptionCollection = UaClient.GetEndpoints(New Uri("opc.tcp://localhost:4048"))

//discovery endpoints
EndpointDescription[] endpoints = UaClient.discoverEndpoints(Hostname, Port);

Beispiel: Abfragen von bestehenden Endpoints eines UA-Servers

//simple browse command example
//Set start NodeId by path
NodeId sourceNode = client.GetNodeIdByPath("Objects.Data.Dynamic.Scalar");
  
// find all of the components of the node.
BrowseDescription nodeToBrowse = new BrowseDescription();
  
nodeToBrowse.NodeId = sourceNode;
nodeToBrowse.BrowseDirection = BrowseDirection.Forward;
nodeToBrowse.ReferenceTypeId = ReferenceTypeIds.Aggregates;
nodeToBrowse.IncludeSubtypes = true;
nodeToBrowse.NodeClassMask = (uint)(NodeClass.Object | NodeClass.Variable);
nodeToBrowse.ResultMask = (uint)BrowseResultMask.All;
  
//now, browse the node
ReferenceDescriptionCollection rdc = client.BrowseFull(nodeToBrowse);

'simple browse command example
'Set start NodeId by path'
Dim sourceNode As NodeId = client.GetNodeIdByPath("Objects.Data.Dynamic.Scalar")
  
'find all of the components of the node. '
Dim nodeToBrowse As BrowseDescription = New BrowseDescription()
nodeToBrowse.NodeId = sourceNode
nodeToBrowse.BrowseDirection = BrowseDirection.Forward
nodeToBrowse.ReferenceTypeId = ReferenceTypeIds.Aggregates
nodeToBrowse.IncludeSubtypes = True
nodeToBrowse.NodeClassMask = CUInt(NodeClass.Object Or NodeClass.Variable)
nodeToBrowse.ResultMask = CUInt(BrowseResultMask.All)
 
//now, browse the node
Dim rdc As ReferenceDescriptionCollection = client.BrowseFull(nodeToBrowse)

//simple browse command example
//create a BrowseDescription object
BrowseDescription browseDescription = new BrowseDescription();
browseDescription.setReferenceTypeId(Identifiers.Aggregates);
browseDescription.setBrowseDirection(BrowseDirection.Forward);
browseDescription.setIncludeSubtypes(true);
browseDescription.setNodeClassMask(NodeClass.Object, NodeClass.Variable);
browseDescription.setResultMask(BrowseResultMask.All);
//set start nodeId
browseDescription1.setNodeId(myClient.getNodeIdByPath("Objects.Server"));
 
//create a BrowseRequest or browse the BrowseDescription direct
BrowseRequest browseRequest = new BrowseRequest(null, null, null,
                                new BrowseDescription[] { browseDescription });
 
//browse the node
BrowseResponse results = client.browse(browseRequest);

Beispiel: Browsen über Nodes

//read values from OPC UA Node into DataValue object
 DataValue value = client.ReadValue("Objects.Server.Data.Static.Scalar.Int64Value");

'reading values from OPC UA Node into DataValue object
 Dim value As DataValue = client.ReadValue("Objects.Server.Data.Static.Scalar.Int64Value")

//read values from OPC UA Node into DataValue object
ReadResponse res = client.read(myClient.getNodeIdByPath("Objects.Server.Data.Static.Scalar.Int16Value"),
                                    UaAttributes.Value);

Beispiel: Lesen von Werten

//write value 123 to OPC UA Node and receive the status code
 StatusCode sc = client.WriteValue("Objects.Server.Data.Static.Scalar.Int64Value",123);

'writing value 123 to OPC UA Node and receive the status code
 Dim sc As StatusCode = client.WriteValue("Objects.Server.Data.Static.Scalar.Int64Value", 123)

//write value 123 to OPC UA Node and receive the status code
StatusCode res = client.write(myClient.getNodeIdByPath("Objects.Server.Data.Static.Scalar.Int16Value"), 
                                (short) 123,
                                UaAttributes.Value);

Beispiel: Schreiben von Werten

...
//create a new subscription
Subscription subscription = new Subscription();
  
subscription.PublishingInterval = 1000;
subscription.DisplayName = "mySubsription";
  
//register subscription events
subscription.StateChanged += Subscription_StateChanged;
subscription.PublishStatusChanged += Subscription_PublishStatusChanged;
  
//add new subscription to client
client.AddSubscription(subscription);
  
//Create a monitoring item and add to the subscription
NodeId nodeId = client.GetNodeIdByPath("Objects.Data.Dynamic.Scalar.Int64Value");
MonitoredItem monitoredItem = new MonitoredItem(subscription.DefaultItem)
                           {
                               StartNodeId = nodeId,
                               SamplingInterval = 500,
                               QueueSize = UInt32.MaxValue,
                               DisplayName = nodeId.ToString()
                           };
  
//register monitoring event
monitoredItem.Notification += Client_MonitorNotification;
//add Item to subscription
subscription.AddItem(monitoredItem);
  
//apply changes
subscription.ApplyChanges();
  
...
 
 //catch the monitoring event
private void Client_MonitorNotification(MonitoredItem monitoredItem, MonitoredItemNotificationEventArgs e)
{
    // notifications coming here, do what you want
}

...
'create a new subscription'
Dim subscription As Subscription = New Subscription()
subscription.PublishingInterval = 1000
subscription.PublishingEnabled = False
subscription.DisplayName = "mySubsription"
  
'register subscription events'
AddHandler subscription.StateChanged, AddressOf Subscription_StateChanged
AddHandler subscription.PublishStatusChanged, AddressOf Subscription_PublishStatusChanged
  
'add new subscription to client'
client.AddSubscription(subscription)
  
'Create a monitoring item and add to the subscription'
Dim nodeId As NodeId = client.GetNodeIdByPath("Objects.Data.Dynamic.Scalar.Int64Value")
Dim monitoredItem As MonitoredItem = New MonitoredItem(subscription.DefaultItem) With {
                                    .StartNodeId = nodeId,
                                    .SamplingInterval = 500,
                                    .QueueSize = UInteger.MaxValue,
                                    .DisplayName = nodeId.ToString()
                                }
  
'register monitoring event'
AddHandler monitoredItem.Notification, AddressOf Client_MonitorNotification
  
'add Item to subscription'
subscription.AddItem(monitoredItem)
  
'apply changes'
subscription.ApplyChanges()
  
...
  
Private Sub Client_MonitorNotification(ByVal monitoredItem As MonitoredItem, ByVal e As MonitoredItemNotificationEventArgs)
    Dim notification As MonitoredItemNotification = TryCast(e.NotificationValue, MonitoredItemNotification)
    'notifications coming here, do what you want
End Sub

...
//create and register monitoring item
//step 1 create the request list
List requests = new ArrayList();
 
//step 2 create and add a create request for a monitoring item
ReadValueId readValueId = new ReadValueId(
                                myClient.getNodeIdByPath("Objects.Server.Data.Dynamic.Scalar.Int32Value"),
                                UaAttributes.Value.getValue(), null, null);
requests.add(new MonitoredItemCreateRequest(readValueId, MonitoringMode.Reporting, new MonitoringParameters()));
 
//step3 create and add a subscription
UaSubscription subscription = myClient.getSubscriptionManager().createSubscription();
                         
//final step create, monitoring items and add monitoring item event listener
List monitoredItems = subscription.createMonitoredItems(requests, new MonitoredItemNotificationListener() {
                         
    @Override
    public void onValueNotification(MonitoredItem monitoredItem, DataValue value) {
        // value notifications coming here, do what you want
                             
    }
                         
    @Override
    public void onEventNotification(MonitoredItem monitoredItem, EventFieldList eventFieldList) {
        // event notifications coming here, do what you want
                             
    }
});

Beispiel: Monitoring von Nodes

Tutorial, Testsoftware und Code-Beispiele

Mit im Lieferumfang enthalten sind umfangreiche Code-Beispiele und Tutorials, die die leichte Anbindung eines OPC-UA-Servers über eine OPC-UA-Schnittstelle an Ihre Applikation verdeutlichen und auch in Ihren Projekten genutzt werden können.

Features

  • einfaches Ansprechen der Nodes über BrowsenNames oder dem Pfad möglich z.B. „Objects.Server.Data.Static.Scalar.Int64Value“
  • automatisches Verbinden und Trennen von Verbindungen zum Server (auf Wunsch abschaltbar)
  • keine Einschränkungen von Anzahl Instanzen, Verbindungen oder Subscriptions
  • kompatibel zu den OPC-Ua-Spezifikationen
  • erweiterte Sicherheitsfeatures, gesicherte Verbindungen auch über Zertifikatsaustausch möglich
  • einfaches Erstellen und Einbinden eigener Zertifikate und eigener Zertifikatsvalidierungen
  • diverse nützliche, hilfreiche Erweiterungen und Funktionen, die dem Entwickler zur Verfügung gestellt werden
  • u.v.m.

Ideal für .Net- oder Java- Software-Entwickler

Bei der Komponente handelt es sich je nach Version um eine 100% .Net- oder Java-Library.
Das Sdk kann direkt in Ihre Dotnet- (c#, vb, etc.) oder Java-Umgebung als Verweis eingebunden werden, weitere externe API-Aufrufe sind nicht notwendig.
Es ist problemlos möglich, die Komponenten in 32-oder 64 Bit-Umgebungen einzusetzen.
Die internen Routinen sind für High-Performance-Zugriffe optimiert.

Einfaches Lizenzmodell, Top-Level-Support

PLCcom.Opc.Ua.Sdk wird pro Entwickler lizenziert, spätere Runtime-Lizenzen fallen nicht an. Probieren Sie das PLCcom.Opc.Ua.Sdk mit einer 30-tägigen Testversion in Ruhe aus, bevor Sie die Library lizenzieren.
Wir möchten, dass Sie mit unserem Produkt zufrieden sind, auch nach dem Kauf lassen wir Sie nicht alleine!
Sollten wider Erwarten Probleme oder Fragen im Zusammenhang mit unserem Produkt auftreten, stehen wir Ihnen unbürokratisch und zeitnah zur Verfügung und unterstützen Sie bei einer Problemlösung.

Indi.An ist langjähriges Mitglied der OPC-Foundation

Mit der OPC UA Spezifikation stellt die OPC-Foundation ein neuentwickeltes Kommunikationsmodell zum einheitlichen Transport von Maschinendaten zur Verfügung.
Ziel war es, das OPC- Kommunikationsmodell an die Erfordernisse zukünftiger Anwendungen anzupassen, und die bestehenden Nachteile der auf DCOM basierenden OPC-Schnittstelle auszugleichen. Das OPC UA Kommunikationsmodell ist eine komplette Neuentwicklung, unterscheidet sich erheblich von seinem Vorgänger und basiert auch nicht auf der DCOM-Schnittstelle.
Die erste Version der OPC UA Spezifikation wurde im Jahre 2006 zur Verfügung gestellt, eine Überarbeitung fand im Jahr 2009 statt.

Mit OPC UA wird ein zukunftsträchtiger einheitlicher Kommunikationsstandard bereitgestellt, der auch die Erfordernisse von Industrie 4.0 Anwendungen abdeckt.

Indi.An GmbH ist ein langjähriges Mitglied der OPC-Foundation.