Anleitung

Node-Typen

• ClientClient.MethodNode

  Findet die Methoden des Servers, zeigt ihre Argumente und ruft eine ausgewählte Methode mit eingegebenen Werten auf.

  C#VB.NET
• ClientClient.Methods

  Ruft Methoden des Servers auf, nacheinander und parallel, und misst die Dauer.

  C#VB.NET
• ClientClient.DataTypeNode

  Liest einen Node mit eigenem Aufzählungstyp, zeigt die möglichen Werte und schreibt einen neuen Wert.

  C#VB.NET
• ClientClient.AnalogItemNode

  Liest Analogwerte mit Einheit und Messbereich und gibt sie aus.

  C#VB.NET

Repository auf GitHub

git clone https://github.com/Traeger-GmbH/opcuanet-samples.git
cd opcuanet-samples
dotnet run --project cs/Nodes/Client.MethodNode -f net8.0
dotnet run --project cs/Basic/Client.Methods -f net8.0
dotnet run --project cs/Nodes/Client.DataTypeNode -f net8.0
dotnet run --project cs/Nodes/Client.AnalogItemNode -f net8.0

Methoden aufrufen

Beteiligte TypenOpcClientOpcNodeIdOpcCallMethod

Die NodeId legt fest, welchen Methoden-Node der Client aufruft. Die Parameter, die eine Methode erwartet, geben Sie beim Aufruf von CallMethod oder in der jeweiligen Instanz von OpcCallMethod an. Geben Sie immer zuerst die NodeId des Owners der Methode an und danach die NodeId der Methode selbst. Die NodeId des Owners ist der Identifier des Objekt-Nodes beziehungsweise Objekttyp-Nodes, der die Methode über einen HasComponent-Verweis referenziert.

Einzelnen Methoden-Node ohne Parameter aufrufen (die Methode hat keine IN-Argumente):

C#

// The result array contains the values of the OUT arguments offered by the method.
object[] result = client.CallMethod(
        "ns=2;s=Machine",                  /* NodeId of Owner Node */
        "ns=2;s=Machine/StartMachine"      /* NodeId of Method Node*/);

VB.NET

'The result array contains the values of the OUT arguments offered by the method.
Dim result As Object() = client.CallMethod( _
        "ns=2;s=Machine", _                     'NodeId of Owner Node
        "ns=2;s=Machine/StartMachine")          'NodeId of Method Node

Einzelnen Methoden-Node mit Parametern aufrufen (die Methode hat IN-Argumente):

C#

// The result array contains the values of the OUT arguments offered by the method.
object[] result = client.CallMethod(
        "ns=2;s=Machine",                  /* NodeId of Owner Node */
        "ns=2;s=Machine/StopMachine",      /* NodeId of Method Node */
        "Job Change",                      /* Parameter 1: 'reason' */
        10023,                             /* Parameter 2: 'reasonCode' */
        DateTime.Now                       /* Parameter 3: 'scheduleDate' */);

VB.NET

'The result array contains the values of the OUT arguments offered by the method.
Dim result As Object() = client.CallMethod( _
        "ns=2;s=Machine", _                     'NodeId of Owner Node
        "ns=2;s=Machine/StopMachine", _         'NodeId of Method Node
        "Job Change", _                         'Parameter 1: 'reason'
        10023, _                                'Parameter 2: 'reasonCode'
        DateTime.Now)                           'Parameter 3: 'scheduleDate'

Mehrere Methoden-Nodes ohne Parameter aufrufen (die Methoden haben keine IN-Argumente):

C#

OpcCallMethod[] commands = new OpcCallMethod[] {
    new OpcCallMethod("ns=2;s=Machine", "ns=2;s=Machine/StopMachine"),
    new OpcCallMethod("ns=2;s=Machine", "ns=2;s=Machine/ScheduleJob"),
    new OpcCallMethod("ns=2;s=Machine", "ns=2;s=Machine/StartMachine")
};
 
// The result array contains the values of the OUT arguments offered by the methods.
object[][] results = client.CallMethods(commands);

VB.NET

