open62541 基于UDP发布订阅（一）

已于 2022-04-22 19:07:35 修改
阅读量3.3k 收藏 15
点赞数 5
分类专栏： open62541 文章标签： c++ 开发语言
于 2022-04-13 18:24:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_47722349/article/details/123787686
版权

概述

PubSub在OPC UA应用程序中分为Publishers（发布者）和Subscribers（订阅者）。发布者是数据的来源，订阅者使用这些数据。PubSub中的通信是基于消息的，Publishers将消息发送给面向消息的中间件，PubSub支持两种不同的消息中间件变体，broker-less和broker-based两种形式。broker-less面向消息的中间件是能够路由基于数据报的消息的网络基础设备，Publishers和Subscribers使用数据报协议，如UDP；broker-based面向消息的中间件是一个消息代理，Publishers和Subscribers使用标准的消息传递协议，如AMQP或MQTT代理。

基于UDP的发布订阅

  • 编译open62541
    CMake中勾选对应的UA_ENABLE_ALALGAMATION和UA_ENABLE_PUBSUB选项，如图所示
    在这里插入图片描述
    编译生成的工程后能够得到对应的.h和.c文件
    在这里插入图片描述
    将其添加进我们工程中能正常使用了。本例程用的是没有勾选UA_ENABLE_AMALGAMATION选项，即使用.h和.lib的方式去进行使用的。

  • Publish端

这里以tutorial_pubsub_publish.c中内容来讲述如何进行发布，代码如下，有部分修改。

#include <open62541/plugin/log_stdout.h>
#include <open62541/plugin/pubsub_ethernet.h>
#include <open62541/plugin/pubsub_udp.h>
#include <open62541/server.h>
#include <open62541/server_config_default.h>

UA_NodeId connectionIdent, publishedDataSetIdent, writerGroupIdent;
UA_NodeId connectionIdentEx, publishedDataSetIdentEx, writerGroupIdentEx;
UA_NodeId myIntegerNodeId, myIntegerNodeIdEx;

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]);
    /* Changed to static publisherId from random generation to identify
     * the publisher on Subscriber side */
    connectionConfig.publisherId.numeric = 2234;
    UA_Server_addPubSubConnection(server, &connectionConfig, &connectionIdent);
}

static void
addPubSubConnectionEx(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 2");
	connectionConfig.transportProfileUri = *transportProfile;
	connectionConfig.enabled = UA_TRUE;
	UA_Variant_setScalar(&connectionConfig.address, networkAddressUrl,
		&UA_TYPES[UA_TYPES_NETWORKADDRESSURLDATATYPE]);
	/* Changed to static publisherId from random generation to identify
	* the publisher on Subscriber side */
	connectionConfig.publisherId.numeric = 2234;
	UA_Server_addPubSubConnection(server, &connectionConfig, &connectionIdentEx);
}

static void
addPublishedDataSet(UA_Server *server) {
    /* The PublishedDataSetConfig contains all necessary public
    * information for the creation of a new PublishedDataSet */
    UA_PublishedDataSetConfig publishedDataSetConfig;
    memset(&publishedDataSetConfig, 0, sizeof(UA_PublishedDataSetConfig));
    publishedDataSetConfig.publishedDataSetType = UA_PUBSUB_DATASET_PUBLISHEDITEMS;
    publishedDataSetConfig.name = UA_STRING("Demo PDS");
    /* Create new PublishedDataSet based on the PublishedDataSetConfig. */
    UA_Server_addPublishedDataSet(server, &publishedDataSetConfig, &publishedDataSetIdent);
}

static void
addPublishedDataSetEx(UA_Server *server) {
	/* The PublishedDataSetConfig contains all necessary public
	* information for the creation of a new PublishedDataSet */
	UA_PublishedDataSetConfig publishedDataSetConfig;
	memset(&publishedDataSetConfig, 0, sizeof(UA_PublishedDataSetConfig));
	publishedDataSetConfig.publishedDataSetType = UA_PUBSUB_DATASET_PUBLISHEDITEMS;
	publishedDataSetConfig.name = UA_STRING("Demo PDS Ex");
	/* Create new PublishedDataSet based on the PublishedDataSetConfig. */
	UA_Server_addPublishedDataSet(server, &publishedDataSetConfig, &publishedDataSetIdentEx);
}

static void
addDataSetField(UA_Server *server) {
    /* Add a field to the previous created PublishedDataSet */
    UA_NodeId dataSetFieldIdent;
    UA_DataSetFieldConfig dataSetFieldConfig;
    memset(&dataSetFieldConfig, 0, sizeof(UA_DataSetFieldConfig));
    dataSetFieldConfig.dataSetFieldType = UA_PUBSUB_DATASETFIELD_VARIABLE;
    dataSetFieldConfig.field.variable.fieldNameAlias = UA_STRING("Server localtime");
    dataSetFieldConfig.field.variable.promotedField = UA_FALSE;
    dataSetFieldConfig.field.variable.publishParameters.publishedVariable =
    UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_SERVERSTATUS_CURRENTTIME);
    dataSetFieldConfig.field.variable.publishParameters.attributeId = UA_ATTRIBUTEID_VALUE;
    UA_Server_addDataSetField(server, publishedDataSetIdent,
                              &dataSetFieldConfig, &dataSetFieldIdent);
}

