OPC-UA-SDK S7-TCPIP for client/server

The following types are used here: Opc.UaFx.Client.OpcClient, Opc.UaFx.OpcNodeId, Opc.UaFx.OpcValue and Opc.UaFx.OpcDataObject.

For easy access to values of variable nodes with structured data, the framework supports the use of the keyword dynamic. Accesses to variables that are declared using dynamic are evaluated by .NET at runtime. This means that the data of a structured data type can be accessed without prior explicit implementation of a .NET type. Such access could look like this:

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

The following types are used here: Opc.UaFx.Client.OpcClient, Opc.UaFx.OpcNodeId, Opc.UaFx.OpcValue, Opc.UaFx.OpcDataObject and Opc.UaFx.OpcDataField.

For name-based access to values of variable nodes with structured data, the OpcDataObject class can be used directly. If the names of the fields of the data type are known, these can be accessed in the following way:

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

The following types are used here: Opc.UaFx.Client.OpcClient, Opc.UaFx.OpcNodeSet, Opc.UaFx.OpcAutomatism and Opc.UaFx.OpcDataTypeSystem.

For the "easiest access" by means of dynamic as well as the name-based access, the used OpcClient needs information about the data types provided by the server. This information is automatically retrieved by the OpcClient-class when you call Connect() from the server, if before the property UseDynamic on either the OpcClient or the static OpcAutomatism value true is set.

By enabling the feature, the OpcClient loads the necessary type information from the server, so that following the call to Connect() they can be accessed without explicit coding or similar as shown in the previous sections.

Is a UANodeSet.xml or an XML file describing the server (an XML file whose contents starts with UANodeSet), this file can also be loaded into the client application. The OpcClient can then obtain the information from the NodeSet and does not need to retrieve the type information when connecting. This could then look like this:

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

Note that when GetDataTypeSystem() is called, the OpcClient class provides an instance of the OpcDataTypeSystem class after setting a NodeSet, which describes the type system described in the NodeSet. Conversely, if no NodeSet is set using the NodeSet property of the OpcClient class, calling GetDataTypeSystem() returns a OpcDataTypeSystem instance, which describes the type system of the server retrieved from the server when Connect() was called.

The following types are used here: Opc.UaFx.Client.OpcClient, Opc.UaFx.OpcNodeId, Opc.UaFx.OpcDataTypeAttribute and Opc.UaFx.OpcDataTypeEncoding.

For typed access, .NET types are defined in the client application as defined in the server. All required metadata is provided via attributes. Definition of .NET types for structured data types:

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

After the client-side definition of a .NET type for a server-defined structured data type, this can be used as follows:

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

If the typed access is to be used, the possibility exists either only certain or all data types of an OPC UA server over the OPC Watch to generate. To generate a single data type implemented in .NET, follow the steps below:

1. OPC Watch open
2. Create new connection (+) and configure if necessary
3. Connect to the server (plug icon)
4. Select a node…
   1. either a variable node with structured DataType as value
   2. or a DataType-node under /Types/DataTypes/BaseDataType/Structure or /Enumeration
5. Right click on this node
6. click „Generate DataType“
7. Paste the code into the application, done!

All data types can be generated either in a code file (* .cs) or assembly file (* .dll). To do this, follow the steps below:

1. OPC Watch open
2. Create new connection (+) and configure if necessary
3. Connect to the server (plug icon)
4. select Server node „opc.tcp://…“
5. Right click on this node
6. click „Generate Models“
7. Select the desired file type in the dialog
8. click „saving“
9. Add the file to the project, done!

The following types are used here: Opc.UaFx.Client.OpcClient, Opc.UaFx.OpcNodeId, Opc.UaFx.OpcData, Opc.UaFx.OpcDataTypeAttribute, Opc.UaFx.OpcDataTypeEncodingAttribute, Opc.UaFx.OpcDataTypeSystem and Opc.UaFx.OpcDataTypeInfo.

As an alternative to generating the data type as a .NET code or .NET assembly, these can also be defined manually. To do this, implement the type as defined by the server. This means that the .NET Type (regardless of structure or class) must provide the fields of the structured data type - in terms of their type - in exactly the same order. All other metadata is provided via corresponding attributes:

[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;
    ...
}

The information needed for the definition can be obtained either through the OPC UA Server manual, the responsible PLC developer or via the OpcClient class. To determine the necessary information about the OpcClient class, you can examine the variable node - which uses the structured data types - as follows:

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

The following types are used here: Opc.UaFx.Client.OpcClient, Opc.UaFx.OpcNodeId, Opc.UaFx.OpcData, Opc.UaFx.OpcDataTypeAttribute, Opc.UaFx.OpcDataTypeEncodingAttribute, Opc.UaFx.OpcDataTypeEncodingMaskAttribute and Opc.UaFx.OpcDataTypeMemberSwitchAttribute.

In order to reduce the amount of data transported, it is possible to "mark" certain fields of a structured data type as existent or missing in the data stream depending on certain conditions or on the value of another field within the data structure. To "mark" that a field is available, either the value of another field or a single bit within the EncodingMask is used (a field which is encoded as a preamble in front of the data in the data stream). The size of the EncodingMask is specified in number of bytes in the 'OpcDataTypeEncodingMaskAttribute'; if the 'Size' property is not explicitly set, its value (when using 'OpcEncodingMaskKind.Auto') will be used with the smallest number of bytes required (based on the number of optional fields).

The following options are available for defining the optional fields:

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