

OPC UA Provider Application

The OPC UA Provider Application is needed for using the OPC UA Server as northbound interface as the OPC UA Server itself doesn’t communicate with the SINUMERIK. The provider application can read and process data from the SINUMERIK, write data to the OPC UA Server through the Databus, receive data from the OPC UA Server for writing it back to the SINUMERIK, send events to the server to add / delete nodes and generate events.The provider application hands the information model, that can be created in SiOME, over to the OPC UA Server while installation/configuration via the Insights Hub AppManagement. The datamodel is configured in the configuration of the provider application and automatically passed to the server.

A provider application uses the AppSDK functionality for reading data from the machine and writing data through the Databus and transmitting data through events, so it can be developed in any language supported by the AppSDK.

One OPC UA Server can support multiple Provider applications, each with their own, independent data model. Important Each Provider application has to implement his own unique namespace(s). It is not possible to load multiple same namespaces in parallel.

Getting Started

The installation and configuration of the opcuaserver application is described in the User Manual. The user manual also explains how to connect to the server with an OPC UA client. This documentation describes how to develop a provider application, that uses the OPC UA Server as a northbound interface.

There are several examples provided within the AppSDK.

This documentation will focus on the interfaces for writing data to the opcuaserver application from the provider application, receiving values from external OPC UA Client, adding / deleting nodes and sending events. They are described in their entirety, while the example is a good starting point for understanding how to implement a provider application.

Creating a Data Model

The information model is defined in a XML file. It describes which nodes are shown in your OPC UA Server, their references and types. It can be manually created, but it is recommended to create it in the free SiOME tool. The data model can be any valid data model, so it can for example implement the Umati standard, but it doesn’t have to.

NOTE: As the OPC UA Server can have multiple provider applications, the namespace indices of your data model are dynamically assigned, and might be different in the OPC UA Server from the namespace indices used in your data model.

Important Each Provider application has to implement his own unique namespace(s). Please make sure that each application has its own data model with its own namespace.

You can download SiOME under the following link or search for the current version in SIOS: https://support.industry.siemens.com/cs/document/109755133/siemens-opc-ua-modeling-editor-(siome)-for-implementing-opc-ua-companion-specifications?dti=0&lc=en-US

Create a new namespace for you data model. Make sure your namespace URI is unique and you don't have any other provider applications installed using this URI.

By right clicking on the "Objects" node you can add a new Object.

Now you can add variables to this object. In this example, a variable called Parameter1 and Parameter2 is created:

You can create your own datamodel with multiple namespaces, any nodes and references.

Mapping Nodes

The OPC UA Server doesn't use the Node ID for identifying nodes. Instead, it uses a mapping, that you define in your data model. This mapping is also referred to as the node's address. It can be manually added to the XML or directly created in SiOME.

In order to write data to variables, you need to define a variable mapping. This variable mapping gives a variable an address, which is later used to write data to the variable. The supported data types for writing variables are listed in the chapter Data Types.

In order to fire events from a specific object and in order to add new nodes as children of an object, you can also add a mapping to an object.

SiOME

Firstly, you have to enable the "Mapping" view in SiOME.

Now you can click on the right side of the variable or object you want to add a mapping to. You can set the mapping to any string you want.

After creating the data model in SiOME you have to save it as a XML file:

The finished datamodel looks as follows:

<?xml version="1.0" encoding="utf-8"?>
<UANodeSet LastModified="2021-05-27T11:13:57.112Z" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://opcfoundation.org/UA/2011/03/UANodeSet.xsd" xmlns:uax="http://opcfoundation.org/UA/2008/02/Types.xsd" xmlns:si="http://www.siemens.com/OPCUA/2017/SimaticNodeSetExtensions" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
    <NamespaceUris>
        <Uri>http://www.siemens.com</Uri>
    </NamespaceUris>
    <Models>
        <Model ModelUri="http://www.siemens.com" PublicationDate="2021-05-27T00:00:00Z" Version="1.00">
            <RequiredModel ModelUri="http://opcfoundation.org/UA/" PublicationDate="2020-07-15T00:00:00Z" Version="1.04.7"/>
        </Model>
    </Models>
    <Aliases>
        <Alias Alias="Boolean">i=1</Alias>
        <Alias Alias="Double">i=11</Alias>
        <Alias Alias="DateTime">i=13</Alias>
        <Alias Alias="String">i=12</Alias>
        <Alias Alias="HasComponent">i=47</Alias>
        <Alias Alias="HasProperty">i=46</Alias>
        <Alias Alias="Organizes">i=35</Alias>
        <Alias Alias="HasTypeDefinition">i=40</Alias>
    </Aliases>
    <Extensions>
        <Extension>
            <si:Generator Product="SiOME" Edition="Standard" Version="2.2.0"/>
        </Extension>
        <Extension>
            <si:GeneratorExtension Hash="f5942115eb1ed727b1ae53188f7f8e45"/>
        </Extension>
    </Extensions>
    <UAObject SymbolicName="http___www_siemens_com" NodeId="ns=1;i=5000" BrowseName="1:http://www.siemens.com" ParentNodeId="i=11715">
        <DisplayName>http://www.siemens.com</DisplayName>
        <References>
            <Reference ReferenceType="HasComponent" IsForward="false">i=11715</Reference>
            <Reference ReferenceType="HasTypeDefinition">i=11616</Reference>
        </References>
    </UAObject>
    <UAVariable DataType="Boolean" NodeId="ns=1;i=6000" BrowseName="IsNamespaceSubset" ParentNodeId="ns=1;i=5000">
        <DisplayName>IsNamespaceSubset</DisplayName>
        <References>
            <Reference ReferenceType="HasProperty" IsForward="false">ns=1;i=5000</Reference>
            <Reference ReferenceType="HasTypeDefinition">i=68</Reference>
        </References>
    </UAVariable>
    <UAVariable DataType="DateTime" NodeId="ns=1;i=6001" BrowseName="NamespacePublicationDate" ParentNodeId="ns=1;i=5000">
        <DisplayName>NamespacePublicationDate</DisplayName>
        <References>
            <Reference ReferenceType="HasProperty" IsForward="false">ns=1;i=5000</Reference>
            <Reference ReferenceType="HasTypeDefinition">i=68</Reference>
        </References>
        <Value>
            <uax:DateTime>2021-05-27T00:00:00Z</uax:DateTime>
        </Value>
    </UAVariable>
    <UAVariable DataType="String" NodeId="ns=1;i=6002" BrowseName="NamespaceUri" ParentNodeId="ns=1;i=5000">
        <DisplayName>NamespaceUri</DisplayName>
        <References>
            <Reference ReferenceType="HasProperty" IsForward="false">ns=1;i=5000</Reference>
            <Reference ReferenceType="HasTypeDefinition">i=68</Reference>
        </References>
        <Value>
            <uax:String>http://www.siemens.com</uax:String>
        </Value>
    </UAVariable>
    <UAVariable DataType="String" NodeId="ns=1;i=6003" BrowseName="NamespaceVersion" ParentNodeId="ns=1;i=5000">
        <DisplayName>NamespaceVersion</DisplayName>
        <References>
            <Reference ReferenceType="HasProperty" IsForward="false">ns=1;i=5000</Reference>
            <Reference ReferenceType="HasTypeDefinition">i=68</Reference>
        </References>
        <Value>
            <uax:String>1.00</uax:String>
        </Value>
    </UAVariable>
    <UAVariable DataType="i=256" ValueRank="1" NodeId="ns=1;i=6004" ArrayDimensions="0" BrowseName="StaticNodeIdTypes" ParentNodeId="ns=1;i=5000">
        <DisplayName>StaticNodeIdTypes</DisplayName>
        <References>
            <Reference ReferenceType="HasProperty" IsForward="false">ns=1;i=5000</Reference>
            <Reference ReferenceType="HasTypeDefinition">i=68</Reference>
        </References>
    </UAVariable>
    <UAVariable DataType="i=291" ValueRank="1" NodeId="ns=1;i=6005" ArrayDimensions="0" BrowseName="StaticNumericNodeIdRange" ParentNodeId="ns=1;i=5000">
        <DisplayName>StaticNumericNodeIdRange</DisplayName>
        <References>
            <Reference ReferenceType="HasProperty" IsForward="false">ns=1;i=5000</Reference>
            <Reference ReferenceType="HasTypeDefinition">i=68</Reference>
        </References>
    </UAVariable>
    <UAVariable DataType="String" NodeId="ns=1;i=6006" BrowseName="StaticStringNodeIdPattern" ParentNodeId="ns=1;i=5000">
        <DisplayName>StaticStringNodeIdPattern</DisplayName>
        <References>
            <Reference ReferenceType="HasProperty" IsForward="false">ns=1;i=5000</Reference>
            <Reference ReferenceType="HasTypeDefinition">i=68</Reference>
        </References>
    </UAVariable>
    <UAVariable DataType="i=96" ValueRank="1" NodeId="ns=1;i=6007" ArrayDimensions="0" BrowseName="DefaultRolePermissions" ParentNodeId="ns=1;i=5000">
        <DisplayName>DefaultRolePermissions</DisplayName>
        <References>
            <Reference ReferenceType="HasProperty" IsForward="false">ns=1;i=5000</Reference>
            <Reference ReferenceType="HasTypeDefinition">i=68</Reference>
        </References>
    </UAVariable>
    <UAObject NodeId="ns=1;i=5001" BrowseName="1:OPCUAApp" ParentNodeId="i=85">
        <DisplayName>OPCUAApp</DisplayName>
        <References>
            <Reference ReferenceType="Organizes" IsForward="false">i=85</Reference>
            <Reference ReferenceType="HasTypeDefinition">i=58</Reference>
        </References>
    </UAObject>
    <UAVariable DataType="Double" NodeId="ns=1;i=6008" BrowseName="1:Parameter1" ParentNodeId="ns=1;i=5001" UserAccessLevel="3" AccessLevel="3">
        <DisplayName>Parameter1</DisplayName>
        <References>
            <Reference ReferenceType="Organizes" IsForward="false">ns=1;i=5001</Reference>
            <Reference ReferenceType="HasTypeDefinition">i=63</Reference>
        </References>
        <Extensions>
            <Extension>
                <si:VariableMapping>Parameter1</si:VariableMapping>
            </Extension>
        </Extensions>
    </UAVariable>
    <UAVariable DataType="Double" NodeId="ns=1;i=6009" BrowseName="1:Parameter2" ParentNodeId="ns=1;i=5001" UserAccessLevel="3" AccessLevel="3">
        <DisplayName>Parameter2</DisplayName>
        <References>
            <Reference ReferenceType="Organizes" IsForward="false">ns=1;i=5001</Reference>
            <Reference ReferenceType="HasTypeDefinition">i=63</Reference>
        </References>
        <Extensions>
            <Extension>
                <si:VariableMapping>Parameter2</si:VariableMapping>
            </Extension>
        </Extensions>
    </UAVariable>