static void
addDataSetFieldEx(UA_Server *server) {
	/* Add a field to the previous created PublishedDataSet */
	UA_NodeId dataSetFieldIdent;
	UA_DataSetFieldConfig dataSetFieldConfig;
	memset(&dataSetFieldConfig, 0, sizeof(UA_DataSetFieldConfig));
	dataSetFieldConfig.dataSetFieldType = UA_PUBSUB_DATASETFIELD_VARIABLE;
	dataSetFieldConfig.field.variable.fieldNameAlias = UA_STRING("Server localtime");
	dataSetFieldConfig.field.variable.promotedField = UA_FALSE;
	dataSetFieldConfig.field.variable.publishParameters.publishedVariable =
		UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_SERVERSTATUS_CURRENTTIME);
	dataSetFieldConfig.field.variable.publishParameters.attributeId = UA_ATTRIBUTEID_VALUE;
	UA_Server_addDataSetField(server, publishedDataSetIdentEx,
		&dataSetFieldConfig, &dataSetFieldIdent);
	/***********添加节点****************/
	UA_NodeId myFieldIdent;
	UA_DataSetFieldConfig myFieldConfig;
	memset(&myFieldConfig, 0, sizeof(UA_DataSetFieldConfig));
	myFieldConfig.dataSetFieldType = UA_PUBSUB_DATASETFIELD_VARIABLE;
	myFieldConfig.field.variable.fieldNameAlias = UA_STRING("Myself node");
	myFieldConfig.field.variable.promotedField = UA_FALSE;
	myFieldConfig.field.variable.publishParameters.publishedVariable = myIntegerNodeId;
	myFieldConfig.field.variable.publishParameters.attributeId = UA_ATTRIBUTEID_VALUE;
	UA_Server_addDataSetField(server, publishedDataSetIdentEx,
		&myFieldConfig, &myFieldIdent);

	UA_NodeId myFieldIdentEx;
	UA_DataSetFieldConfig myFieldConfigEx;
	memset(&myFieldConfigEx, 0, sizeof(UA_DataSetFieldConfig));
	myFieldConfigEx.dataSetFieldType = UA_PUBSUB_DATASETFIELD_VARIABLE;
	myFieldConfigEx.field.variable.fieldNameAlias = UA_STRING("Myself node Ex");
	myFieldConfigEx.field.variable.promotedField = UA_FALSE;
	myFieldConfigEx.field.variable.publishParameters.publishedVariable = myIntegerNodeIdEx;
	myFieldConfigEx.field.variable.publishParameters.attributeId = UA_ATTRIBUTEID_VALUE;
	UA_Server_addDataSetField(server, publishedDataSetIdentEx,
		&myFieldConfigEx, &myFieldIdentEx);
}

static void
addWriterGroup(UA_Server *server) {
    /* Now we create a new WriterGroupConfig and add the group to the existing
     * PubSubConnection. */
    UA_WriterGroupConfig writerGroupConfig;
    memset(&writerGroupConfig, 0, sizeof(UA_WriterGroupConfig));
    writerGroupConfig.name = UA_STRING("Demo WriterGroup");
    writerGroupConfig.publishingInterval = 100;
    writerGroupConfig.enabled = UA_TRUE;
    writerGroupConfig.writerGroupId = 100;
    writerGroupConfig.encodingMimeType = UA_PUBSUB_ENCODING_UADP;
    writerGroupConfig.messageSettings.encoding             = UA_EXTENSIONOBJECT_DECODED;
    writerGroupConfig.messageSettings.content.decoded.type = &UA_TYPES[UA_TYPES_UADPWRITERGROUPMESSAGEDATATYPE];
    /* The configuration flags for the messages are encapsulated inside the
     * message- and transport settings extension objects. These extension
     * objects are defined by the standard. e.g.
     * UadpWriterGroupMessageDataType */
    UA_UadpWriterGroupMessageDataType *writerGroupMessage  = UA_UadpWriterGroupMessageDataType_new();
    /* Change message settings of writerGroup to send PublisherId,
     * WriterGroupId in GroupHeader and DataSetWriterId in PayloadHeader
     * of NetworkMessage */
    writerGroupMessage->networkMessageContentMask          = (UA_UadpNetworkMessageContentMask)(UA_UADPNETWORKMESSAGECONTENTMASK_PUBLISHERID |
                                                              (UA_UadpNetworkMessageContentMask)UA_UADPNETWORKMESSAGECONTENTMASK_GROUPHEADER |
                                                              (UA_UadpNetworkMessageContentMask)UA_UADPNETWORKMESSAGECONTENTMASK_WRITERGROUPID |
                                                              (UA_UadpNetworkMessageContentMask)UA_UADPNETWORKMESSAGECONTENTMASK_PAYLOADHEADER);
    writerGroupConfig.messageSettings.content.decoded.data = writerGroupMessage;
    UA_Server_addWriterGroup(server, connectionIdent, &writerGroupConfig, &writerGroupIdent);
    UA_Server_setWriterGroupOperational(server, writerGroupIdent);
    UA_UadpWriterGroupMessageDataType_delete(writerGroupMessage);
}