Dim commands As OpcCallMethod() = New OpcCallMethod() { _
    New OpcCallMethod("ns=2;s=Machine", "ns=2;s=Machine/StopMachine"), _
    New OpcCallMethod("ns=2;s=Machine", "ns=2;s=Machine/ScheduleJob"), _
    New OpcCallMethod("ns=2;s=Machine", "ns=2;s=Machine/StartMachine") _
}

'The result array contains the values of the OUT arguments offered by the methods.
Dim results As Object()() = client.CallMethods(commands)

Mehrere Methoden-Nodes mit Parametern aufrufen (die Methoden haben IN-Argumente):

C#

OpcCallMethod[] commands = new OpcCallMethod[] {
    new OpcCallMethod(
            "ns=2;s=Machine",              /* NodeId of Owner Node */ 
            "ns=2;s=Machine/StopMachine",  /* NodeId of Method Node */
            "Job Change",                  /* Parameter 1: 'reason' */
            10023,                         /* Parameter 2: 'reasonCode' */
            DateTime.Now                   /* Parameter 3: 'scheduleDate' */),
    new OpcCallMethod(
            "ns=2;s=Machine",              /* NodeId of Owner Node */
            "ns=2;s=Machine/ScheduleJob",  /* NodeId of Method Node */
            "MAN_F01_78910"                /* Parameter 1: 'jobSerial' */),
    new OpcCallMethod(
            "ns=2;s=Machine",              /* NodeId of Owner Node */
            "ns=2;s=Machine/StartMachine", /* NodeId of Method Node */
            10021                          /* Parameter 1: 'reasonCode' */)
};
 
// The result array contains the values of the OUT arguments offered by the methods.
object[][] results = client.CallMethods(commands);

VB.NET

Dim commands As OpcCallMethod() = New OpcCallMethod() { _
    New OpcCallMethod( _
            "ns=2;s=Machine", _                 'NodeId of Owner Node
            "ns=2;s=Machine/StopMachine", _     'NodeId of Method Node
            "Job Change", _                     'Parameter 1: 'reason'
            10023, _                            'Parameter 2: 'reasonCode'
            DateTime.Now), _                    'Parameter 3: 'scheduleDate'
    New OpcCallMethod( _
            "ns=2;s=Machine", _                 'NodeId of Owner Node
            "ns=2;s=Machine/ScheduleJob", _     'NodeId of Method Node
            "MAN_F01_78910"), _                 'Parameter 1: 'jobSerial'
    New OpcCallMethod( _
            "ns=2;s=Machine", _                 'NodeId of Owner Node
            "ns=2;s=Machine/StartMachine", _    'NodeId of Method Node
            10021) _                            'Parameter 1: 'reasonCode'
}

'The result array contains the values of the OUT arguments offered by the methods.
Dim results As Object()() = client.CallMethods(commands)

Methoden-Nodes typisiert aufrufen: Für Methoden ohne OUT-Argumente bietet der OpcClient die Methode CallAction, für Methoden mit OUT-Argumenten die Methode CallFunc. Die Typparameter legen die Typen der IN-Argumente fest, der letzte Typparameter den Typ des Rückgabewerts. Die Methode gibt den Wert des ersten OUT-Arguments zurück:

C#

// Call a method without IN and OUT arguments.
client.CallAction("ns=2;s=Machine", "ns=2;s=Machine/StartMachine");
 
// Call a method with two IN arguments and return the value of its first OUT argument.
int jobId = client.CallFunc<string, int, int>(
        "ns=2;s=Machine",
        "ns=2;s=Machine/StartJob",
        "JOB001",
        10023);

VB.NET

'Call a method without IN and OUT arguments.
client.CallAction("ns=2;s=Machine", "ns=2;s=Machine/StartMachine")

'Call a method with two IN arguments and return the value of its first OUT argument.
Dim jobId As Integer = client.CallFunc(Of String, Integer, Integer)( _
        "ns=2;s=Machine", _
        "ns=2;s=Machine/StartJob", _
        "JOB001", _
        10023)

Datei-Nodes

Nodes vom Typ FileType stellen den Inhalt einer Datei bereit, auf den der Client wie auf eine Datei im Dateisystem zugreift. Wie Sie solche Dateien lesen und schreiben, beschreibt die Seite Dateien lesen und schreiben.