</UANodeSet>

XML:

The Mappings can also be added manually to the XML.

Variable Mapping:

<UAVariable DataType="Boolean" NodeId="ns=1;i=6008" BrowseName="1:MyBoolean" ParentNodeId="ns=1;i=5001" UserAccessLevel="3" AccessLevel="3">
    <DisplayName>MyBoolean</DisplayName>
        <References>
            <Reference ReferenceType="Organizes" IsForward="false">ns=1;i=5001</Reference>
            <Reference ReferenceType="HasTypeDefinition">i=63</Reference>
        </References>
    <Extensions>
        <Extension>
            <si:VariableMapping>MyMachine/MyBoolean</si:VariableMapping>
        </Extension>
    </Extensions>
</UAVariable>

Object Mapping:

<UAObject NodeId="ns=1;i=5002" BrowseName="1:MyObject" ParentNodeId="ns=1;i=5001">
    <DisplayName>MyObject</DisplayName>
    <References>
        <Reference ReferenceType="Organizes" IsForward="false">ns=1;i=5001</Reference>
        <Reference ReferenceType="HasTypeDefinition">i=58</Reference>
    </References>
    <Extensions>
        <Extension>
            <si:ObjectMapping>MyMachine/MyObject</si:ObjectMapping>
        </Extension>
    </Extensions>