static void
addWriterGroupEx(UA_Server *server) {
	/* Now we create a new WriterGroupConfig and add the group to the existing
	* PubSubConnection. */
	UA_WriterGroupConfig writerGroupConfig;
	memset(&writerGroupConfig, 0, sizeof(UA_WriterGroupConfig));
	writerGroupConfig.name = UA_STRING("Demo WriterGroup1");
	writerGroupConfig.publishingInterval = 100;
	writerGroupConfig.enabled = UA_TRUE;
	writerGroupConfig.writerGroupId = 100;
	writerGroupConfig.encodingMimeType = UA_PUBSUB_ENCODING_UADP;
	writerGroupConfig.messageSettings.encoding = UA_EXTENSIONOBJECT_DECODED;
	writerGroupConfig.messageSettings.content.decoded.type = &UA_TYPES[UA_TYPES_UADPWRITERGROUPMESSAGEDATATYPE];
	/* The configuration flags for the messages are encapsulated inside the
	* message- and transport settings extension objects. These extension
	* objects are defined by the standard. e.g.
	* UadpWriterGroupMessageDataType */
	UA_UadpWriterGroupMessageDataType *writerGroupMessage = UA_UadpWriterGroupMessageDataType_new();
	/* Change message settings of writerGroup to send PublisherId,
	* WriterGroupId in GroupHeader and DataSetWriterId in PayloadHeader
	* of NetworkMessage */
	writerGroupMessage->networkMessageContentMask = (UA_UadpNetworkMessageContentMask)(UA_UADPNETWORKMESSAGECONTENTMASK_PUBLISHERID |
		(UA_UadpNetworkMessageContentMask)UA_UADPNETWORKMESSAGECONTENTMASK_GROUPHEADER |
		(UA_UadpNetworkMessageContentMask)UA_UADPNETWORKMESSAGECONTENTMASK_WRITERGROUPID |
		(UA_UadpNetworkMessageContentMask)UA_UADPNETWORKMESSAGECONTENTMASK_PAYLOADHEADER);
	writerGroupConfig.messageSettings.content.decoded.data = writerGroupMessage;
	UA_Server_addWriterGroup(server, connectionIdentEx, &writerGroupConfig, &writerGroupIdentEx);
	UA_Server_setWriterGroupOperational(server, writerGroupIdentEx);
	UA_UadpWriterGroupMessageDataType_delete(writerGroupMessage);
}

static void
addDataSetWriter(UA_Server *server) {
    /* We need now a DataSetWriter within the WriterGroup. This means we must
     * create a new DataSetWriterConfig and add call the addWriterGroup function. */
    UA_NodeId dataSetWriterIdent;
    UA_DataSetWriterConfig dataSetWriterConfig;
    memset(&dataSetWriterConfig, 0, sizeof(UA_DataSetWriterConfig));
    dataSetWriterConfig.name = UA_STRING("Demo DataSetWriter");
    dataSetWriterConfig.dataSetWriterId = 62541;
    dataSetWriterConfig.keyFrameCount = 10;
    UA_Server_addDataSetWriter(server, writerGroupIdent, publishedDataSetIdent,
                               &dataSetWriterConfig, &dataSetWriterIdent);
}

static void
addDataSetWriterEx(UA_Server *server) {
	/* We need now a DataSetWriter within the WriterGroup. This means we must
	* create a new DataSetWriterConfig and add call the addWriterGroup function. */
	UA_NodeId dataSetWriterIdent;
	UA_DataSetWriterConfig dataSetWriterConfig;
	memset(&dataSetWriterConfig, 0, sizeof(UA_DataSetWriterConfig));
	dataSetWriterConfig.name = UA_STRING("Demo DataSetWriter1");
	dataSetWriterConfig.dataSetWriterId = 62541;
	dataSetWriterConfig.keyFrameCount = 10;
	UA_Server_addDataSetWriter(server, writerGroupIdentEx, publishedDataSetIdentEx,
		&dataSetWriterConfig, &dataSetWriterIdent);
}

UA_Boolean running = true;

static void
addVariable(UA_Server *server) {
	/* Define the attribute of the myInteger variable node */
	UA_VariableAttributes attr = UA_VariableAttributes_default;
	UA_Int32 myInteger = 42;
	UA_Variant_setScalar(&attr.value, &myInteger, &UA_TYPES[UA_TYPES_INT32]);
	attr.description = UA_LOCALIZEDTEXT("en-US", "the answer");
	attr.displayName = UA_LOCALIZEDTEXT("en-US", "the answer");
	attr.dataType = UA_TYPES[UA_TYPES_INT32].typeId;
	attr.accessLevel = UA_ACCESSLEVELMASK_READ | UA_ACCESSLEVELMASK_WRITE;

	/* Add the variable node to the information model */
	UA_QualifiedName myIntegerName = UA_QUALIFIEDNAME(1, "the answer");
	UA_NodeId parentNodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER);
	UA_NodeId parentReferenceNodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES);
	UA_Server_addVariableNode(server, UA_NODEID_NULL, parentNodeId,
		parentReferenceNodeId, myIntegerName,
		UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE), attr, NULL, &myIntegerNodeId);

	/* Define the attribute of the myInteger variable node */
	myInteger = 99;
	UA_Variant_setScalar(&attr.value, &myInteger, &UA_TYPES[UA_TYPES_INT32]);
	attr.description = UA_LOCALIZEDTEXT("en-US", "the answer Ex");
	attr.displayName = UA_LOCALIZEDTEXT("en-US", "the answer Ex");
	attr.dataType = UA_TYPES[UA_TYPES_INT32].typeId;
	attr.accessLevel = UA_ACCESSLEVELMASK_READ | UA_ACCESSLEVELMASK_WRITE;

	/* Add the variable node to the information model */
	myIntegerName = UA_QUALIFIEDNAME(1, "the answer Ex");
	parentNodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER);
	parentReferenceNodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES);
	UA_Server_addVariableNode(server, UA_NODEID_NULL, parentNodeId,
		parentReferenceNodeId, myIntegerName,
		UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE), attr, NULL, &myIntegerNodeIdEx);
}


