Add example with IOP DataSets

examples/CMakeLists.txt

@@ -183,6 +183,7 @@ add_subdirectory(nodeset)
 if(UA_ENABLE_PUBSUB)
     add_example(tutorial_pubsub_connection pubsub/tutorial_pubsub_connection.c)
     add_example(tutorial_pubsub_publish pubsub/tutorial_pubsub_publish.c)
+	add_example(server_pubsub_publisher_iop pubsub/server_pubsub_publisher_iop.c)
     if(UA_ENABLE_AMALGAMATION)
         message(WARNING "PubSub subscriber tutorial (preview) can not be used with AMALGAMATION. Skipping tutorial_pubsub_subscribe.")
     else(NOT UA_ENABLE_AMALGAMATION)

examples/pubsub/server_pubsub_publisher_iop.c

@@ -0,0 +1,881 @@
+/* This work is licensed under a Creative Commons CCZero 1.0 Universal License.
+ * See http://creativecommons.org/publicdomain/zero/1.0/ for more information. */
+
+#include <open62541/plugin/log_stdout.h>
+#include <open62541/plugin/pubsub_udp.h>
+#include <open62541/server.h>
+#include <open62541/server_config_default.h>
+
+#include <signal.h>
+#include <stdlib.h>
+
+#define Publisher_ID 60
+
+static void addPublisher1(UA_Server *server, UA_NodeId publishedDataSetId);
+static void addPublisher2(UA_Server *server, UA_NodeId publishedDataSetId);
+
+static UA_NodeId ds1BoolToggleId;
+static int ds1BoolToggleCount = 0;
+static UA_Boolean ds1BoolToggleVal = false;
+static UA_NodeId ds1Int32Id;
+static UA_Int32 ds1Int32Val = 0;
+static UA_NodeId ds1Int32FastId;
+static UA_Int32 ds1Int32FastVal = 0;
+static UA_NodeId ds1DateTimeId;
+
+static UA_NodeId ds2BoolToggleId;
+static UA_Boolean ds2BoolToggleVal = false;
+static UA_NodeId ds2ByteId;
+static UA_Byte ds2ByteVal = 0;
+static UA_NodeId ds2Int16Id;
+static UA_Int16 ds2Int16Val = 0;
+static UA_NodeId ds2Int32Id;
+static UA_Int32 ds2Int32Val = 0;
+static UA_NodeId ds2Int64Id;
+static UA_Int64 ds2Int64Val = 0;
+static UA_NodeId ds2SByteId;
+static UA_SByte ds2SByteVal = 0;
+static UA_NodeId ds2UInt16Id;
+static UA_UInt16 ds2UInt16Val = 0;
+static UA_NodeId ds2UInt32Id;
+static UA_UInt32 ds2UInt32Val = 0;
+static UA_NodeId ds2UInt64Id;
+static UA_UInt64 ds2UInt64Val = 0;
+static UA_NodeId ds2FloatId;
+static UA_Float ds2FloatVal = 0;
+static UA_NodeId ds2DoubleId;
+static UA_Double ds2DoubleVal = 0;
+static UA_String *ds2StringArray = NULL;
+static size_t ds2StringArrayLen = 0;
+static size_t ds2StringIndex = 0;
+static UA_NodeId ds2StringId;
+static UA_NodeId ds2ByteStringId;
+static UA_NodeId ds2GuidId;
+static UA_NodeId ds2DateTimeId;
+static UA_NodeId ds2UInt32ArrId;
+static UA_UInt32 ds2UInt32ArrValue[10] = { 0, 10, 20, 30, 40, 50, 60, 70, 80, 90 };
+
+UA_NodeId connectionIdent, publishedDataSetIdent, writerGroupIdent;
+
+void
+timerCallback(UA_Server *server, void *data);
+
+static void
+addPubSubConnection(UA_Server *server, UA_String *transportProfile,
+    UA_NetworkAddressUrlDataType *networkAddressUrl) {
+    /* Details about the connection configuration and handling are located
+    * in the pubsub connection tutorial */
+    UA_PubSubConnectionConfig connectionConfig;
+    memset(&connectionConfig, 0, sizeof(connectionConfig));
+    connectionConfig.name = UA_STRING("UADP Connection 1");
+    connectionConfig.transportProfileUri = *transportProfile;
+    connectionConfig.enabled = UA_TRUE;
+    UA_Variant_setScalar(&connectionConfig.address, networkAddressUrl,
+        &UA_TYPES[UA_TYPES_NETWORKADDRESSURLDATATYPE]);
+    connectionConfig.publisherId.numeric = Publisher_ID;
+    UA_Server_addPubSubConnection(server, &connectionConfig, &connectionIdent);
+}
+
+static void addPublisher1(UA_Server *server, UA_NodeId publishedDataSetId) {
+    UA_NodeId folderId;
+    UA_ObjectAttributes oAttr = UA_ObjectAttributes_default;
+    oAttr.displayName = UA_LOCALIZEDTEXT("en-US", "Publisher 1");
+    UA_Server_addObjectNode(server, UA_NODEID_NULL,
+        UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER),
+        UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES),
+        UA_QUALIFIEDNAME(1, "Publisher 1"), UA_NODEID_NUMERIC(0, UA_NS0ID_BASEOBJECTTYPE),
+        oAttr, NULL, &folderId);
+
+    UA_NodeId_init(&ds1BoolToggleId);
+    UA_VariableAttributes boolToggleAttr = UA_VariableAttributes_default;
+    boolToggleAttr.valueRank = -1;
+    UA_NodeId_copy(&UA_TYPES[UA_TYPES_BOOLEAN].typeId, &boolToggleAttr.dataType);
+    UA_Variant_setScalar(&boolToggleAttr.value, &ds1BoolToggleVal, &UA_TYPES[UA_TYPES_BOOLEAN]);
+    boolToggleAttr.displayName = UA_LOCALIZEDTEXT("en-US", "BoolToggle");
+    UA_Server_addVariableNode(server, UA_NODEID_STRING(1, "Publisher1.BoolToggle"), folderId,
+        UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT),
+        UA_QUALIFIEDNAME(1, "BoolToggle"),
+        UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE), boolToggleAttr, NULL, &ds1BoolToggleId);
+
+    UA_NodeId_init(&ds1Int32Id);
+    UA_VariableAttributes int32Attr = UA_VariableAttributes_default;
+    int32Attr.valueRank = -1;
+    UA_NodeId_copy(&UA_TYPES[UA_TYPES_INT32].typeId, &int32Attr.dataType);
+    int32Attr.accessLevel = UA_ACCESSLEVELMASK_READ ^ UA_ACCESSLEVELMASK_WRITE;
+    UA_Variant_setScalar(&int32Attr.value, &ds1Int32Val, &UA_TYPES[UA_TYPES_INT32]);
+    int32Attr.displayName = UA_LOCALIZEDTEXT("en-US", "Int32");
+    UA_Server_addVariableNode(server, UA_NODEID_STRING(1, "Publisher1.Int32"), folderId,
+        UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT),
+        UA_QUALIFIEDNAME(1, "Int32"),
+        UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE), int32Attr, NULL, &ds1Int32Id);
+
+    UA_NodeId_init(&ds1Int32FastId);
+    UA_VariableAttributes int32FastAttr = UA_VariableAttributes_default;
+    int32FastAttr.valueRank = -1;
+    UA_NodeId_copy(&UA_TYPES[UA_TYPES_INT32].typeId, &int32FastAttr.dataType);
+    int32FastAttr.accessLevel = UA_ACCESSLEVELMASK_READ ^ UA_ACCESSLEVELMASK_WRITE;
+    UA_Variant_setScalar(&int32FastAttr.value, &ds1Int32FastVal, &UA_TYPES[UA_TYPES_INT32]);
+    int32FastAttr.displayName = UA_LOCALIZEDTEXT("en-US", "Int32Fast");
+    UA_Server_addVariableNode(server, UA_NODEID_STRING(1, "Publisher1.Int32Fast"), folderId,
+        UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT),
+        UA_QUALIFIEDNAME(1, "Int32Fast"),
+        UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE), int32FastAttr, NULL, &ds1Int32FastId);
+
+    UA_NodeId_init(&ds1DateTimeId);
+    UA_VariableAttributes dateTimeAttr = UA_VariableAttributes_default;
+    dateTimeAttr.valueRank = -1;
+    UA_NodeId_copy(&UA_TYPES[UA_TYPES_DATETIME].typeId, &dateTimeAttr.dataType);
+    dateTimeAttr.accessLevel = UA_ACCESSLEVELMASK_READ ^ UA_ACCESSLEVELMASK_WRITE;
+    UA_DateTime dateTimeVal = UA_DateTime_now();
+    UA_Variant_setScalar(&dateTimeAttr.value, &dateTimeVal, &UA_TYPES[UA_TYPES_DATETIME]);
+    dateTimeAttr.displayName = UA_LOCALIZEDTEXT("en-US", "DateTime");
+    UA_Server_addVariableNode(server, UA_NODEID_STRING(1, "Publisher1.DateTime"), folderId,
+        UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT),
+        UA_QUALIFIEDNAME(1, "DateTime"),
+        UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE), dateTimeAttr, NULL, &ds1DateTimeId);
+
+    if (!UA_NodeId_equal(&publishedDataSetId, &UA_NODEID_NULL))
+    {
+        // Create and add fields to the PublishedDataSet
+        UA_DataSetFieldConfig boolToggleConfig;
+        memset(&boolToggleConfig, 0, sizeof(UA_DataSetFieldConfig));
+        boolToggleConfig.field.variable.fieldNameAlias = UA_STRING("BoolToggle");
+        boolToggleConfig.field.variable.promotedField = false;
+        boolToggleConfig.field.variable.publishParameters.publishedVariable = ds1BoolToggleId;
+        boolToggleConfig.field.variable.publishParameters.attributeId = UA_ATTRIBUTEID_VALUE;
+
+        UA_DataSetFieldConfig int32Config;
+        memset(&int32Config, 0, sizeof(UA_DataSetFieldConfig));
+        int32Config.field.variable.fieldNameAlias = UA_STRING("Int32");
+        int32Config.field.variable.promotedField = false;
+        int32Config.field.variable.publishParameters.publishedVariable = ds1Int32Id;
+        int32Config.field.variable.publishParameters.attributeId = UA_ATTRIBUTEID_VALUE;
+
+        UA_DataSetFieldConfig int32FastConfig;
+        memset(&int32FastConfig, 0, sizeof(UA_DataSetFieldConfig));
+        int32FastConfig.field.variable.fieldNameAlias = UA_STRING("Int32Fast");
+        int32FastConfig.field.variable.promotedField = false;
+        int32FastConfig.field.variable.publishParameters.publishedVariable = ds1Int32FastId;
+        int32FastConfig.field.variable.publishParameters.attributeId = UA_ATTRIBUTEID_VALUE;
+
+        UA_DataSetFieldConfig dateTimeConfig;
+        memset(&dateTimeConfig, 0, sizeof(UA_DataSetFieldConfig));
+        dateTimeConfig.field.variable.fieldNameAlias = UA_STRING("DateTime");
+        dateTimeConfig.field.variable.promotedField = false;
+        dateTimeConfig.field.variable.publishParameters.publishedVariable = ds1DateTimeId;
+        dateTimeConfig.field.variable.publishParameters.attributeId = UA_ATTRIBUTEID_VALUE;
+
+        UA_NodeId f1, f2, f3, f4;
+        // add fields in reverse order, because all fields are added to the beginning of the list
+        UA_Server_addDataSetField(server, publishedDataSetId, &dateTimeConfig, &f4);
+        UA_Server_addDataSetField(server, publishedDataSetId, &int32FastConfig, &f3);
+        UA_Server_addDataSetField(server, publishedDataSetId, &int32Config, &f2);
+        UA_Server_addDataSetField(server, publishedDataSetId, &boolToggleConfig, &f1);
+    }
+}
+
+static void addPublisher2(UA_Server *server, UA_NodeId publishedDataSetId) {
+    UA_NodeId folderId;
+    UA_ObjectAttributes oAttr = UA_ObjectAttributes_default;
+    oAttr.displayName = UA_LOCALIZEDTEXT("en-US", "Publisher 2");
+    UA_Server_addObjectNode(server, UA_NODEID_NULL,
+        UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER),
+        UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES),
+        UA_QUALIFIEDNAME(1, "Publisher 2"), UA_NODEID_NUMERIC(0, UA_NS0ID_BASEOBJECTTYPE),
+        oAttr, NULL, &folderId);
+
+    UA_NodeId_init(&ds2BoolToggleId);
+    UA_VariableAttributes boolToggleAttr = UA_VariableAttributes_default;
+    boolToggleAttr.valueRank = -1;
+    UA_NodeId_copy(&UA_TYPES[UA_TYPES_BOOLEAN].typeId, &boolToggleAttr.dataType);
+    UA_Variant_setScalar(&boolToggleAttr.value, &ds2BoolToggleVal, &UA_TYPES[UA_TYPES_BOOLEAN]);
+    boolToggleAttr.displayName = UA_LOCALIZEDTEXT("en-US", "BoolToggle");
+    UA_Server_addVariableNode(server, UA_NODEID_STRING(1, "Publisher2.BoolToggle"), folderId,
+        UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT),
+        UA_QUALIFIEDNAME(1, "BoolToggle"),
+        UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE), boolToggleAttr, NULL, &ds2BoolToggleId);
+
+    UA_NodeId_init(&ds2ByteId);
+    UA_VariableAttributes byteAttr = UA_VariableAttributes_default;
+    byteAttr.valueRank = -1;
+    UA_NodeId_copy(&UA_TYPES[UA_TYPES_BYTE].typeId, &byteAttr.dataType);
+    byteAttr.accessLevel = UA_ACCESSLEVELMASK_READ ^ UA_ACCESSLEVELMASK_WRITE;
+    UA_Variant_setScalar(&byteAttr.value, &ds2ByteVal, &UA_TYPES[UA_TYPES_BYTE]);
+    byteAttr.displayName = UA_LOCALIZEDTEXT("en-US", "Byte");
+    UA_Server_addVariableNode(server, UA_NODEID_STRING(1, "Publisher2.Byte"), folderId,
+        UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT),
+        UA_QUALIFIEDNAME(1, "Byte"),
+        UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE), byteAttr, NULL, &ds2ByteId);
+
+    UA_NodeId_init(&ds2Int16Id);
+    UA_VariableAttributes int16Attr = UA_VariableAttributes_default;
+    int16Attr.valueRank = -1;
+    UA_NodeId_copy(&UA_TYPES[UA_TYPES_INT16].typeId, &int16Attr.dataType);
+    int16Attr.accessLevel = UA_ACCESSLEVELMASK_READ ^ UA_ACCESSLEVELMASK_WRITE;
+    UA_Variant_setScalar(&int16Attr.value, &ds2Int16Val, &UA_TYPES[UA_TYPES_INT16]);
+    int16Attr.displayName = UA_LOCALIZEDTEXT("en-US", "Int16");
+    UA_Server_addVariableNode(server, UA_NODEID_STRING(1, "Publisher2.Int16"), folderId,
+        UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT),
+        UA_QUALIFIEDNAME(1, "Int16"),
+        UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE), int16Attr, NULL, &ds2Int16Id);
+
+    UA_NodeId_init(&ds2Int32Id);
+    UA_VariableAttributes int32Attr = UA_VariableAttributes_default;
+    int32Attr.valueRank = -1;
+    UA_NodeId_copy(&UA_TYPES[UA_TYPES_INT32].typeId, &int32Attr.dataType);
+    int32Attr.accessLevel = UA_ACCESSLEVELMASK_READ ^ UA_ACCESSLEVELMASK_WRITE;
+    UA_Variant_setScalar(&int32Attr.value, &ds2Int32Val, &UA_TYPES[UA_TYPES_INT32]);
+    int32Attr.displayName = UA_LOCALIZEDTEXT("en-US", "Int32");
+    UA_Server_addVariableNode(server, UA_NODEID_STRING(1, "Publisher2.Int32"), folderId,
+        UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT),
+        UA_QUALIFIEDNAME(1, "Int32"),
+        UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE), int32Attr, NULL, &ds2Int32Id);
+
+    UA_NodeId_init(&ds2Int64Id);
+    UA_VariableAttributes int64Attr = UA_VariableAttributes_default;
+    int64Attr.valueRank = -1;
+    UA_NodeId_copy(&UA_TYPES[UA_TYPES_INT64].typeId, &int64Attr.dataType);
+    int64Attr.accessLevel = UA_ACCESSLEVELMASK_READ ^ UA_ACCESSLEVELMASK_WRITE;
+    UA_Variant_setScalar(&int64Attr.value, &ds2Int64Val, &UA_TYPES[UA_TYPES_INT64]);
+    int64Attr.displayName = UA_LOCALIZEDTEXT("en-US", "Int64");
+    UA_Server_addVariableNode(server, UA_NODEID_STRING(1, "Publisher2.Int64"), folderId,
+        UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT),
+        UA_QUALIFIEDNAME(1, "Int64"),
+        UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE), int64Attr, NULL, &ds2Int64Id);
+
+    UA_NodeId_init(&ds2SByteId);
+    UA_VariableAttributes sbyteAttr = UA_VariableAttributes_default;
+    sbyteAttr.valueRank = -1;
+    UA_NodeId_copy(&UA_TYPES[UA_TYPES_SBYTE].typeId, &sbyteAttr.dataType);
+    sbyteAttr.accessLevel = UA_ACCESSLEVELMASK_READ ^ UA_ACCESSLEVELMASK_WRITE;
+    UA_Variant_setScalar(&sbyteAttr.value, &ds2SByteVal, &UA_TYPES[UA_TYPES_SBYTE]);
+    sbyteAttr.displayName = UA_LOCALIZEDTEXT("en-US", "SByte");
+    UA_Server_addVariableNode(server, UA_NODEID_STRING(1, "Publisher2.SByte"), folderId,
+        UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT),
+        UA_QUALIFIEDNAME(1, "SByte"),
+        UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE), sbyteAttr, NULL, &ds2SByteId);
+
+    UA_NodeId_init(&ds2UInt16Id);
+    UA_VariableAttributes uint16Attr = UA_VariableAttributes_default;
+    uint16Attr.valueRank = -1;
+    UA_NodeId_copy(&UA_TYPES[UA_TYPES_UINT16].typeId, &uint16Attr.dataType);
+    uint16Attr.accessLevel = UA_ACCESSLEVELMASK_READ ^ UA_ACCESSLEVELMASK_WRITE;
+    UA_Variant_setScalar(&uint16Attr.value, &ds2UInt16Val, &UA_TYPES[UA_TYPES_UINT16]);
+    uint16Attr.displayName = UA_LOCALIZEDTEXT("en-US", "UInt16");
+    UA_Server_addVariableNode(server, UA_NODEID_STRING(1, "Publisher2.UInt16"), folderId,
+        UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT),
+        UA_QUALIFIEDNAME(1, "UInt16"),
+        UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE), uint16Attr, NULL, &ds2UInt16Id);
+
+    UA_NodeId_init(&ds2UInt32Id);
+    UA_VariableAttributes uint32Attr = UA_VariableAttributes_default;
+    uint32Attr.valueRank = -1;
+    UA_NodeId_copy(&UA_TYPES[UA_TYPES_UINT32].typeId, &uint32Attr.dataType);
+    uint32Attr.accessLevel = UA_ACCESSLEVELMASK_READ ^ UA_ACCESSLEVELMASK_WRITE;
+    UA_Variant_setScalar(&uint32Attr.value, &ds2UInt32Val, &UA_TYPES[UA_TYPES_UINT32]);
+    uint32Attr.displayName = UA_LOCALIZEDTEXT("en-US", "UInt32");
+    UA_Server_addVariableNode(server, UA_NODEID_STRING(1, "Publisher2.UInt32"), folderId,
+        UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT),
+        UA_QUALIFIEDNAME(1, "UInt32"),
+        UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE), uint32Attr, NULL, &ds2UInt32Id);
+
+    UA_NodeId_init(&ds2UInt64Id);
+    UA_VariableAttributes uint64Attr = UA_VariableAttributes_default;
+    uint64Attr.valueRank = -1;
+    UA_NodeId_copy(&UA_TYPES[UA_TYPES_UINT64].typeId, &uint64Attr.dataType);
+    uint64Attr.accessLevel = UA_ACCESSLEVELMASK_READ ^ UA_ACCESSLEVELMASK_WRITE;
+    UA_Variant_setScalar(&uint64Attr.value, &ds2UInt64Val, &UA_TYPES[UA_TYPES_UINT64]);
+    uint64Attr.displayName = UA_LOCALIZEDTEXT("en-US", "UInt64");
+    UA_Server_addVariableNode(server, UA_NODEID_STRING(1, "Publisher2.UInt64"), folderId,
+        UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT),
+        UA_QUALIFIEDNAME(1, "UInt64"),
+        UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE), uint64Attr, NULL, &ds2UInt64Id);
+
+    UA_NodeId_init(&ds2FloatId);
+    UA_VariableAttributes floatAttr = UA_VariableAttributes_default;
+    floatAttr.valueRank = -1;
+    UA_NodeId_copy(&UA_TYPES[UA_TYPES_FLOAT].typeId, &floatAttr.dataType);
+    floatAttr.accessLevel = UA_ACCESSLEVELMASK_READ ^ UA_ACCESSLEVELMASK_WRITE;
+    UA_Variant_setScalar(&floatAttr.value, &ds2FloatVal, &UA_TYPES[UA_TYPES_FLOAT]);
+    floatAttr.displayName = UA_LOCALIZEDTEXT("en-US", "Float");
+    UA_Server_addVariableNode(server, UA_NODEID_STRING(1, "Publisher2.Float"), folderId,
+        UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT),
+        UA_QUALIFIEDNAME(1, "Float"),
+        UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE), floatAttr, NULL, &ds2FloatId);
+
+    UA_NodeId_init(&ds2DoubleId);
+    UA_VariableAttributes doubleAttr = UA_VariableAttributes_default;
+    doubleAttr.valueRank = -1;
+    UA_NodeId_copy(&UA_TYPES[UA_TYPES_DOUBLE].typeId, &doubleAttr.dataType);
+    doubleAttr.accessLevel = UA_ACCESSLEVELMASK_READ ^ UA_ACCESSLEVELMASK_WRITE;
+    UA_Variant_setScalar(&doubleAttr.value, &ds2DoubleVal, &UA_TYPES[UA_TYPES_DOUBLE]);
+    doubleAttr.displayName = UA_LOCALIZEDTEXT("en-US", "Double");
+    UA_Server_addVariableNode(server, UA_NODEID_STRING(1, "Publisher2.Double"), folderId,
+        UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT),
+        UA_QUALIFIEDNAME(1, "Double"),
+        UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE), doubleAttr, NULL, &ds2DoubleId);
+
+    ds2StringArrayLen = 26;
+    ds2StringArray = (UA_String*)UA_Array_new(ds2StringArrayLen, &UA_TYPES[UA_TYPES_STRING]);
+    ds2StringArray[0] = UA_STRING_ALLOC("Alpha");
+    ds2StringArray[1] = UA_STRING_ALLOC("Bravo");
+    ds2StringArray[2] = UA_STRING_ALLOC("Charlie");
+    ds2StringArray[3] = UA_STRING_ALLOC("Delta");
+    ds2StringArray[4] = UA_STRING_ALLOC("Echo");
+    ds2StringArray[5] = UA_STRING_ALLOC("Foxtrot");
+    ds2StringArray[6] = UA_STRING_ALLOC("Golf");
+    ds2StringArray[7] = UA_STRING_ALLOC("Hotel");
+    ds2StringArray[8] = UA_STRING_ALLOC("India");
+    ds2StringArray[9] = UA_STRING_ALLOC("Juliet");
+    ds2StringArray[10] = UA_STRING_ALLOC("Kilo");
+    ds2StringArray[11] = UA_STRING_ALLOC("Lima");
+    ds2StringArray[12] = UA_STRING_ALLOC("Mike");
+    ds2StringArray[13] = UA_STRING_ALLOC("November");
+    ds2StringArray[14] = UA_STRING_ALLOC("Oscar");
+    ds2StringArray[15] = UA_STRING_ALLOC("Papa");
+    ds2StringArray[16] = UA_STRING_ALLOC("Quebec");
+    ds2StringArray[17] = UA_STRING_ALLOC("Romeo");
+    ds2StringArray[18] = UA_STRING_ALLOC("Sierra");
+    ds2StringArray[19] = UA_STRING_ALLOC("Tango");
+    ds2StringArray[20] = UA_STRING_ALLOC("Uniform");
+    ds2StringArray[21] = UA_STRING_ALLOC("Victor");
+    ds2StringArray[22] = UA_STRING_ALLOC("Whiskey");
+    ds2StringArray[23] = UA_STRING_ALLOC("X-ray");
+    ds2StringArray[24] = UA_STRING_ALLOC("Yankee");
+    ds2StringArray[25] = UA_STRING_ALLOC("Zulu");
+
+    UA_String stringVal;
+    UA_String_init(&stringVal);
+
+    UA_NodeId_init(&ds2StringId);
+    UA_VariableAttributes stringAttr = UA_VariableAttributes_default;
+    stringAttr.valueRank = -1;
+    UA_NodeId_copy(&UA_TYPES[UA_TYPES_STRING].typeId, &stringAttr.dataType);
+    stringAttr.accessLevel = UA_ACCESSLEVELMASK_READ ^ UA_ACCESSLEVELMASK_WRITE;
+    UA_Variant_setScalar(&stringAttr.value, &stringVal, &UA_TYPES[UA_TYPES_STRING]);
+    stringAttr.displayName = UA_LOCALIZEDTEXT("en-US", "String");
+    UA_Server_addVariableNode(server, UA_NODEID_STRING(1, "Publisher2.String"), folderId,
+        UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT),
+        UA_QUALIFIEDNAME(1, "String"),
+        UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE), stringAttr, NULL, &ds2StringId);
+
+    UA_Byte data[] = { 0x00 };
+    UA_ByteString byteStringVal = { 1, data };
+
+    UA_NodeId_init(&ds2ByteStringId);
+    UA_VariableAttributes byteStringAttr = UA_VariableAttributes_default;
+    byteStringAttr.valueRank = -1;
+    UA_NodeId_copy(&UA_TYPES[UA_TYPES_BYTESTRING].typeId, &byteStringAttr.dataType);
+    byteStringAttr.accessLevel = UA_ACCESSLEVELMASK_READ ^ UA_ACCESSLEVELMASK_WRITE;
+    UA_Variant_setScalar(&byteStringAttr.value, &byteStringVal, &UA_TYPES[UA_TYPES_BYTESTRING]);
+    byteStringAttr.displayName = UA_LOCALIZEDTEXT("en-US", "ByteString");
+    UA_Server_addVariableNode(server, UA_NODEID_STRING(1, "Publisher2.ByteString"), folderId,
+        UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT),
+        UA_QUALIFIEDNAME(1, "ByteString"),
+        UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE), byteStringAttr, NULL, &ds2ByteStringId);
+
+    UA_Guid guidVal = UA_Guid_random();
+    UA_NodeId_init(&ds2GuidId);
+    UA_VariableAttributes guidAttr = UA_VariableAttributes_default;
+    guidAttr.valueRank = -1;
+    UA_NodeId_copy(&UA_TYPES[UA_TYPES_GUID].typeId, &guidAttr.dataType);
+    guidAttr.accessLevel = UA_ACCESSLEVELMASK_READ ^ UA_ACCESSLEVELMASK_WRITE;
+    UA_Variant_setScalar(&guidAttr.value, &guidVal, &UA_TYPES[UA_TYPES_GUID]);
+    guidAttr.displayName = UA_LOCALIZEDTEXT("en-US", "Guid");
+    UA_Server_addVariableNode(server, UA_NODEID_STRING(1, "Publisher2.Guid"), folderId,
+        UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT),
+        UA_QUALIFIEDNAME(1, "Guid"),
+        UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE), guidAttr, NULL, &ds2GuidId);
+
+    UA_NodeId_init(&ds2DateTimeId);
+    UA_VariableAttributes dateTimeAttr = UA_VariableAttributes_default;
+    dateTimeAttr.valueRank = -1;
+    UA_NodeId_copy(&UA_TYPES[UA_TYPES_DATETIME].typeId, &dateTimeAttr.dataType);
+    dateTimeAttr.accessLevel = UA_ACCESSLEVELMASK_READ ^ UA_ACCESSLEVELMASK_WRITE;
+    UA_DateTime dateTimeVal = UA_DateTime_now();
+    UA_Variant_setScalar(&dateTimeAttr.value, &dateTimeVal, &UA_TYPES[UA_TYPES_DATETIME]);
+    dateTimeAttr.displayName = UA_LOCALIZEDTEXT("en-US", "DateTime");
+    UA_Server_addVariableNode(server, UA_NODEID_STRING(1, "Publisher2.DateTime"), folderId,
+        UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT),
+        UA_QUALIFIEDNAME(1, "DateTime"),
+        UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE), dateTimeAttr, NULL, &ds2DateTimeId);
+
+    // UInt32Array
+    UA_NodeId_init(&ds2UInt32ArrId);
+    UA_VariableAttributes uint32ArrAttr = UA_VariableAttributes_default;
+    uint32ArrAttr.valueRank = 1;    // 1-dimensional array
+    uint32ArrAttr.arrayDimensionsSize = 1;
+    UA_UInt32 arrayDims[1] = { 10 };
+    uint32ArrAttr.arrayDimensions = arrayDims;
+
+    UA_NodeId_copy(&UA_TYPES[UA_TYPES_UINT32].typeId, &uint32ArrAttr.dataType);
+    uint32ArrAttr.accessLevel = UA_ACCESSLEVELMASK_READ ^ UA_ACCESSLEVELMASK_WRITE;
+
+    UA_Variant_setArray(&uint32ArrAttr.value, ds2UInt32ArrValue, 10, &UA_TYPES[UA_TYPES_UINT32]);
+    uint32ArrAttr.displayName = UA_LOCALIZEDTEXT("en-US", "UInt32Array");
+    UA_Server_addVariableNode(server, UA_NODEID_STRING(1, "Publisher2.UInt32Array"), folderId,
+        UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT),
+        UA_QUALIFIEDNAME(1, "UInt32Array"),
+        UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE), uint32ArrAttr, NULL, &ds2UInt32ArrId);
+
+    if (!UA_NodeId_equal(&publishedDataSetId, &UA_NODEID_NULL))
+    {
+        // Create and add fields to the PublishedDataSet
+        UA_DataSetFieldConfig boolToggleConfig;
+        memset(&boolToggleConfig, 0, sizeof(UA_DataSetFieldConfig));
+        boolToggleConfig.field.variable.fieldNameAlias = UA_STRING("BoolToggle");
+        boolToggleConfig.field.variable.promotedField = false;
+        boolToggleConfig.field.variable.publishParameters.publishedVariable = ds2BoolToggleId;
+        boolToggleConfig.field.variable.publishParameters.attributeId = UA_ATTRIBUTEID_VALUE;
+
+        UA_DataSetFieldConfig byteConfig;
+        memset(&byteConfig, 0, sizeof(UA_DataSetFieldConfig));
+        byteConfig.field.variable.fieldNameAlias = UA_STRING("Byte");
+        byteConfig.field.variable.promotedField = false;
+        byteConfig.field.variable.publishParameters.publishedVariable = ds2ByteId;
+        byteConfig.field.variable.publishParameters.attributeId = UA_ATTRIBUTEID_VALUE;
+
+        UA_DataSetFieldConfig int16Config;
+        memset(&int16Config, 0, sizeof(UA_DataSetFieldConfig));
+        int16Config.field.variable.fieldNameAlias = UA_STRING("Int16");
+        int16Config.field.variable.promotedField = false;
+        int16Config.field.variable.publishParameters.publishedVariable = ds2Int16Id;
+        int16Config.field.variable.publishParameters.attributeId = UA_ATTRIBUTEID_VALUE;
+
+        UA_DataSetFieldConfig int32Config;
+        memset(&int32Config, 0, sizeof(UA_DataSetFieldConfig));
+        int32Config.field.variable.fieldNameAlias = UA_STRING("Int32");
+        int32Config.field.variable.promotedField = false;
+        int32Config.field.variable.publishParameters.publishedVariable = ds2Int32Id;
+        int32Config.field.variable.publishParameters.attributeId = UA_ATTRIBUTEID_VALUE;
+
+        UA_DataSetFieldConfig int64Config;
+        memset(&int64Config, 0, sizeof(UA_DataSetFieldConfig));
+        int64Config.field.variable.fieldNameAlias = UA_STRING("Int64");
+        int64Config.field.variable.promotedField = false;
+        int64Config.field.variable.publishParameters.publishedVariable = ds2Int64Id;
+        int64Config.field.variable.publishParameters.attributeId = UA_ATTRIBUTEID_VALUE;
+
+        UA_DataSetFieldConfig sbyteConfig;
+        memset(&sbyteConfig, 0, sizeof(UA_DataSetFieldConfig));
+        sbyteConfig.field.variable.fieldNameAlias = UA_STRING("SByte");
+        sbyteConfig.field.variable.promotedField = false;
+        sbyteConfig.field.variable.publishParameters.publishedVariable = ds2SByteId;
+        sbyteConfig.field.variable.publishParameters.attributeId = UA_ATTRIBUTEID_VALUE;
+
+        UA_DataSetFieldConfig uint16Config;
+        memset(&uint16Config, 0, sizeof(UA_DataSetFieldConfig));
+        uint16Config.field.variable.fieldNameAlias = UA_STRING("UInt16");
+        uint16Config.field.variable.promotedField = false;
+        uint16Config.field.variable.publishParameters.publishedVariable = ds2UInt16Id;
+        uint16Config.field.variable.publishParameters.attributeId = UA_ATTRIBUTEID_VALUE;
+
+        UA_DataSetFieldConfig uint32Config;
+        memset(&uint32Config, 0, sizeof(UA_DataSetFieldConfig));
+        uint32Config.field.variable.fieldNameAlias = UA_STRING("UInt32");
+        uint32Config.field.variable.promotedField = false;
+        uint32Config.field.variable.publishParameters.publishedVariable = ds2UInt32Id;
+        uint32Config.field.variable.publishParameters.attributeId = UA_ATTRIBUTEID_VALUE;
+
+        UA_DataSetFieldConfig uint64Config;
+        memset(&uint64Config, 0, sizeof(UA_DataSetFieldConfig));
+        uint64Config.field.variable.fieldNameAlias = UA_STRING("UInt64");
+        uint64Config.field.variable.promotedField = false;
+        uint64Config.field.variable.publishParameters.publishedVariable = ds2UInt64Id;
+        uint64Config.field.variable.publishParameters.attributeId = UA_ATTRIBUTEID_VALUE;
+
+        UA_DataSetFieldConfig floatConfig;
+        memset(&floatConfig, 0, sizeof(UA_DataSetFieldConfig));
+        floatConfig.field.variable.fieldNameAlias = UA_STRING("Float");
+        floatConfig.field.variable.promotedField = false;
+        floatConfig.field.variable.publishParameters.publishedVariable = ds2FloatId;
+        floatConfig.field.variable.publishParameters.attributeId = UA_ATTRIBUTEID_VALUE;
+
+        UA_DataSetFieldConfig doubleConfig;
+        memset(&doubleConfig, 0, sizeof(UA_DataSetFieldConfig));
+        doubleConfig.field.variable.fieldNameAlias = UA_STRING("Double");
+        doubleConfig.field.variable.promotedField = false;
+        doubleConfig.field.variable.publishParameters.publishedVariable = ds2DoubleId;
+        doubleConfig.field.variable.publishParameters.attributeId = UA_ATTRIBUTEID_VALUE;
+
+        UA_DataSetFieldConfig stringConfig;
+        memset(&stringConfig, 0, sizeof(UA_DataSetFieldConfig));
+        stringConfig.field.variable.fieldNameAlias = UA_STRING("String");
+        stringConfig.field.variable.promotedField = false;
+        stringConfig.field.variable.publishParameters.publishedVariable = ds2StringId;
+        stringConfig.field.variable.publishParameters.attributeId = UA_ATTRIBUTEID_VALUE;
+
+        UA_DataSetFieldConfig byteStringConfig;
+        memset(&byteStringConfig, 0, sizeof(UA_DataSetFieldConfig));
+        byteStringConfig.field.variable.fieldNameAlias = UA_STRING("ByteString");
+        byteStringConfig.field.variable.promotedField = false;
+        byteStringConfig.field.variable.publishParameters.publishedVariable = ds2ByteStringId;
+        byteStringConfig.field.variable.publishParameters.attributeId = UA_ATTRIBUTEID_VALUE;
+
+        UA_DataSetFieldConfig guidConfig;
+        memset(&guidConfig, 0, sizeof(UA_DataSetFieldConfig));
+        guidConfig.field.variable.fieldNameAlias = UA_STRING("Guid");
+        guidConfig.field.variable.promotedField = false;
+        guidConfig.field.variable.publishParameters.publishedVariable = ds2GuidId;
+        guidConfig.field.variable.publishParameters.attributeId = UA_ATTRIBUTEID_VALUE;
+
+        UA_DataSetFieldConfig dateTimeConfig;
+        memset(&dateTimeConfig, 0, sizeof(UA_DataSetFieldConfig));
+        dateTimeConfig.field.variable.fieldNameAlias = UA_STRING("DateTime");
+        dateTimeConfig.field.variable.promotedField = false;
+        dateTimeConfig.field.variable.publishParameters.publishedVariable = ds2DateTimeId;
+        dateTimeConfig.field.variable.publishParameters.attributeId = UA_ATTRIBUTEID_VALUE;
+
+        UA_DataSetFieldConfig uint32ArrConfig;
+        memset(&uint32ArrConfig, 0, sizeof(UA_DataSetFieldConfig));
+        uint32ArrConfig.field.variable.fieldNameAlias = UA_STRING("UInt32Array");
+        uint32ArrConfig.field.variable.promotedField = false;
+        uint32ArrConfig.field.variable.publishParameters.publishedVariable = ds2UInt32ArrId;
+        uint32ArrConfig.field.variable.publishParameters.attributeId = UA_ATTRIBUTEID_VALUE;
+
+        UA_NodeId f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, f16;
+        // add fields in reverse order, because all fields are added to the beginning of the list
+        UA_Server_addDataSetField(server, publishedDataSetId, &uint32ArrConfig, &f16);
+        UA_Server_addDataSetField(server, publishedDataSetId, &dateTimeConfig, &f15);
+        UA_Server_addDataSetField(server, publishedDataSetId, &guidConfig, &f14);
+        UA_Server_addDataSetField(server, publishedDataSetId, &byteStringConfig, &f13);
+        UA_Server_addDataSetField(server, publishedDataSetId, &stringConfig, &f12);
+        UA_Server_addDataSetField(server, publishedDataSetId, &doubleConfig, &f11);
+        UA_Server_addDataSetField(server, publishedDataSetId, &floatConfig, &f10);
+        UA_Server_addDataSetField(server, publishedDataSetId, &uint64Config, &f9);
+        UA_Server_addDataSetField(server, publishedDataSetId, &uint32Config, &f8);
+        UA_Server_addDataSetField(server, publishedDataSetId, &uint16Config, &f7);
+        UA_Server_addDataSetField(server, publishedDataSetId, &sbyteConfig, &f6);
+        UA_Server_addDataSetField(server, publishedDataSetId, &int64Config, &f5);
+        UA_Server_addDataSetField(server, publishedDataSetId, &int32Config, &f4);
+        UA_Server_addDataSetField(server, publishedDataSetId, &int16Config, &f3);
+        UA_Server_addDataSetField(server, publishedDataSetId, &byteConfig, &f2);
+        UA_Server_addDataSetField(server, publishedDataSetId, &boolToggleConfig, &f1);
+    }
+}
+
+void
+timerCallback(UA_Server *server, void *data) {
+    // DataSet 1
+    // BoolToggle
+    ds1BoolToggleCount++;
+    UA_Variant tmpVari;
+    if (ds1BoolToggleCount >= 3) {
+        if (ds1BoolToggleVal) {
+            ds1BoolToggleVal = false;
+        }
+        else {
+            ds1BoolToggleVal = true;
+        }
+
+        // neuen Wert schreiben
+        UA_Variant_init(&tmpVari);
+
+        UA_Variant_setScalar(&tmpVari, &ds1BoolToggleVal, &UA_TYPES[UA_TYPES_BOOLEAN]);
+        UA_Server_writeValue(server, ds1BoolToggleId, tmpVari);
+        //UA_Variant_clear(&tmpVari);
+        ds1BoolToggleCount = 0;
+    }
+
+    // Int32
+    UA_Variant_init(&tmpVari);
+    ds1Int32Val++;
+    if (ds1Int32Val > 10000) {
+        ds1Int32Val = 0;
+    }
+    UA_Variant_setScalar(&tmpVari, &ds1Int32Val, &UA_TYPES[UA_TYPES_INT32]);
+    UA_Server_writeValue(server, ds1Int32Id, tmpVari);
+    //UA_Variant_clear(&tmpVari);
+
+    // Int32Fast
+    UA_Variant_init(&tmpVari);
+    ds1Int32FastVal += 100;
+    if (ds1Int32FastVal > 10000) {
+        ds1Int32FastVal = 0;
+    }
+    UA_Variant_setScalar(&tmpVari, &ds1Int32FastVal, &UA_TYPES[UA_TYPES_INT32]);
+    UA_Server_writeValue(server, ds1Int32FastId, tmpVari);
+    //UA_Variant_clear(&tmpVari);
+
+    // DateTime
+    UA_Variant_init(&tmpVari);
+    UA_DateTime tmpTime = UA_DateTime_now();
+    UA_Variant_setScalar(&tmpVari, &tmpTime, &UA_TYPES[UA_TYPES_DATETIME]);
+    UA_Server_writeValue(server, ds1DateTimeId, tmpVari);
+
+    // DataSet 2
+    UA_Server_writeValue(server, ds2DateTimeId, tmpVari);
+    //UA_Variant_clear(&tmpVari);
+
+    // BoolToggle
+    if (ds2BoolToggleVal)
+    {
+        ds2BoolToggleVal = false;
+    }
+    else
+    {
+        ds2BoolToggleVal = true;
+    }
+
+    // neuen Wert schreiben 
+    UA_Variant_init(&tmpVari);
+
+    UA_Variant_setScalar(&tmpVari, &ds2BoolToggleVal, &UA_TYPES[UA_TYPES_BOOLEAN]);
+    UA_Server_writeValue(server, ds2BoolToggleId, tmpVari);
+    //UA_Variant_clear(&tmpVari);
+
+    // Byte
+    UA_Variant_init(&tmpVari);
+    ds2ByteVal++;
+    UA_Variant_setScalar(&tmpVari, &ds2ByteVal, &UA_TYPES[UA_TYPES_BYTE]);
+    UA_Server_writeValue(server, ds2ByteId, tmpVari);
+    //UA_Variant_clear(&tmpVari);
+
+    // Int16
+    UA_Variant_init(&tmpVari);
+    ds2Int16Val++;
+    UA_Variant_setScalar(&tmpVari, &ds2Int16Val, &UA_TYPES[UA_TYPES_INT16]);
+    UA_Server_writeValue(server, ds2Int16Id, tmpVari);
+    //UA_Variant_clear(&tmpVari);
+
+    // Int32
+    UA_Variant_init(&tmpVari);
+    ds2Int32Val++;
+    UA_Variant_setScalar(&tmpVari, &ds2Int32Val, &UA_TYPES[UA_TYPES_INT32]);
+    UA_Server_writeValue(server, ds2Int32Id, tmpVari);
+    //UA_Variant_clear(&tmpVari);
+
+    // Int64
+    UA_Variant_init(&tmpVari);
+    ds2Int64Val++;
+    UA_Variant_setScalar(&tmpVari, &ds2Int64Val, &UA_TYPES[UA_TYPES_INT64]);
+    UA_Server_writeValue(server, ds2Int64Id, tmpVari);
+    //UA_Variant_clear(&tmpVari);
+
+    // SByte
+    UA_Variant_init(&tmpVari);
+    ds2SByteVal++;
+    UA_Variant_setScalar(&tmpVari, &ds2SByteVal, &UA_TYPES[UA_TYPES_SBYTE]);
+    UA_Server_writeValue(server, ds2SByteId, tmpVari);
+    //UA_Variant_clear(&tmpVari);
+
+    // UInt16
+    UA_Variant_init(&tmpVari);
+    ds2UInt16Val++;
+    UA_Variant_setScalar(&tmpVari, &ds2UInt16Val, &UA_TYPES[UA_TYPES_UINT16]);
+    UA_Server_writeValue(server, ds2UInt16Id, tmpVari);
+    //UA_Variant_clear(&tmpVari);
+
+    // UInt32
+    UA_Variant_init(&tmpVari);
+    ds2UInt32Val++;
+    UA_Variant_setScalar(&tmpVari, &ds2UInt32Val, &UA_TYPES[UA_TYPES_UINT32]);
+    UA_Server_writeValue(server, ds2UInt32Id, tmpVari);
+    //UA_Variant_clear(&tmpVari);
+
+    // UInt64
+    UA_Variant_init(&tmpVari);
+    ds2UInt64Val++;
+    UA_Variant_setScalar(&tmpVari, &ds2UInt64Val, &UA_TYPES[UA_TYPES_UINT64]);
+    UA_Server_writeValue(server, ds2UInt64Id, tmpVari);
+    //UA_Variant_clear(&tmpVari);
+
+    // Float
+    UA_Variant_init(&tmpVari);
+    ds2FloatVal++;
+    UA_Variant_setScalar(&tmpVari, &ds2FloatVal, &UA_TYPES[UA_TYPES_FLOAT]);
+    UA_Server_writeValue(server, ds2FloatId, tmpVari);
+    //UA_Variant_clear(&tmpVari);
+
+    // Double
+    UA_Variant_init(&tmpVari);
+    ds2DoubleVal++;
+    UA_Variant_setScalar(&tmpVari, &ds2DoubleVal, &UA_TYPES[UA_TYPES_DOUBLE]);
+    UA_Server_writeValue(server, ds2DoubleId, tmpVari);
+    //UA_Variant_clear(&tmpVari);
+
+    // String 
+    UA_Variant_init(&tmpVari);
+    ds2StringIndex++;
+    if (ds2StringIndex >= ds2StringArrayLen)
+    {
+        ds2StringIndex = 0;
+    }
+
+    UA_Variant_setScalar(&tmpVari, &ds2StringArray[ds2StringIndex], &UA_TYPES[UA_TYPES_STRING]);
+    UA_Server_writeValue(server, ds2StringId, tmpVari);
+    //UA_Variant_deleteMembers(&tmpVari);
+    //UA_Variant_clear(&tmpVari);
+
+    // ByteString 
+    UA_Variant_init(&tmpVari);
+    UA_ByteString bs;
+    UA_ByteString_init(&bs);
+    UA_ByteString_allocBuffer(&bs, 4);
+    UA_UInt32 ui2 = UA_UInt32_random();
+    memcpy(bs.data, &ui2, 4);
+
+    UA_Variant_setScalar(&tmpVari, &bs, &UA_TYPES[UA_TYPES_BYTESTRING]);
+    UA_Server_writeValue(server, ds2ByteStringId, tmpVari);
+    UA_ByteString_deleteMembers(&bs);
+    //UA_Variant_clear(&tmpVari);
+
+    // Guid 
+    UA_Variant_init(&tmpVari);
+    UA_Guid g = UA_Guid_random();
+    UA_Variant_setScalar(&tmpVari, &g, &UA_TYPES[UA_TYPES_GUID]);
+    UA_Server_writeValue(server, ds2GuidId, tmpVari);
+    //UA_Variant_clear(&tmpVari);
+
+    // UInt32Array
+    for (size_t i = 0; i < 10; i++)
+    {
+        ds2UInt32ArrValue[i]++;
+    }
+
+    UA_Variant_init(&tmpVari);
+    UA_Variant_setArray(&tmpVari, ds2UInt32ArrValue, 10, &UA_TYPES[UA_TYPES_UINT32]);
+    UA_Server_writeValue(server, ds2UInt32ArrId, tmpVari);
+    //UA_Variant_clear(&tmpVari);
+}
+
+UA_Boolean running = true;
+static void stopHandler(int sig) {
+    running = false;
+}
+
+static int run(UA_String *transportProfile,
+    UA_NetworkAddressUrlDataType *networkAddressUrl) {
+    signal(SIGINT, stopHandler);
+    signal(SIGTERM, stopHandler);
+
+    UA_Server *server = UA_Server_new();
+    UA_ServerConfig *config = UA_Server_getConfig(server);
+    UA_ServerConfig_setMinimal(config, 4802, NULL);
+
+    /* Details about the connection configuration and handling are located in
+    * the pubsub connection tutorial */
+    config->pubsubTransportLayers =
+        (UA_PubSubTransportLayer *)UA_calloc(2, sizeof(UA_PubSubTransportLayer));
+    if (!config->pubsubTransportLayers) {
+        UA_Server_delete(server);
+        return EXIT_FAILURE;
+    }
+    config->pubsubTransportLayers[0] = UA_PubSubTransportLayerUDPMP();
+    config->pubsubTransportLayersSize++;
+#ifdef UA_ENABLE_PUBSUB_ETH_UADP
+    config->pubsubTransportLayers[1] = UA_PubSubTransportLayerEthernet();
+    config->pubsubTransportLayersSize++;
+#endif
+
+    addPubSubConnection(server, transportProfile, networkAddressUrl);
+    
+    /* Create a PublishedDataSet based on a PublishedDataSetConfig. */
+    UA_PublishedDataSetConfig publishedDataSetConfig;
+    publishedDataSetConfig.publishedDataSetType = UA_PUBSUB_DATASET_PUBLISHEDITEMS;
+    publishedDataSetConfig.name = UA_STRING("DataSet 1 (Simple)");
+
+    UA_NodeId publishedDataSetIdent;
+    UA_Server_addPublishedDataSet(server, &publishedDataSetConfig, &publishedDataSetIdent);
+
+    addPublisher1(server, publishedDataSetIdent);
+
+    /* Create a new WriterGroup and configure parameters like the publish interval. */
+    UA_WriterGroupConfig writerGroupConfig;
+    memset(&writerGroupConfig, 0, sizeof(UA_WriterGroupConfig));
+    writerGroupConfig.name = UA_STRING("DataSet WriterGroup");
+    writerGroupConfig.publishingInterval = 500;
+    writerGroupConfig.enabled = UA_FALSE;
+    writerGroupConfig.writerGroupId = 100;
+    writerGroupConfig.encodingMimeType = UA_PUBSUB_ENCODING_UADP;
+    writerGroupConfig.maxEncapsulatedDataSetMessageCount = 3;
+
+    /* Add the new WriterGroup to an existing Connection. */
+    UA_NodeId writerGroupIdent;
+    UA_Server_addWriterGroup(server, connectionIdent, &writerGroupConfig, &writerGroupIdent);
+
+    /* Create a new Writer and connect it with an existing PublishedDataSet */
+    // DataSetWriter ID 1 with Variant Encoding 
+    UA_DataSetWriterConfig dataSetWriterConfig;
+    memset(&dataSetWriterConfig, 0, sizeof(UA_DataSetWriterConfig));
+    dataSetWriterConfig.name = UA_STRING("DataSet 1 DataSetWriter");
+    dataSetWriterConfig.dataSetWriterId = 1;
+    //The creation of delta messages is configured in the following line. Value
+    // 0 -> no delta messages are created. 
+    dataSetWriterConfig.keyFrameCount = 10;
+
+    UA_NodeId writerIdentifier;
+    UA_Server_addDataSetWriter(server, writerGroupIdent, publishedDataSetIdent,
+        &dataSetWriterConfig, &writerIdentifier);
+
+    // Published DataSet 2
+    UA_PublishedDataSetConfig publishedDataSetConfig2;
+    publishedDataSetConfig2.publishedDataSetType = UA_PUBSUB_DATASET_PUBLISHEDITEMS;
+    publishedDataSetConfig2.name = UA_STRING("DataSet 2 (AllTypes)");
+
+    UA_NodeId publishedDataSetIdent2;
+    UA_Server_addPublishedDataSet(server, &publishedDataSetConfig2, &publishedDataSetIdent2);
+
+    addPublisher2(server, publishedDataSetIdent2);
+
+    // DataSet Writer 2
+    // Create a new Writer and connect it with an existing PublishedDataSet
+    UA_DataSetWriterConfig dataSetWriterConfig2;
+
+    memset(&dataSetWriterConfig2, 0, sizeof(UA_DataSetWriterConfig));
+    dataSetWriterConfig2.name = UA_STRING("DataSet 2 DataSetWriter");
+    dataSetWriterConfig2.dataSetWriterId = 2;
+    //The creation of delta messages is configured in the following line. Value
+    // 0 -> no delta messages are created. 
+    dataSetWriterConfig2.keyFrameCount = 10;
+
+    UA_NodeId writerIdentifier2;
+    UA_Server_addDataSetWriter(server, writerGroupIdent, publishedDataSetIdent2,
+        &dataSetWriterConfig2, &writerIdentifier2);
+
+    UA_UInt64 timerCallbackId = 0;
+    UA_Server_addRepeatedCallback(server, (UA_ServerCallback)timerCallback, NULL, 1000, &timerCallbackId);
+
+    UA_StatusCode retval = UA_Server_run(server, &running);
+
+    UA_Server_delete(server);
+    return retval == UA_STATUSCODE_GOOD ? EXIT_SUCCESS : EXIT_FAILURE;
+}
+
+static void
+usage(char *progname) {
+    printf("usage: %s <uri> [device]\n", progname);
+}
+
+int main(int argc, char **argv) {
+    UA_String transportProfile =
+        UA_STRING("http://opcfoundation.org/UA-Profile/Transport/pubsub-udp-uadp");
+    UA_NetworkAddressUrlDataType networkAddressUrl =
+    { UA_STRING_NULL, UA_STRING("opc.udp://239.0.0.1:4840/") };
+
+    if (argc > 1) {
+        if (strcmp(argv[1], "-h") == 0) {
+            usage(argv[0]);
+            return EXIT_SUCCESS;
+        }
+        else if (strncmp(argv[1], "opc.udp://", 10) == 0) {
+            networkAddressUrl.url = UA_STRING(argv[1]);
+        }
+        else if (strncmp(argv[1], "opc.eth://", 10) == 0) {
+            transportProfile =
+                UA_STRING("http://opcfoundation.org/UA-Profile/Transport/pubsub-eth-uadp");
+            if (argc < 3) {
+                printf("Error: UADP/ETH needs an interface name\n");
+                return EXIT_FAILURE;
+            }
+            networkAddressUrl.networkInterface = UA_STRING(argv[2]);
+            networkAddressUrl.url = UA_STRING(argv[1]);
+        }
+        else {
+            printf("Error: unknown URI\n");
+            return EXIT_FAILURE;
+        }
+    }
+
+    return run(&transportProfile, &networkAddressUrl);
+}