OPC-UA-SDK S7-TCPIP für Client/Server

Die folgenden Typen kommen hierbei zum Einsatz: Opc.UaFx.Client.OpcClient, Opc.UaFx.OpcNodeId, Opc.UaFx.OpcValue und Opc.UaFx.OpcDataObject.

Zum einfachen Zugriff auf Werte von Variablen-Nodes mit strukturierten Daten unterstützt das Framework die Verwendung des Schlüsselwortes dynamic. Zugriffe auf Variablen, welche mittels dynamic deklariert werden, werden von .NET zur Laufzeit ausgewertet. Das bedeutet, dass ohne vorherige explizite Implementierung eines .NET Typens auf die Daten eines strukturierten Datentypens zugegriffen werden kann. Ein derartiger Zugriff könnte wie folgt aussehen:

client.UseDynamic = true;
client.Connect();
 
dynamic staff = client.ReadNode("ns=2;s=Machine/Operator").Value;
 
// Access the 'Name' and 'ID' field of the data without to declare the data type itself.
// Just use the field names known as they would be defined in a .NET Type.
Console.WriteLine("Name: {0}", staff.Name);
Console.WriteLine("Staff ID: {0}", staff.ID);
 
// Continue accessing subsequently used data types.
Console.WriteLine("Shift: {0}", staff.Shift.Name);
Console.WriteLine("- Time Elapsed: {0}", staff.Shift.Elapsed);
Console.WriteLine("- Jobs Remaining: {0}", staff.Shift.Remaining);
 
// Change Shift
staff.Name = "John";
staff.ID = 4242;
staff.Shift.Name = "Swing Shift";
 
client.WriteNode("ns=2;s=Machine/Operator", staff);

Die folgenden Typen kommen hierbei zum Einsatz: Opc.UaFx.Client.OpcClient, Opc.UaFx.OpcNodeId, Opc.UaFx.OpcValue, Opc.UaFx.OpcDataObject und Opc.UaFx.OpcDataField.

Zum Namen-basierten Zugriff auf Werte von Variablen-Nodes mit strukturierten Daten kann direkt die OpcDataObject Klasse verwendet werden. Sind die Namen der Felder des Datentypen bekannt, kann auf diese auf die folgende Weise zugegriffen werden:

client.UseDynamic = true;
client.Connect();
 
OpcDataObject staff = client.ReadNode("ns=2;s=Machine/Operator").As<OpcDataObject>();
 
// Access the 'Name' and 'ID' field of the data without to declare the data type itself.
// Just use the field names known as the 'key' to access the according field value.
Console.WriteLine("Name: {0}", staff["Name"].Value);
Console.WriteLine("Staff ID: {0}", staff["ID"].Value);
 
// Continue accessing subsequently used data types using the OpcDataObject as before.
OpcDataObject shift = (OpcDataObject)staff["Shift"].Value;
 
Console.WriteLine("Shift: {0}", shift["Name"].Value);
Console.WriteLine("- Time Elapsed: {0}", shift["Elapsed"].Value);
Console.WriteLine("- Jobs Remaining: {0}", shift["Remaining"].Value);
 
// Change Shift
staff["Name"].Value = "John";
staff["ID"].Value = 4242;
shift["Name"].Value = "Swing Shift";
 
client.WriteNode("ns=2;s=Machine/Operator", staff);

Die folgenden Typen kommen hierbei zum Einsatz: Opc.UaFx.Client.OpcClient, Opc.UaFx.OpcNodeSet, Opc.UaFx.OpcAutomatism und Opc.UaFx.OpcDataTypeSystem.

Für den „einfachsten Zugriff“ mittels dynamic wie auch dem Namen-basierten Zugriff benötigt der verwendete OpcClient Informationen über die vom Server bereitgestellten Datentypen. Diese Informationen ermittelt die OpcClient-Klasse automatisch beim Aufruf von Connect() vom Server, wenn zuvor die Eigenschaft UseDynamic entweder auf dem OpcClient oder der statischen Klasse OpcAutomatism auf den Wert true gesetzt wird.

Durch die Aktivierung des Features ladet der OpcClient die notwendigen Typinformationen vom Server, damit im Anschluss des Aufrufs von Connect() auf diese ohne explizite Codierung oder ähnlichen wie in den vorherigen Abschnitten gezeigt zugegriffen werden kann.

Liegt eine UANodeSet.xml beziehungsweise eine XML-Datei mit der Beschreibung des Servers (eine XML-Datei deren Inhalt mit UANodeSet beginnt) vor, kann diese Datei auch in die Client-Anwendung geladen werden. Der OpcClient kann dann die Informationen aus dem NodeSet beziehen und muss nicht beim Herstellen einer Verbindung die Typinformation abrufen. Dies könnte dann wie folgt aussehen:

using (OpcClient client = new OpcClient("opc.tcp://localhost:4840")) {
    client.NodeSet = OpcNodeSet.Load(@"..\Resources\MyServersNodeSet.xml");
    client.UseDynamic = true;
 
    client.Connect();
    dynamic staff = client.ReadNode("ns=2;s=Machine/Operator").Value;
 
    Console.WriteLine("Name: {0}", staff.Name);
    Console.WriteLine("Staff ID: {0}", staff.ID);
}

Zu beachten ist, dass die OpcClient-Klasse beim Aufruf von GetDataTypeSystem() nach dem Setzen eines NodeSets eine Instanz der OpcDataTypeSystem-Klasse bereitstellt, welche das im NodeSet beschriebene Typ-System beschreibt. Wird hingegen kein NodeSet über die NodeSet-Eigenschaft der OpcClient-Klasse festgelegt, liefert der Aufruf von GetDataTypeSystem() eine OpcDataTypeSystem-Instanz, welche das Typ-System des Servers beschreibt, welches beim Aufruf von Connect() vom Server abgerufen wurde.

Die folgenden Typen kommen hierbei zum Einsatz: Opc.UaFx.Client.OpcClient, Opc.UaFx.OpcNodeId, Opc.UaFx.OpcDataTypeAttribute und Opc.UaFx.OpcDataTypeEncoding.

Für den typisierten Zugriff werden .NET Typen in der Client-Anwendung so definiert, wie sie im Server definiert sind. Alle nötigen Metadaten werden dabei über Attribute bereitgestellt. Definition der .NET Typen für strukturierte Datentypen:

[OpcDataType("ns=2;s=StaffType")]
[OpcDataTypeEncoding("ns=2;s=StaffType-Binary")]
public class Staff
{
    public string Name { get; set; }
    public int ID { get; set; }
    public ShiftInfo Shift { get; set; }
}
 
[OpcDataType("ns=2;s=ShiftInfoType")]
[OpcDataTypeEncoding("ns=2;s=ShiftInfoType-Binary")]
public class ShiftInfo
{
    public string Name { get; set; }
    public DateTime Elapsed { get; set; }
    public byte Remaining { get; set; }
}

Nach der Client-seitigen Definition eines .NET Typen für einen Server-seitig definierten strukturierten Datentypen kann dieser wie folgt verwendet werden:

client.Connect();
Staff staff = client.ReadNode("ns=2;s=Machine/Operator").As<Staff>();
 
// Access the 'Name' and 'ID' field of the data with the declared the data type.
Console.WriteLine("Name: {0}", staff.Name);
Console.WriteLine("Staff ID: {0}", staff.ID);
 
// Continue accessing subsequently used data types.
Console.WriteLine("Shift: {0}", staff.Shift.Name);
Console.WriteLine("- Time Elapsed: {0}", staff.Shift.Elapsed);
Console.WriteLine("- Jobs Remaining: {0}", staff.Shift.Remaining);
 
// Change Shift
staff.Name = "John";
staff.ID = 4242;
staff.Shift.Name = "Swing Shift";
 
client.WriteNode("ns=2;s=Machine/Operator", staff);

Ist der typisierte Zugriff zu verwenden besteht die Möglichkeit entweder nur bestimmte oder alle Datentypen eines OPC UA Servers über die OPC Watch zu generieren. Zur Generierung eines einzelnen in .NET implementierten Datentypen sind folgende Schritte durchzuführen:

1. OPC Watch öffnen
2. Neue Verbindung anlegen (+) und ggf. konfigurieren
3. Verbindung zum Server herstellen (Stecker-Symbol)
4. Einen Knoten auswählen…
   1. entweder einen Variablen-Knoten mit strukturierten DataType als Wert
   2. oder einen DataType-Knoten unter /Types/DataTypes/BaseDataType/Structure oder /Enumeration
5. Rechtsklick auf diesen Knoten
6. „Generate DataType“ klicken
7. Den Code in die Anwendung einfügen, fertig!

Zur Generierung aller Datentypen besteht die Möglichkeit diese entweder in einer Code-Datei (*.cs) oder Assembly-Datei (*.dll) zu generieren. Hierzu befolgen sind die folgenden Schritte durchzuführen:

1. OPC Watch öffnen
2. Neue Verbindung anlegen (+) und ggf. konfigurieren
3. Verbindung zum Server herstellen (Stecker-Symbol)
4. Server-Knoten „opc.tcp://…“ auswählen
5. Rechtsklick auf diesen Knoten
6. „Generate Models“ klicken
7. Im Dialog den gewünschten Dateitypen auswählen
8. „Speichern“ klicken
9. Die Datei dem Projekt hinzufügen, fertig!

Die folgenden Typen kommen hierbei zum Einsatz: Opc.UaFx.Client.OpcClient, Opc.UaFx.OpcNodeId, Opc.UaFx.OpcData, Opc.UaFx.OpcDataTypeAttribute, Opc.UaFx.OpcDataTypeEncodingAttribute, Opc.UaFx.OpcDataTypeSystem und Opc.UaFx.OpcDataTypeInfo.