static int run(UA_String *transportProfile,
               UA_NetworkAddressUrlDataType *networkAddressUrl) {
    UA_Server *server = UA_Server_new();
    UA_ServerConfig *config = UA_Server_getConfig(server);
	UA_ServerConfig_setMinimal(config, 4888, NULL);

	/* Details about the connection configuration and handling are located in
	* the pubsub connection tutorial */
	UA_ServerConfig_addPubSubTransportLayer(config, UA_PubSubTransportLayerUDPMP());
#ifdef UA_ENABLE_PUBSUB_ETH_UADP
	UA_ServerConfig_addPubSubTransportLayer(config, UA_PubSubTransportLayerEthernet());
#endif

	//添加自己定义的两个节点
	addVariable(server);

#if 1
	addPubSubConnection(server, transportProfile, networkAddressUrl);
    addPublishedDataSet(server);
    addDataSetField(server);
    addWriterGroup(server);
    addDataSetWriter(server);
#endif
	//向不同地址发布信息
	UA_String transportProfileEx =
		UA_STRING("http://opcfoundation.org/UA-Profile/Transport/pubsub-udp-uadp");
	UA_NetworkAddressUrlDataType networkAddressUrlEx =
	{ UA_STRING_NULL, UA_STRING("opc.udp://224.0.0.23:4843/") };

#if 1
	addPubSubConnectionEx(server, &transportProfileEx, &networkAddressUrlEx);
	addPublishedDataSetEx(server);
	addDataSetFieldEx(server);
	addWriterGroupEx(server);
	addDataSetWriterEx(server);
#endif

    UA_StatusCode retval = UA_Server_run(server, &running);

    UA_Server_delete(server);
    return retval == UA_STATUSCODE_GOOD ? EXIT_SUCCESS : EXIT_FAILURE;
}

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://224.0.0.22:4840/")};
    return run(&transportProfile, &networkAddressUrl);
}

这里相比原.c中内容的话添加了两个Int32类型的node，以及添加了一个地址用于发布内容。运行后输出信息如下
在这里插入图片描述
可以看到一个PubSub连接对应应该PubSub通道，在一个server中我们可以向多个地址发布不同的信息，彼此之间不受影响。同样，在同一个地址中我们可以创建多个组和数据集，在sub端根据对应设定的Id号便可以访问到对应发布的数据。
大致流程如下：
在这里插入图片描述
connect：建立连接，设定一个发布id，根据UDP地址创建并打开安全通道
add DataSet：添加数据集，获取一个数据集id，用来绑定需要发布的数据
add DataSet field：添加数据集字段，即要发布的数据，与数据集id进行绑定
add Group：添加组，获取一个组id，用于创建writer
add Writer：添加Writer，绑定组与数据集

sub端通过发布id，组id，和写者id进行绑定需要订阅的对应变量

  • subscribe端
    这里以tutorial_pubsub_subscribe.c中内容来讲述如何订阅发布的信息，代码如下。
#include <open62541/plugin/log_stdout.h>
#include <open62541/plugin/pubsub_udp.h>
#include <open62541/server.h>
#include <open62541/server_config_default.h>
#include <open62541/types_generated.h>

#if defined (UA_ENABLE_PUBSUB_ETH_UADP)
#include <open62541/plugin/pubsub_ethernet.h>
#endif

UA_NodeId connectionIdentifier;
UA_NodeId readerGroupIdentifier;
UA_NodeId readerIdentifier;

UA_DataSetReaderConfig readerConfig;

static void fillTestDataSetMetaData(UA_DataSetMetaDataType *pMetaData);

/* Add new connection to the server */
static UA_StatusCode
addPubSubConnection(UA_Server *server, UA_String *transportProfile,
                    UA_NetworkAddressUrlDataType *networkAddressUrl) {
    if((server == NULL) || (transportProfile == NULL) ||
        (networkAddressUrl == NULL)) {
        return UA_STATUSCODE_BADINTERNALERROR;
    }

    UA_StatusCode retval = UA_STATUSCODE_GOOD;
    /* Configuration creation for the connection */
    UA_PubSubConnectionConfig connectionConfig;
    memset (&connectionConfig, 0, sizeof(UA_PubSubConnectionConfig));
    connectionConfig.name = UA_STRING("UDPMC Connection 1");
    connectionConfig.transportProfileUri = *transportProfile;
    connectionConfig.enabled = UA_TRUE;
    UA_Variant_setScalar(&connectionConfig.address, networkAddressUrl,
                         &UA_TYPES[UA_TYPES_NETWORKADDRESSURLDATATYPE]);
	connectionConfig.publisherId.numeric = UA_UInt32_random();
    retval |= UA_Server_addPubSubConnection (server, &connectionConfig, &connectionIdentifier);
    if (retval != UA_STATUSCODE_GOOD) {
        return retval;
    }

    return retval;
}