Datentypen abfragen

Beteiligte TypenOpcClientOpcNodeIdOpcNodeInfoOpcTypeNodeInfo

Ein Server kann einen Node bereitstellen, der einen vom Server definierten Datentyp genauer beschreibt. Diese Informationen muss der Client unter Umständen abrufen und weiterverarbeiten. Am einfachsten gelingt das durch Browsen. Für Datentyp-Nodes bietet das SDK deshalb eine Spezialisierung der Klasse OpcNodeInfo: die Klasse OpcTypeNodeInfo. Über ihre Eigenschaften ruft der Client zusätzliche Informationen über den benutzerdefinierten Datentyp ab, zum Beispiel, ob der Datentyp eine Enumeration ist. Wenn das der Fall ist, ruft er auch die Enum-Einträge dieses Typs ab:

C#

var machineStatusNode = client.BrowseNode("ns=2;s=MachineStatus") as OpcTypeNodeInfo;
 
if (machineStatusNode != null && machineStatusNode.IsEnum) {
    var members = machineStatusNode.GetEnumMembers();
 
    foreach (var member in members)
        Console.WriteLine(member.Name);
}

VB.NET

Dim machineStatusNode = TryCast(client.BrowseNode("ns=2;s=MachineStatus"), OpcTypeNodeInfo)

If machineStatusNode IsNot Nothing AndAlso machineStatusNode.IsEnum Then
    Dim members = machineStatusNode.GetEnumMembers()

    For Each member In members
        Console.WriteLine(member.Name)
    Next
End If

Variablen

Beteiligte TypenOpcClientOpcNodeIdOpcNodeInfoOpcVariableNodeInfo

Das Arbeiten mit Variablen-Nodes beschränkt sich häufig auf das Lesen und Schreiben des Value-Attributs. Das funktioniert wie bei allen Nodes, siehe Werte lesen und Werte schreiben. Wenn der Client weitere Informationen als den Wert benötigt, fordert er sie per Browsen in einem Schritt vom Server an. Dazu gehören zum Beispiel DataType, AccessLevel, IsArray, ArrayDimensions oder IsHistorizing der Klasse OpcVariableNodeInfo. Einzelne Anfragen per ReadNode sind dann nicht nötig. Das folgende Beispiel zeigt das:

C#

var machineStatusNode = client.BrowseNode("ns=2;s=Machine/Status") as OpcVariableNodeInfo;
 
if (machineStatusNode != null) {
    Console.WriteLine($"AccessLevel: {machineStatusNode.AccessLevel}");
    Console.WriteLine($"UserAccessLevel: {machineStatusNode.UserAccessLevel}");
    ...
}

VB.NET

Dim machineStatusNode = TryCast(client.BrowseNode("ns=2;s=Machine/Status"), OpcVariableNodeInfo)

If machineStatusNode IsNot Nothing Then
    Console.WriteLine("AccessLevel: {0}", machineStatusNode.AccessLevel)
    Console.WriteLine("UserAccessLevel: {0}", machineStatusNode.UserAccessLevel)
    ...
End If

Außerdem kann der Client das Browsen direkt beim Datentyp-Node fortsetzen, den der Variablen-Node verwendet:

C#

var dataTypeNode = machineStatusNode.DataType;
 
if (dataTypeNode.IsSystemType) {
    ...
}

VB.NET

Dim dataTypeNode = machineStatusNode.DataType

If dataTypeNode.IsSystemType Then
    ...
End If

Große Binärwerte als Stream

Beteiligte TypenOpcClientOpcNodeStream

Variablen mit großen ByteString-Werten (zum Beispiel Bilder, Rezepte oder Protokolle) liest der Client über einen OpcNodeStream wie eine Datei, zum Beispiel mit CopyTo. Der Stream versucht zunächst, den ganzen Wert zu lesen. Wenn das nicht gelingt, etwa weil der Wert die Grenzen der Datenübertragung überschreitet, liest er ihn in Abschnitten über Teilbereiche des Werts. Die Größe der Abschnitte richtet sich nach MaxByteStringLength. Der Stream unterstützt nur das Lesen und setzt voraus, dass der Node das Lesen erlaubt (AccessLevel CurrentRead):