</UAObject>

You can add the \<Extensions> section to any variable or object and later write to it by using this mapping as the address. Make sure to use the extension \<si:ObjectMapping> for object mappings and the extension \<si:VariableMapping> for variable mappings.

Configuring the provider application

In order to pass your data model to the opcuaserver, you must include it in your metaconfiguration. Therefore, encode the XML file in Base64 and add the Base64 string to your delta.json file under the object “opcuaserverConfig”. You can also pass any number of certificates in the Array "certificates", that clients can later use to authenticate themselves. Make sure that your ".der" certificate files are encoded in base64 and copy them into the delta.json as follows:

{
  "opcuaserverConfig": {
    "dataModel": "Base64 encoded XML",
    "certificates": [
      "Base64 encoded Certificate File"
    ]
  },
  "specificConfig": {
    ...
  },
  ...
}

This isn't the only way for allowing client certificates to connect with the opcuaserver, the normal way to manage certificates is explained in the User Manual. You can simply leave the "certificates" Array out.

You can for example encode the XML and the certificate file with the following linux command:

base64 datamodel.xml

When building the app with the "indapp-build" tool, there is a parameter "opc-ua", that takes a XML file and puts the base64 encoded content in the metaconfig for you. You can also pass certificates with the parameter "opc-ua-crt". The "opc-ua-crt" parameter can be repeated multiple times for including multiple certificates.

indapp-build -n provider_name -m opc-ua datamodel.xml opc-ua-cert openssl_crt.der -d delta.json -swu 1.0.0

These parameters aren't available when using appsdk package to build your application, you have to insert your base64 encoded data model and certificates in the delta.json file in that case.

OPC UA Server API

When your provider application has the data model configured in its metaconfig, you can use the AppSDK to write data, send events and to add/delete dynamic nodes.

The API uses the Event mechanism to send events to the opcuaserver, as well as the Databus for sending data. You don't have to configure any permissions for the Databus or the events in your application's metaconfig, as they are automatically enabled for a provider application.

The API is described in this chapter.

Data Types

Opc UA has 24 built-in data types. It is important to understand the difference between these built-in data types and the attribute “DataType”. The built-in data types are used for transmitting the actual value over the wire. That’s why the value of every variable uses one of these 24 data types. Variables also have an attribute called “DataType”, which is a NodeId, that references a data type node. There are a lot more data type nodes then built-in data types, and you can create data types in your own data model and reference them, e.g. for custom Enums. You can see the difference in the following screenshot from UaExpert:

When creating a data model, you only set the attribute “DataType” and the server deduces the value data type from that. If you are unsure, which value data type your variable will have, you can load the datamodel in the server and check it in UaExpert. The value data type is used for respresenting a variable's value when interacting with the opcuaserver.

The opcuaserver supports 19 of the 24 value data types. Their representations when writing data are shown in the following table:

Value Datatype	JSON representation	Examples
Boolean	Boolean, String	true; false; “true”; “false”; “1”; “0”
SByte	Number, String	-12, 2, “-12”, “2”
Byte	Number, String	2, “2”
Int16	Number, String	-5123, 4214, "-12", "12"
UInt16	Number, String	4214, "12"
Int32	Number, String	-41232, 52353, "-423", "1322"
UInt32	Number, String	55231, "9"
Int64	Number, String	-4214124, 4122424, "42", "-42"
UInt64	Number, String	4122424, "242"
Float	Number, String	3, 3.54, 53e5, -48.5E-5, "3", "3.4", "42e5", "-42.5E2"
Double	Number, String	3, 3.54, 53e5, -48.5E-5, "3", "3.4", "42e5", "-42.5E2"
String	String	“abcde”
DateTime	String (ISO 8601)	“2021-05-11T08:18:52+0000”
Guid	String (hex representation, 16 byte)	“87df9023458327849d4782 2829df9823”
ByteString	String (hex representation)	“023ab2”
NodeId	String	"NS2|String|Hello"; "NS2|Numeric|2432"
	The NodeId always has the format:	“NS[namespace index]|[String/Numeric]|[Identifier]”