/**
 * **ReaderGroup**
 *
 * ReaderGroup is used to group a list of DataSetReaders. All ReaderGroups are
 * created within a PubSubConnection and automatically deleted if the connection
 * is removed. All network message related filters are only available in the DataSetReader. */
/* Add ReaderGroup to the created connection */
static UA_StatusCode
addReaderGroup(UA_Server *server) {
    if(server == NULL) {
        return UA_STATUSCODE_BADINTERNALERROR;
    }

    UA_StatusCode retval = UA_STATUSCODE_GOOD;
    UA_ReaderGroupConfig readerGroupConfig;
    memset (&readerGroupConfig, 0, sizeof(UA_ReaderGroupConfig));
    readerGroupConfig.name = UA_STRING("ReaderGroup1");
    retval |= UA_Server_addReaderGroup(server, connectionIdentifier, &readerGroupConfig,
                                       &readerGroupIdentifier);
    UA_Server_setReaderGroupOperational(server, readerGroupIdentifier);
    return retval;
}

/**
 * **DataSetReader**
 *
 * DataSetReader can receive NetworkMessages with the DataSetMessage
 * of interest sent by the Publisher. DataSetReader provides
 * the configuration necessary to receive and process DataSetMessages
 * on the Subscriber side. DataSetReader must be linked with a
 * SubscribedDataSet and be contained within a ReaderGroup. */
/* Add DataSetReader to the ReaderGroup */
static UA_StatusCode
addDataSetReader(UA_Server *server) {
    if(server == NULL) {
        return UA_STATUSCODE_BADINTERNALERROR;
    }

    UA_StatusCode retval = UA_STATUSCODE_GOOD;
    memset (&readerConfig, 0, sizeof(UA_DataSetReaderConfig));
    readerConfig.name = UA_STRING("DataSet Reader 1");
    /* Parameters to filter which DataSetMessage has to be processed
     * by the DataSetReader */
    /* The following parameters are used to show that the data published by
     * tutorial_pubsub_publish.c is being subscribed and is being updated in
     * the information model */
    UA_UInt16 publisherIdentifier = 2234;
    readerConfig.publisherId.type = &UA_TYPES[UA_TYPES_UINT16];
    readerConfig.publisherId.data = &publisherIdentifier;
    readerConfig.writerGroupId    = 100;
    readerConfig.dataSetWriterId  = 62542;

    /* Setting up Meta data configuration in DataSetReader */
    fillTestDataSetMetaData(&readerConfig.dataSetMetaData);

    retval |= UA_Server_addDataSetReader(server, readerGroupIdentifier, &readerConfig,
                                         &readerIdentifier);
    return retval;
}

/**
 * **SubscribedDataSet**
 *
 * Set SubscribedDataSet type to TargetVariables data type.
 * Add subscribedvariables to the DataSetReader */