C#

using (var source = new OpcNodeStream(client, "ns=2;s=Machine/Snapshot"))
using (var target = File.Create("snapshot.bin")) {
    source.CopyTo(target);
}

VB.NET

Using source = New OpcNodeStream(client, "ns=2;s=Machine/Snapshot")
    Using target = IO.File.Create("snapshot.bin")
        source.CopyTo(target)
    End Using
End Using

Datenpunkte

Beteiligte TypenOpcClientOpcNodeId

Datenpunkt-Nodes, die ein Server als OpcDataItemNode bereitstellt, erweitern einen einfachen OpcDataVariableNode. Auch sie stellen vor allem Werte bereit. Darüber hinaus liefern sie weitere nützliche Metadaten. Dazu gehört vor allem die Eigenschaft „Definition“, die diesem Node als Property-Node untergeordnet ist. Sie hilft, die Daten des Nodes korrekt zu interpretieren und weiterzuverarbeiten. Ihr herstellerabhängiger Wert beschreibt, wie der Wert des Nodes zustande kommt. Davon abgesehen funktionieren auch für diese Spezialisierung die Operationen aus Werte lesen und schreiben. Der Client liest „Definition“ wie jeden anderen Kind-Node, zum Beispiel über Child("Definition") beim Browsen oder über ReadNode mit dem Identifier des Property-Nodes.

Analoge Datenpunkte

Beteiligte TypenOpcClientOpcNodeIdOpcNodeInfoOpcAnalogItemNodeInfo

Analoge Datenpunkte sind eine Spezialisierung des Datenpunkt-Nodes OpcDataItemNode. Ihre Werte sind vor allem analog. Die zusätzlichen Eigenschaften InstrumentRange, EngineeringUnit und EngineeringUnitRange beschreiben sie genauer. InstrumentRange beschreibt den Wertebereich der analogen Daten der Quelle. EngineeringUnit legt die Maßeinheit des Werts fest, den der Node bereitstellt. Im normalen Betrieb liegt der ermittelte Wert im Wertebereich, den die Eigenschaft EngineeringUnitRange festlegt. Die Maßeinheit in der Eigenschaft EngineeringUnit folgt den UNECE-Empfehlungen N° 20. Diese Empfehlungen basieren auf dem internationalen Einheitensystem (engl. International System of Units, kurz SI Units). Für die einfachere Verarbeitung dieser zusätzlichen Informationen bietet die Klasse OpcAnalogItemNodeInfo beim Browsen die passende Schnittstelle:

C#

var temperatureNode = client.BrowseNode("ns=2;s=Machine/Temperature") as OpcAnalogItemNodeInfo;
 
if (temperatureNode != null) {
    Console.WriteLine($"InstrumentRange: {temperatureNode.InstrumentRange}");
 
    Console.WriteLine($"EngineeringUnit: {temperatureNode.EngineeringUnit}");
    Console.WriteLine($"EngineeringUnitRange: {temperatureNode.EngineeringUnitRange}");
}

VB.NET

Dim temperatureNode = TryCast(client.BrowseNode("ns=2;s=Machine/Temperature"), OpcAnalogItemNodeInfo)

If temperatureNode IsNot Nothing Then
    Console.WriteLine("InstrumentRange: {0}", temperatureNode.InstrumentRange)

    Console.WriteLine("EngineeringUnit: {0}", temperatureNode.EngineeringUnit)
    Console.WriteLine("EngineeringUnitRange: {0}", temperatureNode.EngineeringUnitRange)
End If

Die in einer OpcEngineeringUnitInfo enthaltenen Informationen beschreiben eine Maßeinheit der UNECE-Tabelle für Maßeinheiten. Die möglichen Einheiten können bei der OPC Foundation nachgeschlagen werden: UNECE-Maßeinheiten in OPC UA (aktuell nicht verfügbar). Alternativ bietet auch das MTConnect-Institut die UNECE-Tabelle auf GitHub an: UNECE-Maßeinheiten in OPC UA (MTConnect@GitHub).