ExpandedNodeId	Object	{ “NodeId”: [NodeId], “NamespaceUri”: [String], “ServerIndex”: [UInt32] }
StatusCode	Number, String (UInt32)	5343; “4221” https://reference.opcfoundation.org/v104/Core/docs/Part4/7.34.1/
QualifiedName	Object	{ “Name”: [String], “NamespaceIndex”: [UInt16] }
LocalizedText	String JSON array of 2 Strings	“abcde” The locale will be an empty string “”. ["en-US","abcde"] The locale must be the first element, the text the second
ExtensionObject	-	Extension Objects are not generally supported, the exceptions are shown below

Currently the provider application can only set one locale for the LocalizedText which will be used from the OPC UA Server.

An ExtensionObject can only be written to, if the Attribute “DataType” is either EUInformation (NS0|Numeric|887) or Range (NS0|Numeric|884). They have the following JSON representations:

Attribute Datatype	JSON representation	Examples
EUInformation	Object	{ “NamespaceUri”: [String], “UnitId”: [Int32], “DisplayName”: [LocalizedText], “Description”: [LocalizedText] }
Range	Object	{ “Low”: [Double], “High”: [Double] }

These are only supported when adding nodes / writing to nodes, they cannot be used as event fields.

Provide data to a variable in the OPC UA Server

To provide datasource variables to the OPC UA server for OPC UA client reading operations, the provider app needs to write the data to the OPC UA Server. For that, it is required to send a message with the data via the Databus. The payload is similar to the HF payload format for SINUMERIK data.

The topic is always "edge_opcua_data". Write permissions for this topic are automatically assigned to your application, so you don't have to declare them in the metaconfig.

For each datapoint, the address field in the payload corresponds to the VariableMapping defined in the data model xml for the variable you want to write. The value for the variable is given as the JSON representation for the value data type of the variable, defined in the table above

IMPORTANT NOTE : Please check the ValueRank of your variable. Only Scalar (ValueRank = "-1") and OneDimension (ValueRank = "1") are supported.

{
    "header": {
        "message_type": "dataobject",
        "key": "",
        "source_id": "sampleOPCUAProvider"
    },
    "body": {
        "datapoint": [
               {
                    "address": "MyMachine/MyBoolean",
                    "timestamp": "2020-09-10T09:57:22",
                    "content": [
                        {
                            "value": [
                              true
                            ]
                        }
                    ]
                } 
            ]
    }
}

This is an example json format for the payload.

The address is the Variable Mapping which is defined in the Datamodel.

The timestamp is in the ISO 8601 format.

The value can be represented as just the value or as an array with a single element as it is shown in the example above. For a variable with the ValueRank = "1" (Linear) the value must be given as an Array which can have any number of elements.

A message can contain multiple datapoints for writing to multiple variables at once.

Overwriting variables via OPC UA Client

When an OPC UA Client application intends to write data in the OPC UA object model (OPC UA Write), it writes the data into the OPC UA Server variable. The OPC UA Server then sends a message through the Databus to the corresponding provider application. The payload of the message follows a format similar to the HF payload format.

To ensure successful transmission, the Consumer's message ID must be "edge_opcua_server_data." It is not necessary to specify read permissions for this message ID in the app configuration. By using the opcuaserverConfig section, the read permissions are automatically assigned.

In the payload, the address field for each datapoint corresponds to the variable mapping name specified in the data model XML for the variable you wish to update. The value of the variable is given in JSON representation, as defined in the table above for the variable's value data type.