static UA_StatusCode
addSubscribedVariables (UA_Server *server, UA_NodeId dataSetReaderId) {
    if(server == NULL)
        return UA_STATUSCODE_BADINTERNALERROR;

    UA_StatusCode retval = UA_STATUSCODE_GOOD;
    UA_NodeId folderId;
    UA_String folderName = readerConfig.dataSetMetaData.name;
    UA_ObjectAttributes oAttr = UA_ObjectAttributes_default;
    UA_QualifiedName folderBrowseName;
    if(folderName.length > 0) {
        oAttr.displayName.locale = UA_STRING ("en-US");
        oAttr.displayName.text = folderName;
        folderBrowseName.namespaceIndex = 1;
        folderBrowseName.name = folderName;
    }
    else {
        oAttr.displayName = UA_LOCALIZEDTEXT ("en-US", "Subscribed Variables");
        folderBrowseName = UA_QUALIFIEDNAME (1, "Subscribed Variables");
    }

    UA_Server_addObjectNode (server, UA_NODEID_NULL,
                             UA_NODEID_NUMERIC (0, UA_NS0ID_OBJECTSFOLDER),
                             UA_NODEID_NUMERIC (0, UA_NS0ID_ORGANIZES),
                             folderBrowseName, UA_NODEID_NUMERIC (0,
                             UA_NS0ID_BASEOBJECTTYPE), oAttr, NULL, &folderId);

/**
 * **TargetVariables**
 *
 * The SubscribedDataSet option TargetVariables defines a list of Variable mappings between
 * received DataSet fields and target Variables in the Subscriber AddressSpace.
 * The values subscribed from the Publisher are updated in the value field of these variables */
    /* Create the TargetVariables with respect to DataSetMetaData fields */
    UA_FieldTargetVariable *targetVars = (UA_FieldTargetVariable *)
            UA_calloc(readerConfig.dataSetMetaData.fieldsSize, sizeof(UA_FieldTargetVariable));
    for(size_t i = 0; i < readerConfig.dataSetMetaData.fieldsSize; i++) {
        /* Variable to subscribe data */
        UA_VariableAttributes vAttr = UA_VariableAttributes_default;
        UA_LocalizedText_copy(&readerConfig.dataSetMetaData.fields[i].description,
                              &vAttr.description);
        vAttr.displayName.locale = UA_STRING("en-US");
        vAttr.displayName.text = readerConfig.dataSetMetaData.fields[i].name;
        vAttr.dataType = readerConfig.dataSetMetaData.fields[i].dataType;

        UA_NodeId newNode;
        retval |= UA_Server_addVariableNode(server, UA_NODEID_NUMERIC(1, (UA_UInt32)i + 50000),
                                           folderId,
                                           UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT),
                                           UA_QUALIFIEDNAME(1, (char *)readerConfig.dataSetMetaData.fields[i].name.data),
                                           UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE),
                                           vAttr, NULL, &newNode);

        /* For creating Targetvariables */
        UA_FieldTargetDataType_init(&targetVars[i].targetVariable);
        targetVars[i].targetVariable.attributeId  = UA_ATTRIBUTEID_VALUE;
        targetVars[i].targetVariable.targetNodeId = newNode;
    }

    retval = UA_Server_DataSetReader_createTargetVariables(server, dataSetReaderId,
                                                           readerConfig.dataSetMetaData.fieldsSize, targetVars);
    for(size_t i = 0; i < readerConfig.dataSetMetaData.fieldsSize; i++)
        UA_FieldTargetDataType_clear(&targetVars[i].targetVariable);

    UA_free(targetVars);
    UA_free(readerConfig.dataSetMetaData.fields);
    return retval;
}

/**
 * **DataSetMetaData**
 *
 * The DataSetMetaData describes the content of a DataSet. It provides the information necessary to decode
 * DataSetMessages on the Subscriber side. DataSetMessages received from the Publisher are decoded into
 * DataSet and each field is updated in the Subscriber based on datatype match of TargetVariable fields of Subscriber
 * and PublishedDataSetFields of Publisher */
/* Define MetaData for TargetVariables */
static void fillTestDataSetMetaData(UA_DataSetMetaDataType *pMetaData) {
    if(pMetaData == NULL) {
        return;
    }

    UA_DataSetMetaDataType_init (pMetaData);
    pMetaData->name = UA_STRING ("DataSet 1");

    /* Static definition of number of fields size to 4 to create four different
     * targetVariables of distinct datatype
     * Currently the publisher sends only DateTime data type */
    pMetaData->fieldsSize = 4;
    pMetaData->fields = (UA_FieldMetaData*)UA_Array_new (pMetaData->fieldsSize,
                         &UA_TYPES[UA_TYPES_FIELDMETADATA]);

    /* DateTime DataType */
    UA_FieldMetaData_init (&pMetaData->fields[0]);
	UA_NodeId_copy(&UA_TYPES[UA_TYPES_DATETIME].typeId,
                    &pMetaData->fields[0].dataType);
	pMetaData->fields[0].builtInType = UA_NS0ID_DATETIME;
    pMetaData->fields[0].name =  UA_STRING ("DateTime");
    pMetaData->fields[0].valueRank = -1; /* scalar */

    /* Int32 DataType */
    UA_FieldMetaData_init (&pMetaData->fields[1]);
	UA_NodeId_copy(&UA_TYPES[UA_TYPES_INT32].typeId,
                   &pMetaData->fields[1].dataType);
	pMetaData->fields[1].builtInType = UA_NS0ID_INT32;
    pMetaData->fields[1].name =  UA_STRING ("Int32");
    pMetaData->fields[1].valueRank = -1; /* scalar */

    /* Int64 DataType */
    UA_FieldMetaData_init (&pMetaData->fields[2]);
	UA_NodeId_copy(&UA_TYPES[UA_TYPES_INT32].typeId,
                   &pMetaData->fields[2].dataType);
	pMetaData->fields[2].builtInType = UA_TYPES_INT32;
    pMetaData->fields[2].name =  UA_STRING ("Int64");
    pMetaData->fields[2].valueRank = -1; /* scalar */

    /* Boolean DataType */
    UA_FieldMetaData_init (&pMetaData->fields[3]);
    UA_NodeId_copy (&UA_TYPES[UA_TYPES_BOOLEAN].typeId,
                    &pMetaData->fields[3].dataType);
    pMetaData->fields[3].builtInType = UA_NS0ID_BOOLEAN;
    pMetaData->fields[3].name =  UA_STRING ("BoolToggle");
    pMetaData->fields[3].valueRank = -1; /* scalar */
}

/**
 * Followed by the main server code, making use of the above definitions */
UA_Boolean running = true;