Alternativ zur Generierung des Datentypen als .NET-Code oder .NET-Assembly besteht können diese auch manuell definiert werden. Hierzu implementiert man den Typen, wie er vom Server definiert wurde. Das bedeutet, dass der .NET Type (unabhängig ob Struktur oder Klasse) in genau der gleichen Reihenfolge die Felder des strukturierten Datentypen - bezüglich ihres Typens - bereitstellen muss. Alle weiteren Metadaten werden über entsprechende Attribute bereitgestellt:

[OpcDataType("<NodeId of DataType Node>")]
[OpcDataTypeEncoding(
        "<NodeId of Binary Encoding Node>",
        NamespaceUri = "<NamespaceUri.Value of binary Dictionary-Node>")]
internal struct MyDataType
{
    public short FieldA;
    public int FieldB;
    public string FieldC;
    ...
}

Die zur Definition benötigten Informationen können entweder über das Handbuch zum OPC UA Server, dem verantwortlichen SPS-Entwickler oder über die OpcClient-Klasse bezogen werden. Zur Ermittlung der notwendigen Informationen über die OpcClient-Klasse können sie den Variablen-Node - der den strukturierten Datentypen verwendet - wie folgt untersuchen:

OpcNodeInfo node = client.BrowseNode("ns=2;s=Machine/Operator");
 
if (node is OpcVariableNodeInfo variableNode) {
    OpcNodeId dataTypeId = variableNode.DataTypeId;
    OpcDataTypeInfo dataType = client.GetDataTypeSystem().GetType(dataTypeId);
 
    Console.WriteLine(dataType.TypeId);
    Console.WriteLine(dataType.Encoding);
 
    Console.WriteLine(dataType.Name);
 
    foreach (OpcDataFieldInfo field in dataType.GetFields())
        Console.WriteLine(".{0} : {1}", field.Name, field.FieldType);
}

Die folgenden Typen kommen hierbei zum Einsatz: Opc.UaFx.Client.OpcClient, Opc.UaFx.OpcNodeId, Opc.UaFx.OpcData, Opc.UaFx.OpcDataTypeAttribute, Opc.UaFx.OpcDataTypeEncodingAttribute, Opc.UaFx.OpcDataTypeEncodingMaskAttribute und Opc.UaFx.OpcDataTypeMemberSwitchAttribute.

Zur Reduzierung der transportierten Datenmenge, besteht die Möglichkeit bestimmte Felder eines strukturierten Datentypens in Abhängigkeit von bestimmten Bedingungen beziehungsweise von dem Wert eines anderen Feldes innerhalb der Datenstruktur als existent oder fehlend im Datenstrom zu „markieren“. Zur „Markierung“, dass ein Feld verfügbar ist, dient somit entweder der Wert eines anderen Feldes oder ein einzelnes Bit innerhalb der EncodingMask (ein Feld welches als Präambel vor den Daten im Datenstrom kodiert ist). Die Größe der EncodingMask wird in Anzahl Bytes im 'OpcDataTypeEncodingMaskAttribute' angegeben; wird die Eigenschaft 'Size' nicht explizit festgelegt, wird ihr Wert (bei Verwendung von 'OpcEncodingMaskKind.Auto') mit der kleinsten Anzahl an benötigten Bytes (anhand der Anzahl der optionalen Felder) belegt.

Zur Definition der optionalen Felder stehen unter anderen die folgenden Möglichkeiten zur Verfügung:

[OpcDataType("<NodeId of DataType Node>")]
[OpcDataTypeEncoding(
        "<NodeId of Binary Encoding Node>",
        NamespaceUri = "<NamespaceUri.Value of binary Dictionary-Node>")]
[OpcDataTypeEncodingMask(OpcEncodingMaskKind.Auto, Size = sizeof(uint))]
internal struct MyDataTypeWithOptionalFields
{
    public short FieldA;
    public int FieldB;
    public string FieldC;
 
    // Nullables are treat as optional fields by default.
    // Existence-Indicator-Bit is Bit0 in the encoding mask.
    public uint? OptionalField1;
 
    // Existence-Indicator-Bit is Bit1 (the next unused bit) in the encoding mask.
    [OpcDataTypeMemberSwitch]
    public int OptionalField2;
 
    // Existence-Indicator-Bit is Bit3 (bit 2 is unused) in the encoding mask.
    [OpcDataTypeMemberSwitch(bit: 3)]
    public byte OptionalField3;
 
    public bool FieldD;
 
    // 'OptionalField3' exists only if the value of 'FieldD' is equals 'true'.
    [OpcDataTypeMemberSwitch("FieldD")]
    public string OptionalField3;
 
    public int FieldE;
 
    // 'OptionalField4' exists only if the value of 'FieldE' is greater than '42'.
    [OpcDataTypeMemberSwitch("FieldE", value: 42, operand: OpcMemberSwitchOperator.GreaterThan)]
    public string OptionalField4;
}