{
    "header": {
        "message_type": "dataobject",
        "key": "",
        "source_id": "opcuaserver"
    },
    "body": {
        "datapoint": [
            {
                "address": "MyMachine/MyBoolean",
                "timestamp": "2023-06-07T07:08:13.786898",
                "period_ms": "2",
                "content": [
                    {
                        "value": false
                    }
                ]
            }
        ]
    }
}

This is an example json format for the payload.

The address is the variable mapping name which is defined in the Datamodel. The timestamp is in the ISO 8601 format. The period_ms is not relevant and just a default value .

To overwrite the variables you need to set the AccessLevel and UserAccessLevel to "CurrentWrite" within the data model.

Important! For writing values back to the SINUMERIK please consider that the WriteDeviceParameter function filters parameter access with a whitelist. For more information look into the parameter-service function refence User Manual.

Important! The data type Extensionobject can't be written back and will be returned as null value to the provider application.

Adding Nodes

Nodes can be added into the information model at runtime. These added nodes exist only as long as the OPC UA Server is not stopped. Adding Nodes can be done by sending the event “AddNode” to the "opcuaserver" application. Therefore the EventManager is used. The OPC UA Server supports adding and deleting variables and objects. Nodes can be added as children of Objects or Variables, just make sure that the parent nodes have a mapping/address defined.

The Event data for adding an Object looks as follows:

{
  "node_id": "NS0|String|HelloWorldObj",
  "name": "HelloWorldObj",
  "address": "HelloWorldObj",
  "value_data_type": "Object",
  "parent_address": "ToolList",
}

The Event data for adding a Variable looks as follows:

{
  "node_id": "NS0|String|HelloWorldVar",
  "name": "HelloWorldVar",
  "address": "HelloWorldVar",
  "browsename_nsid": "http://opcfoundation.org/UA/MachineTool/",
  "value_data_type": "Int32",
  "initial_value": 56,
  "parent_address": "ToolList",
  "reference_parent_child": "NS0|Numeric|46",
  "reference_type_definition": "NS0|Numeric|68",
  "attribute_data_type": "http://opcfoundation.org/UA/Machinery/|Numeric|3006"
}

Parameter	Explanation
node_id	Node ID of the new node. Use the namespace 0 for the new node to be automatically added to the same namespace as its parent (recommended).
name	Display- and browse name of the new Node
address	The address/mapping of the new Variable / Object, used for writing in case of a variable, adding new child nodes and deleting the node.
browsename_nsid	Optional Namespace Uri for browsename. Default Same namespace ID as its parent.
value_data_type	The value data type of the new node, as defined in the chapter Data Types. There is the additional data type “Object”, which is used for creating an Object instead of a Variable.
parent_address	The address/mapping of the parent node.
reference_parent_child	Optional The Node ID of the hierarchical reference. Default NS0|Numeric|47 (HasComponent)
reference_type_definition	Optional The Node ID of the type definition reference. Default NS0|Numeric|48 (BaseDataVariableType) for Variables; NS0|Numeric|24 (BaseObjectType) for Objects
initial_value	Variables only This defines the initial value of the variable, using the JSON representation defined in the chapter Data Types.
attribute_data_type	Variables only, Optional This defines the NodeID for the "DataType" attribute when creating a variable. Default The data type corresponding to the passed "value_data_type".

The references are explained in the following screenshot from UaExpert:

The Node ID notation for the "reference_type_definition" and the "attribute_data_type" is expanded for this use case. You can pass the namespace URI instead of the namespace index for a node, e.g.:

"http://machine_tool.org/Example|Numeric|25535"

This is needed when you reference a node, that is in your datamodel and not in the default namespace, because your namespace indices change when deploying you data model on the opcuaserver.

The payload of the event can either consist of the above JSON Object directly, or the payload can be an array of multiple of these objects. This way, you can create multiple nodes in one event.

Important! Parent nodes must come before any children you add to them if you create them in the same array.

Deleting Nodes

Deleting Nodes can be done by sending the event “DeleteNode” to the opcuaserver, with the following data:

{
  "address": "HelloWorldObj"
}

The address is the address/mapping of the node you want to remove.

You can also pass an Array with this object to delete multiple nodes at the same time.