static int
run(UA_String *transportProfile, UA_NetworkAddressUrlDataType *networkAddressUrl) {
    signal(SIGINT, stopHandler);
    signal(SIGTERM, stopHandler);
    /* Return value initialized to Status Good */
    UA_StatusCode retval = UA_STATUSCODE_GOOD;
    UA_Server *server = UA_Server_new();
    UA_ServerConfig *config = UA_Server_getConfig(server);
    UA_ServerConfig_setMinimal(config, 4899, NULL);

    /* Add the PubSub network layer implementation to the server config.
     * The TransportLayer is acting as factory to create new connections
     * on runtime. Details about the PubSubTransportLayer can be found inside the
     * tutorial_pubsub_connection */
    UA_ServerConfig_addPubSubTransportLayer(config, UA_PubSubTransportLayerUDPMP());
#ifdef UA_ENABLE_PUBSUB_ETH_UADP
    UA_ServerConfig_addPubSubTransportLayer(config, UA_PubSubTransportLayerEthernet());
#endif

    /* API calls */
    /* Add PubSubConnection */
    retval |= addPubSubConnection(server, transportProfile, networkAddressUrl);
    if (retval != UA_STATUSCODE_GOOD)
        return EXIT_FAILURE;

    /* Add ReaderGroup to the created PubSubConnection */
    retval |= addReaderGroup(server);
    if (retval != UA_STATUSCODE_GOOD)
        return EXIT_FAILURE;

    /* Add DataSetReader to the created ReaderGroup */
    retval |= addDataSetReader(server);
    if (retval != UA_STATUSCODE_GOOD)
        return EXIT_FAILURE;

    /* Add SubscribedVariables to the created DataSetReader */
    retval |= addSubscribedVariables(server, readerIdentifier);
    if (retval != UA_STATUSCODE_GOOD)
        return EXIT_FAILURE;

    retval = UA_Server_run(server, &running);
    UA_Server_delete(server);
    return retval == UA_STATUSCODE_GOOD ? EXIT_SUCCESS : EXIT_FAILURE;
}

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://224.0.0.22:4843/")};
	//networkAddressUrl.url = UA_STRING("opc.udp://224.0.0.23:4845/");
    return run(&transportProfile, &networkAddressUrl);
}

这里sub端订阅的是opc.udp://224.0.0.22:4843地址中的发布变量，一个服务器时间和我们自定义的两个变量。使用uaexpert去分别连接pub和sub端，改变pub端变量值，在连接sub端的uaexpert中可以看到对应的值也进行了变化。

这里进行了几个测试：
1、添加多个PubSubConnection：每个connect对应一个安全通道，互不干扰。
2、同一个PubSubConnection添加多个dataset，使用同一个writerGroup ：
若DataSetWriter Id一致则使用最后绑定的dataset字段，不一致则可通过id访问不同的信息。
3、同一个PubSubConnection添加多个dataset，使用多个writerGroup ：
若group Id一致则使用最后绑定的dataset字段，不一致则可通过id访问不同的信息。
4、连接同一个address，publish id不一致：所有的都是独立操作，不会影响。

注意事项
1、Publish端设定的node，subscription端对应node类型一定需要对应。个数可以不一致。
2、addPubSubConnection1多个UDP地址，对应一个通道。

碰到的问题

将生成的open62541.h和open62541.c加入到工程后，将发布者运行起来后会如下问题
在这里插入图片描述
这个时候主要是由于
在这里插入图片描述
这句代码导致，其中addressAsChar是char*类型，我们看一下UA_inet_pton的定义
在这里插入图片描述
vs中我们使用了UNICODE这个宏因此使用的是InetPtonW这个接口，我们看一下这个接口定义
在这里插入图片描述
很明显其第二个参数是PCWSTR类型的与char *类型不符合因此导致每次这个接口识别地址失败从而返回0，这里我们需要将这里源码进行修改一下。如下，主要是做类型转换
在这里插入图片描述

修改完后就能正常跑起来了。

复杂的世界311
关注
  • 5
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 10
    评论
