Industrial Network Protocols. OPC UA. Part 2.

The OPC UA standard specifies the methods for exchanging messages between the OPC server and the client, regardless of the hardware and software platform, the type of interacting systems, and networks. ОРС UA provides reliable and secure communication, counteracts hacker attacks, and guarantees the identity of client and server information. The new standard uses the concept of an object, which is understood as a physical or abstract element of a system. Examples of objects include physical devices, including their systems and subsystems. A temperature sensor, for example, can be thought of as an object that includes a temperature value, a set of alarm parameters, and their thresholds. An object, by analogy with object-oriented programming, is defined as an instance of a class, and a class is treated as a data type. Objects include variables, events, and methods. OPC UA uses several data formats, the main ones being binary structures and XML documents. The data format can be defined by the OPC server vendor or by the standard. To work with arbitrary formats, the client can ask the server for information about the description of this format. In many cases, automatic recognition of the data format during transmission is used.


open62541 ( is an open-source and free implementation of OPC UA (OPC Unified Architecture) written in the common subset of the C99 and C++98 languages. The library is usable with all major compilers and provides the necessary tools to implement dedicated OPC UA clients and servers or to integrate OPC UA-based communication into existing applications. open62541 library is platform-independent. All platform-specific functionality is implemented via exchangeable plugins. Plugin implementations are provided for the major operating systems.

open62541 Features

open62541 implements the OPC UA binary protocol stack as well as a client and server SDK. It currently supports the Micro Embedded Device Server Profile plus some additional features. Server binaries can be well under 100kb in size, depending on the contained information model.

  • Communication Stack
    • OPC UA binary protocol
    • Chunking (splitting of large messages)
    • Exchangeable network layer (plugin) for using custom networking APIs (e.g. on embedded targets)
    • Encrypted communication
    • Asynchronous service requests in the client
  • Information model
    • Support for all OPC UA node types (including method nodes)
    • Support for adding and removing nodes and references also at runtime.
    • Support for inheritance and instantiation of object- and variable-types (custom constructor/destructor, instantiation of child nodes)
    • Access control for individual nodes
  • Subscriptions
    • Support for subscriptions/monitored items for data change notifications
    • Very low resource consumption for each monitored value (event-based server architecture)
  • Code-Generation
    • Support for generating data types from standard XML definitions
    • Support for generating server-side information models (nodesets) from standard XML definitions
git clone
cd open62541
git checkout v1.1.2
git submodule update --init --recursive
mkdir build && cd build
sudo make install
LIBS += -lopen62541

As an IDE I will use QT Creator. We continue to work with our basic project. Our task is to output the state of the variables and display them and change the value of variable 1, in our case we will turn on the relay on the PLC.

#include <open62541/client_config_default.h>
#include <open62541/client_highlevel.h>
#include <open62541/client_subscriptions.h>
#include <open62541/plugin/log_stdout.h>

#include <unistd.h>
#include <stdlib.h>

static void
handler_TheAnswerChanged(UA_Client *client, UA_UInt32 subId, void *subContext,
                         UA_UInt32 monId, void *monContext, UA_DataValue *value) {
    printf("The Answer has changed!\n");

static UA_StatusCode
nodeIter(UA_NodeId childId, UA_Boolean isInverse, UA_NodeId referenceTypeId, void *handle) {
        return UA_STATUSCODE_GOOD;
    UA_NodeId *parent = (UA_NodeId *)handle;
    printf("%d, %d --- %d ---> NodeId %d, %d\n",
           parent->namespaceIndex, parent->identifier.numeric,
           referenceTypeId.identifier.numeric, childId.namespaceIndex,

int main(int argc, char *argv[]) {
    UA_Client *client = UA_Client_new();

    /* Listing endpoints */
    UA_EndpointDescription* endpointArray = NULL;
    size_t endpointArraySize = 0;
    UA_StatusCode retval = UA_Client_getEndpoints(client, "opc.tcp://",
                                                  &endpointArraySize, &endpointArray);
    if(retval != UA_STATUSCODE_GOOD) {
        UA_Array_delete(endpointArray, endpointArraySize, &UA_TYPES[UA_TYPES_ENDPOINTDESCRIPTION]);
        return EXIT_FAILURE;
    printf("%i endpoints found\n", (int)endpointArraySize);
    for(size_t i=0;i<endpointArraySize;i++) {
        printf("URL of endpoint %i is %.*s\n", (int)i,
    UA_Array_delete(endpointArray,endpointArraySize, &UA_TYPES[UA_TYPES_ENDPOINTDESCRIPTION]);

    /* Connect to a server */
    /* anonymous connect would be: retval = UA_Client_connect(client, "opc.tcp://localhost:4840"); */
    retval = UA_Client_connect(client, "opc.tcp://");
    if(retval != UA_STATUSCODE_GOOD) {
        return EXIT_FAILURE;

    /* Browse some objects */
    printf("Browsing nodes in objects folder:\n");
    UA_BrowseRequest bReq;
    bReq.requestedMaxReferencesPerNode = 0;
    bReq.nodesToBrowse = UA_BrowseDescription_new();
    bReq.nodesToBrowseSize = 1;
    bReq.nodesToBrowse[0].nodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER); /* browse objects folder */
    bReq.nodesToBrowse[0].resultMask = UA_BROWSERESULTMASK_ALL; /* return everything */
    UA_BrowseResponse bResp = UA_Client_Service_browse(client, bReq);
    printf("%-9s %-16s %-16s %-16s\n", "NAMESPACE", "NODEID", "BROWSE NAME", "DISPLAY NAME");
    for(size_t i = 0; i < bResp.resultsSize; ++i) {
        for(size_t j = 0; j < bResp.results[i].referencesSize; ++j) {
            UA_ReferenceDescription *ref = &(bResp.results[i].references[j]);
            if(ref->nodeId.nodeId.identifierType == UA_NODEIDTYPE_NUMERIC) {
                printf("%-9d %-16d %-16.*s %-16.*s\n", ref->nodeId.nodeId.namespaceIndex,
                       ref->nodeId.nodeId.identifier.numeric, (int)ref->,
                       ref->, (int)ref->displayName.text.length,
            } else if(ref->nodeId.nodeId.identifierType == UA_NODEIDTYPE_STRING) {
                printf("%-9d %-16.*s %-16.*s %-16.*s\n", ref->nodeId.nodeId.namespaceIndex,
                       (int)ref->, ref->,
                       (int)ref->displayName.text.length, ref->;
            /* TODO: distinguish further types */

    /* Same thing, this time using the node iterator... */
    UA_NodeId *parent = UA_NodeId_new();
    UA_Client_forEachChildNodeCall(client, UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER),
                                   nodeIter, (void *) parent);

    /* Create a subscription */
    UA_CreateSubscriptionRequest request = UA_CreateSubscriptionRequest_default();
    UA_CreateSubscriptionResponse response = UA_Client_Subscriptions_create(client, request,
                                                                            NULL, NULL, NULL);

    UA_UInt32 subId = response.subscriptionId;
    if(response.responseHeader.serviceResult == UA_STATUSCODE_GOOD)
        printf("Create subscription succeeded, id %u\n", subId);

    UA_MonitoredItemCreateRequest monRequest =
        UA_MonitoredItemCreateRequest_default(UA_NODEID_NUMERIC(4, 3));

    UA_MonitoredItemCreateResult monResponse =
        UA_Client_MonitoredItems_createDataChange(client, response.subscriptionId,
                                                  monRequest, NULL, handler_TheAnswerChanged, NULL);
    if(monResponse.statusCode == UA_STATUSCODE_GOOD)
        printf("Monitoring 'ns=4,i=3', id %u\n", monResponse.monitoredItemId);

    /* The first publish request should return the initial value of the variable */
    UA_Client_run_iterate(client, 1000);

    /* Read attribute */
    UA_Boolean value = 0;
    printf("\nReading the value of node 'ns=4,i=3':\n");
    UA_Variant *val = UA_Variant_new();
    retval = UA_Client_readValueAttribute(client, UA_NODEID_NUMERIC(4, 3), val);
    if(retval == UA_STATUSCODE_GOOD && UA_Variant_isScalar(val) &&
        val->type == &UA_TYPES[UA_TYPES_BOOLEAN]) {
        value = *(UA_Boolean*)val->data;
        printf("the value is: %s\n", value == UA_TRUE ? "true": "false");

    /* Write node attribute */

    if(value == UA_FALSE)
        value = UA_TRUE;
        value = UA_FALSE;

    printf("\nWriting a value of node 'ns=4,i=3':\n");
    UA_WriteRequest wReq;
    wReq.nodesToWrite = UA_WriteValue_new();
    wReq.nodesToWriteSize = 1;
    wReq.nodesToWrite[0].nodeId = UA_NODEID_NUMERIC(4, 3);
    wReq.nodesToWrite[0].attributeId = UA_ATTRIBUTEID_VALUE;
    wReq.nodesToWrite[0].value.hasValue = true;
    wReq.nodesToWrite[0].value.value.type = &UA_TYPES[UA_TYPES_BOOLEAN];
    wReq.nodesToWrite[0].value.value.storageType = UA_VARIANT_DATA_NODELETE; /* do not free the integer on deletion */
    wReq.nodesToWrite[0] = &value;
    UA_WriteResponse wResp = UA_Client_Service_write(client, wReq);
    if(wResp.responseHeader.serviceResult == UA_STATUSCODE_GOOD)
        printf("the new value is: %s\n", value == UA_TRUE ? "true": "false");

    //sleep 5s

    /* Write node attribute (using the highlevel API) */

    if(value == UA_FALSE)
        value = UA_TRUE;
        value = UA_FALSE;

    UA_Variant *myVariant = UA_Variant_new();
    UA_Variant_setScalarCopy(myVariant, &value, &UA_TYPES[UA_TYPES_BOOLEAN]);
    UA_Client_writeValueAttribute(client, UA_NODEID_NUMERIC(4, 3), myVariant);

    return EXIT_SUCCESS;

Dear friends, thank you for reading this article to the end, you are great. I would be glad to hear and see your comments and suggestions for improving my articles. Although the OPC UA topic has not yet been fully disclosed, I still want to tell a lot more, in the future I will definitely add new articles to the OPC UA topic. Thank you very much for your attention.