The children of deleted nodes will automatically be deleted.

Sending Events

The OPC UA Server allows you to fire events from your provider application. For that, send an Event with the name "SetEvent" to the opcuaserver application, using the AppSDK EventManager. The payload looks as follows:

{
  "source_address": "EventSource",
  "type": "CustomEventType",
  "fields":
  {
    "Message": "TestEvent_Message",
    "Time": "2020-05-30T09:30:10Z",
    "ExampleInt32": 214
  }
}

Parameter	Explanation
source_address	Address/Mapping of the Object, which shall emit the event.
type	Type of the event. It is given as the DisplayName of the event type.
fields	JSON Object which contains the value for every event field that you want to set. Entries in this Object have the DisplayName of the event field as their key. The value is represented as described in the chapter Data Types

The Event type can either be one of the default events listed below, or it can be a custom event, if the custom event is a subtype of one of the supported events below.

If you define a custom event, you can add any event fields to it, as long as the value data types are supported by the opcuaserver. You can then pass their value in the "fields" object, using their DisplayName as the key and the JSON representation of the argument value as the value.

It is important to set the "EventNotifier" attribute of the Object you want to fire events on to 1 (SubscribeToEvents). If you want to fire a custom event type, you also need to add the reference "GeneratesEvents" (i=41) from the event source to your event type.

XML:

<UAObject EventNotifier="1" NodeId="ns=1;i=5003" BrowseName="1:EventSource" ParentNodeId="ns=1;i=5001">
    <DisplayName>EventSource</DisplayName>
    <References>
        <Reference ReferenceType="Organizes" IsForward="false">ns=1;i=5001</Reference>
        <Reference ReferenceType="HasTypeDefinition">i=58</Reference>
        <Reference ReferenceType="i=41">ns=1;i=1000</Reference>
    </References>
    <Extensions>
        <Extension>
            <si:ObjectMapping>EventSource</si:ObjectMapping>
        </Extension>
    </Extensions>
</UAObject>

SiOME:

The following tables show the supported OPC UA EventTypes, with their associated fields. Please remember that every event type inherits the event fields of the super event type. You don't have to specify every event field, if they are left out, defaults are assumed. You can see the defaults by leaving the fields out and checking the event in UaExpert.

DiscreteAlarmType subtype of: AlarmConditionType

The discrete alarm type has no event fields of its own.

AlarmConditionType subtype of: AcknowledgeableConditionType

Field	Data Type
ActiveState	Boolean
ActiveStateDisplayName	LocalizedText
InputNode	NodeId
MaxTimeShelved	Double
SuppressedOrShelved	Boolean
SuppressedState	Boolean

AcknowledgableConditionType subtype of: ConditionType

Field	Data Type
AckedState	Boolean
ConfirmedState	Boolean

ConditionType subtype of: BaseEventType

Field	Data Type
ConditionNodeId	NodeId
BranchId	NodeId
ClientUserId	String
Comment	LocalizedText
ConditionClassId	NodeId
ConditionClassName	LocalizedText
ConditionName	String
EnabledState	Boolean
LastSeverity	UInt16
Quality	StatusCode
Retain	Boolean

BaseEventType

Field	Data Type	Default
Message	LocalizedText	""
Severity	UInt16	500
SourceName	String	DisplayName of the Source Node
ReceiveTime	DateTime	Current Time
Time	Time	Current Time

Umati

Umati (universal machine technology interface) or also called UA4MT (OPC UA for Machine Tools) is a companion specification for Machine Tools. You can create your own umati information model and implement it within your own provider application. We need the DI, IA and the Machinery nodesets as base and the MachineTool nodeset which contains the umati specification. The UA-Nodeset V1.04 of the OPC Foundation contains these specifications. There is an example for creating the base information model and also for implementing the specific AlertType.

Important As each Provider application has to implement his own unique namespace(s) it is not possible to load multiple umati provider applications as they are bringing the same integrated namespaces within their data models.

Any questions left?

Ask the community

---

Except where otherwise noted, content on this site is licensed under the The Siemens Inner Source License - 1.1.