专栏目录
open62541简单的封装类
10-13
将常用的open62541的功能进行简单的封装。可以将其进行简单的改造之后用于MFC中。仅供参考使用。
open62541.h
10-10
open62541开源项目中的.h文件open62541通过CMake编译后产生的集成文件
open62541 基于UDP发布订阅（二）
m0_47722349的博客
04-22 2581
概述 在基于UDP发布订阅（一）一文中讲述了基于无代理的OPCUA订阅/发布，在订阅过程中会发现我们需要知道发布的每一个节点信息，自己填充数据集元数据，包括设定名称、数据类型等信息，这样如果发布节点一多很容易发生问题。那有没有方法让我们订阅方能够知道发布方指定数据集下所有节点信息呢？答案是有的，opcua中提供了这样的一个操作， ...
open62541-current_open62541代码_open62541_
10-03
open62541客户端源代码，用来参考学习。
open62541.rar
02-02
vs2015编译的OPC UA open62541.lib、open62541.dll。配套含open62541.h 、WS2_32.Lib，可直接引用。
open62541-open62541-v1.2.1-0-g4038a31_OPCUA_visualc++_
10-04
Open62541开源库，可以用来开发OPC UA协议的客户端与用户端，物联网必备工具
基于open62541库的OPC UA协议节点信息查询及多节点数值读写案例实践
技术需要分享
06-22 4549
基于open62541库的OPC UA协议节点信息查询及多节点数值读写案例实践，创建服务端、客户端工程，服务端添加了一些节点及初始化节点数值，客户端链接到服务端，可以读取单节点数值，同时读取和写入节点数值，可以指定父节点读取其下各个子节点信息。
OPC UA开源库Open62541源码编译及Client客户端Server服务器端测试[一]
最新发布
lzc881012的博客
01-19 1951
pen62541 是一款开源的嵌入式系统开发手册，旨在帮助开发者快速掌握 Open62541 的开发技能。本文将从 Open62541 的概述、功能、开发环境、编程接口和应用案例五个方面进行介绍。
open62541 基于mqtt订阅发布
m0_47722349的博客
04-19 1822
windows下mosquitto使用 1、下载mosquitto 链接：https://mosquitto.org/download/ 2、安装 安装完毕后进入安装目录，如下： 3、配置 在这个目录中打开命令行 输入cmd，回车，命令行就弹出来了。 设置用户名密码 命令：mosquitto_passwd.exe -c pwfile.example -u mqtt 这里使用123456作为密码 设置端口 默认端口：1883 指定端口启动：mosquitto.exe -p < por
open62541中文文档
热门推荐
mikasoi的博客
12-04 4万+
  介绍 open62541（http://open62541.org）是一个开源的免费实现OPC UA（OPC统一架构），用C99和C ++ 98语言的通用子集编写。该库可与所有主要编译器一起使用，并提供实现专用OPC UA客户端和服务器的必要工具，或将基于OPC UA的通信集成到现有应用程序中。open62541库与平台无关。所有特定于平台的功能都是通过可交换的插件实现的。为主要操作系统提...
基于open62541的服务器和客户端
07-09
基于open62541的服务器和客户端，使用vs2015开发工具，有服务器和客户端代码和执行文件，程序为32位。
学习open62541 — [24] 定时执行任务
01-06
open62541提供定时执行任务功能，这个功能很实用，在前面的文章中，有时我们想定时的去修改一些变量节点的值，都是开一个线程去做的，相对来说有点小麻烦。使用open62541自带的定时器就会简单很多。 下面来看下如何使用open62541提供定时功能。 一 相关api 首先要知道一些关于定时任务的简单知识， 定时任务分为定时执行一次（也叫one shot）和定时循环执行（有个定时周期）2种 当定时任务被添加到定时器的执行列表里后，就开始计时 也可以看下linux系统提供的api，促进理解，点击这里。 api分为Server端和Client端，如下， Server端 /** * Timed
open62541-win32.zip_mainory_opc_open62541_open62541 加密_open62541
07-15
Open62541是OPC基金会的开源动态库，免去了需要企业邮箱才能注册下载的麻烦。
Open62541 Linux静态库
08-24
Linux 下编译的OPC UA Open62541 静态库文件，包括server Client
OPC UA - Open62541学习
liwen9016的博客
08-23 1万+
前言 这几天看了看Open62541，这是用C语言遵循C99标准实现的一个开源跨平台OPC UA库。学习过程中发现好多不明白的运行结果，可能是自己没搞太明白，也可能是源码有些潜在bug，希望大神看到指导下小弟。这里简单记录下自己的学习过程和测试结果，算是个小笔记？ 一：编译 按着文档编译下 Linux： sudo apt-get install git build-essential g...
学习open62541 --- [38] 避坑指南
爱就是是恒久忍耐的专栏
11-18 5387
如何正确使用open62541
学习open62541 --- [3] 类型系统初探
爱就是是恒久忍耐的专栏
08-25 1万+
OPC UA类型系统
Open62541 为硬件设备（PLC）构建OPC UA模型
姚家湾博客
06-26 2385
open62541直接导入NodeSet文件，不再需要uaCompiler。这对设计通用的OPC UA Server 更方便灵活。
学习open62541 --- [1] 初始
爱就是是恒久忍耐的专栏
08-11 3万+
万事开头难
open62541订阅数据
07-27
open62541是一个开源的OPC UA（Open Platform Communications Unified Architecture）实现库。通过使用open62541，您可以创建OPC UA服务器和客户端，实现数据的发布和订阅。 在open62541中，数据是通过订阅和发布机制进行传输的。首先，您需要创建一个OPC UA服务器，该服务器将发布数据。然后，您可以创建一个OPC UA客户端，该客户端订阅服务器发布的数据。 在服务器端，您需要定义数据节点。数据节点是用于存储和提供数据的对象。您可以为每个数据节点指定不同的标识符、数据类型和访问权限。一旦您定义了数据节点，您可以在服务器的主循环中定期更新数据节点的值。 在客户端端，您需要创建一个订阅对象。订阅对象用于指定要订阅的数据节点和更新的频率。您可以选择在订阅对象中定义一个回调函数，在数据更新时触发该函数。 一旦订阅对象启动，它将连接到服务器，并在指定的频率下请求服务器更新数据节点的值。当数据节点的值发生变化时，服务器将通知所有相关订阅对象，并发送新的数据值。客户端可以通过订阅对象的回调函数处理这些通知。 总结来说，通过open62541，您可以轻松地订阅和接收OPC UA服务器发布的数据。通过定义数据节点和创建订阅对象，您可以灵活地控制数据的发布和订阅过程，实现实时数据的传输和分发。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 10
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

复杂的世界311

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值