open62541 linux编译,open62541学习

最新推荐文章于 2025-07-02 05:15:15 发布
最新推荐文章于 2025-07-02 05:15:15 发布
阅读量781 收藏
点赞数
文章标签： open62541 linux编译
本文详细介绍OPCUA客户端如何连接服务、浏览节点、读写指定节点数据及订阅模式的操作方法，并提供了添加新节点的初步指导。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

连接OPC UA服务

UA_Client *client = UA_Client_new(UA_ClientConfig_default);

char *uri = "opc.tcp://127.0.0.1:49320";

retval = UA_Client_connect(client, uri);

if (retval != UA_STATUSCODE_GOOD)

{

UA_Client_delete(client);

return (int)retval;

}

这里还可以用指定用户名和密码去连接，连接函数原型为：但是我没有测试

UA_StatusCode

UA_Client_connect_username(UA_Client *client, const char *endpointUrl,

const char *username, const char *password) {

client->authenticationMethod = UA_CLIENTAUTHENTICATION_USERNAME;

client->username = UA_STRING_ALLOC(username);

client->password = UA_STRING_ALLOC(password);

return UA_Client_connect(client, endpointUrl);

}

浏览指定节点下NODE

static void BrowseNode(UA_Client *client,char* nodeIdStr)

{

/* Browse some objects */

if (nodeIdStr == NULL)

{

printf("nodeIdStr == NULL");

return;

}

printf("Browsing nodes in objects folder:

");

UA_NodeId nodeId = UA_NODEID_STRING(2, nodeIdStr);

//UA_NodeId nodeId = UA_NODEID_NUMERIC(0, 8);

UA_BrowseRequest bReq ;

UA_BrowseRequest_init(&bReq);

bReq.requestedMaxReferencesPerNode = 0;

bReq.nodesToBrowse = UA_BrowseDescription_new();

bReq.nodesToBrowseSize = 1;

bReq.nodesToBrowse[0].nodeId = nodeId;

bReq.nodesToBrowse[0].resultMask = UA_BROWSERESULTMASK_ALL; /* return everything */

UA_BrowseResponse bResp = UA_Client_Service_browse(client, bReq);

printf("%-9s %-16s %-16s %-16s

", "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

", ref->nodeId.nodeId.namespaceIndex,

ref->nodeId.nodeId.identifier.numeric, (int)ref->browseName.name.length,

ref->browseName.name.data, (int)ref->displayName.text.length,

ref->displayName.text.data);

}

else if (ref->nodeId.nodeId.identifierType == UA_NODEIDTYPE_STRING) {

printf("%-9d %-16.*s %-16.*s %-16.*s

", ref->nodeId.nodeId.namespaceIndex,

(int)ref->nodeId.nodeId.identifier.string.length,

ref->nodeId.nodeId.identifier.string.data,

(int)ref->browseName.name.length, ref->browseName.name.data,

(int)ref->displayName.text.length, ref->displayName.text.data);

}

}

}

UA_BrowseDescription_deleteMembers(&bReq);

//UA_BrowseRequest_deleteMembers(&bReq);

UA_BrowseResponse_deleteMembers(&bResp);

}

这里遇到个小问题，其实应该用UA_BrowseRequest_deleteMembers(&bReq);来释放资源，浏览根节点释放资源时没问题，指定Node去浏览后 释放就报错，这样写同样可以起到释放的效果。

UA_BrowseDescription_deleteMembers(&bReq);

这里还有一种枚举指定节点下NODE的方法

UA_NodeId *parent = UA_NodeId_new();

*parent = UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER);

UA_Client_forEachChildNodeCall(client, UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER),

nodeIter, (void *)parent);

UA_NodeId_delete(parent);

static UA_StatusCode

nodeIter(UA_NodeId childId, UA_Boolean isInverse, UA_NodeId referenceTypeId, void *handle) {

if (isInverse)

return UA_STATUSCODE_GOOD;

UA_NodeId *parent = (UA_NodeId *)handle;

printf("%d, %d --- %d ---> NodeId %d, %d

",

parent->namespaceIndex, parent->identifier.numeric,

referenceTypeId.identifier.numeric, childId.namespaceIndex,

childId.identifier.numeric);

return UA_STATUSCODE_GOOD;

}

每个子节点会以回调的方式反馈给我们。

读指定Node

UA_Variant *val = UA_Variant_new();

UA_LocalizedText outDisplayName;

UA_NodeId nodeId = UA_NODEID_STRING(2, nodeIdStr);

//CX62KX63.ER.Queue.CarVin

//CX62KX63.ER.Queue.Request

UA_StatusCode retval = UA_Client_readValueAttribute(client, nodeId, val);

主动读的时候需要注意，根据指定node的数据类型指定类型来接收，不然可能拿不到或者拿到错误的数据，因为C语言嘛，比较基于内存。

读的时候很灵活可以用底层的

__UA_Client_readAttribute(UA_Client *client, const UA_NodeId *nodeId,

UA_AttributeId attributeId, void *out,

const UA_DataType *outDataType);

指定UA_AttributeId 去读。但是推荐使用包装后的读取方式，官方文档上有说明

static UA_INLINE UA_StatusCode

UA_Client_readNodeIdAttribute(UA_Client *client, const UA_NodeId nodeId,

UA_NodeId *outNodeId) {

return __UA_Client_readAttribute(client, &nodeId, UA_ATTRIBUTEID_NODEID,

outNodeId, &UA_TYPES[UA_TYPES_NODEID]);

}

static UA_INLINE UA_StatusCode

UA_Client_readNodeClassAttribute(UA_Client *client, const UA_NodeId nodeId,

UA_NodeClass *outNodeClass) {

return __UA_Client_readAttribute(client, &nodeId, UA_ATTRIBUTEID_NODECLASS,

outNodeClass, &UA_TYPES[UA_TYPES_NODECLASS]);

}

static UA_INLINE UA_StatusCode

UA_Client_readBrowseNameAttribute(UA_Client *client, const UA_NodeId nodeId,

UA_QualifiedName *outBrowseName) {

return __UA_Client_readAttribute(client, &nodeId, UA_ATTRIBUTEID_BROWSENAME,

outBrowseName,

&UA_TYPES[UA_TYPES_QUALIFIEDNAME]);

}

static UA_INLINE UA_StatusCode

UA_Client_readDisplayNameAttribute(UA_Client *client, const UA_NodeId nodeId,

UA_LocalizedText *outDisplayName) {

return __UA_Client_readAttribute(client, &nodeId, UA_ATTRIBUTEID_DISPLAYNAME,

outDisplayName,

&UA_TYPES[UA_TYPES_LOCALIZEDTEXT]);

}

static UA_INLINE UA_StatusCode

UA_Client_readDescriptionAttribute(UA_Client *client, const UA_NodeId nodeId,

UA_LocalizedText *outDescription) {

return __UA_Client_readAttribute(client, &nodeId, UA_ATTRIBUTEID_DESCRIPTION,

outDescription,

&UA_TYPES[UA_TYPES_LOCALIZEDTEXT]);

}

static UA_INLINE UA_StatusCode

UA_Client_readWriteMaskAttribute(UA_Client *client, const UA_NodeId nodeId,

UA_UInt32 *outWriteMask) {

return __UA_Client_readAttribute(client, &nodeId, UA_ATTRIBUTEID_WRITEMASK,

outWriteMask, &UA_TYPES[UA_TYPES_UINT32]);

}

static UA_INLINE UA_StatusCode

UA_Client_readUserWriteMaskAttribute(UA_Client *client, const UA_NodeId nodeId,

UA_UInt32 *outUserWriteMask) {

return __UA_Client_readAttribute(client, &nodeId,

UA_ATTRIBUTEID_USERWRITEMASK,

outUserWriteMask,

&UA_TYPES[UA_TYPES_UINT32]);

}

static UA_INLINE UA_StatusCode

UA_Client_readIsAbstractAttribute(UA_Client *client, const UA_NodeId nodeId,

UA_Boolean *outIsAbstract) {

return __UA_Client_readAttribute(client, &nodeId, UA_ATTRIBUTEID_ISABSTRACT,

outIsAbstract, &UA_TYPES[UA_TYPES_BOOLEAN]);

}

static UA_INLINE UA_StatusCode

UA_Client_readSymmetricAttribute(UA_Client *client, const UA_NodeId nodeId,

UA_Boolean *outSymmetric) {

return __UA_Client_readAttribute(client, &nodeId, UA_ATTRIBUTEID_SYMMETRIC,

outSymmetric, &UA_TYPES[UA_TYPES_BOOLEAN]);

}

static UA_INLINE UA_StatusCode

UA_Client_readInverseNameAttribute(UA_Client *client, const UA_NodeId nodeId,

UA_LocalizedText *outInverseName) {

return __UA_Client_readAttribute(client, &nodeId, UA_ATTRIBUTEID_INVERSENAME,

outInverseName,

&UA_TYPES[UA_TYPES_LOCALIZEDTEXT]);

}

static UA_INLINE UA_StatusCode

UA_Client_readContainsNoLoopsAttribute(UA_Client *client, const UA_NodeId nodeId,

UA_Boolean *outContainsNoLoops) {

return __UA_Client_readAttribute(client, &nodeId,

UA_ATTRIBUTEID_CONTAINSNOLOOPS,

outContainsNoLoops,

&UA_TYPES[UA_TYPES_BOOLEAN]);

}

static UA_INLINE UA_StatusCode

UA_Client_readEventNotifierAttribute(UA_Client *client, const UA_NodeId nodeId,

UA_Byte *outEventNotifier) {

return __UA_Client_readAttribute(client, &nodeId, UA_ATTRIBUTEID_EVENTNOTIFIER,

outEventNotifier, &UA_TYPES[UA_TYPES_BYTE]);

}

static UA_INLINE UA_StatusCode

UA_Client_readValueAttribute(UA_Client *client, const UA_NodeId nodeId,

UA_Variant *outValue) {

return __UA_Client_readAttribute(client, &nodeId, UA_ATTRIBUTEID_VALUE,

outValue, &UA_TYPES[UA_TYPES_VARIANT]);

}

static UA_INLINE UA_StatusCode

UA_Client_readDataTypeAttribute(UA_Client *client, const UA_NodeId nodeId,

UA_NodeId *outDataType) {

return __UA_Client_readAttribute(client, &nodeId, UA_ATTRIBUTEID_DATATYPE,

outDataType, &UA_TYPES[UA_TYPES_NODEID]);

}

static UA_INLINE UA_StatusCode

UA_Client_readValueRankAttribute(UA_Client *client, const UA_NodeId nodeId,

UA_Int32 *outValueRank) {

return __UA_Client_readAttribute(client, &nodeId, UA_ATTRIBUTEID_VALUERANK,

outValueRank, &UA_TYPES[UA_TYPES_INT32]);

}

UA_StatusCode UA_EXPORT

UA_Client_readArrayDimensionsAttribute(UA_Client *client, const UA_NodeId nodeId,

size_t *outArrayDimensionsSize,

UA_UInt32 **outArrayDimensions);

static UA_INLINE UA_StatusCode

UA_Client_readAccessLevelAttribute(UA_Client *client, const UA_NodeId nodeId,

UA_Byte *outAccessLevel) {

return __UA_Client_readAttribute(client, &nodeId, UA_ATTRIBUTEID_ACCESSLEVEL,

outAccessLevel, &UA_TYPES[UA_TYPES_BYTE]);

}

static UA_INLINE UA_StatusCode

UA_Client_readUserAccessLevelAttribute(UA_Client *client, const UA_NodeId nodeId,

UA_Byte *outUserAccessLevel) {

return __UA_Client_readAttribute(client, &nodeId,

UA_ATTRIBUTEID_USERACCESSLEVEL,

outUserAccessLevel,

&UA_TYPES[UA_TYPES_BYTE]);

}

static UA_INLINE UA_StatusCode

UA_Client_readMinimumSamplingIntervalAttribute(UA_Client *client,

const UA_NodeId nodeId,

UA_Double *outMinSamplingInterval) {

return __UA_Client_readAttribute(client, &nodeId,

UA_ATTRIBUTEID_MINIMUMSAMPLINGINTERVAL,

outMinSamplingInterval,

&UA_TYPES[UA_TYPES_DOUBLE]);

}

static UA_INLINE UA_StatusCode

UA_Client_readHistorizingAttribute(UA_Client *client, const UA_NodeId nodeId,

UA_Boolean *outHistorizing) {

return __UA_Client_readAttribute(client, &nodeId, UA_ATTRIBUTEID_HISTORIZING,

outHistorizing, &UA_TYPES[UA_TYPES_BOOLEAN]);

}

static UA_INLINE UA_StatusCode

UA_Client_readExecutableAttribute(UA_Client *client, const UA_NodeId nodeId,

UA_Boolean *outExecutable) {

return __UA_Client_readAttribute(client, &nodeId, UA_ATTRIBUTEID_EXECUTABLE,

outExecutable, &UA_TYPES[UA_TYPES_BOOLEAN]);

}

static UA_INLINE UA_StatusCode

UA_Client_readUserExecutableAttribute(UA_Client *client, const UA_NodeId nodeId,

UA_Boolean *outUserExecutable) {

return __UA_Client_readAttribute(client, &nodeId,

UA_ATTRIBUTEID_USEREXECUTABLE,

outUserExecutable,

&UA_TYPES[UA_TYPES_BOOLEAN]);

}

看这些函数命名，几乎不用注释就可以猜到每个函数读的是什么内容。

写指定Node

static bool WriteValue(UA_Client *client,char* nodeIdStr,void *value,UINT type)

{

boolean result = true;

UA_Variant *myVariant = UA_Variant_new();

UA_NodeId nodeId = UA_NODEID_STRING(2, nodeIdStr);

UA_StatusCode code = UA_Variant_setScalarCopy(myVariant, value, &UA_TYPES[type]);

if(code != UA_STATUSCODE_GOOD)

{

result = false;

UA_Variant_delete(myVariant);

return result;

}

code=UA_Client_writeValueAttribute(client, nodeId, myVariant);

if (code != UA_STATUSCODE_GOOD)

{

result = false;

UA_Variant_delete(myVariant);

return result;

}

UA_Variant_delete(myVariant);

return result;

}

我是测试写了个字符串，因为相对字符串要比int、bool这些基本类型字符串读写的时候更需要注意。

和读一样，写也有一个比较低级的函数

UA_StatusCode UA_EXPORT

__UA_Client_writeAttribute(UA_Client *client, const UA_NodeId *nodeId,

UA_AttributeId attributeId, const void *in,

const UA_DataType *inDataType);

指定UA_AttributeId 去写。但是推荐比较高级的包装函数。

static UA_INLINE UA_StatusCode

UA_Client_writeNodeIdAttribute(UA_Client *client, const UA_NodeId nodeId,

const UA_NodeId *newNodeId) {

return __UA_Client_writeAttribute(client, &nodeId, UA_ATTRIBUTEID_NODEID,

newNodeId, &UA_TYPES[UA_TYPES_NODEID]);

}

static UA_INLINE UA_StatusCode

UA_Client_writeNodeClassAttribute(UA_Client *client, const UA_NodeId nodeId,

const UA_NodeClass *newNodeClass) {

return __UA_Client_writeAttribute(client, &nodeId, UA_ATTRIBUTEID_NODECLASS,

newNodeClass, &UA_TYPES[UA_TYPES_NODECLASS]);

}

static UA_INLINE UA_StatusCode

UA_Client_writeBrowseNameAttribute(UA_Client *client, const UA_NodeId nodeId,

const UA_QualifiedName *newBrowseName) {

return __UA_Client_writeAttribute(client, &nodeId, UA_ATTRIBUTEID_BROWSENAME,

newBrowseName,

&UA_TYPES[UA_TYPES_QUALIFIEDNAME]);

}

static UA_INLINE UA_StatusCode

UA_Client_writeDisplayNameAttribute(UA_Client *client, const UA_NodeId nodeId,

const UA_LocalizedText *newDisplayName) {

return __UA_Client_writeAttribute(client, &nodeId, UA_ATTRIBUTEID_DISPLAYNAME,

newDisplayName,

&UA_TYPES[UA_TYPES_LOCALIZEDTEXT]);

}

static UA_INLINE UA_StatusCode

UA_Client_writeDescriptionAttribute(UA_Client *client, const UA_NodeId nodeId,

const UA_LocalizedText *newDescription) {

return __UA_Client_writeAttribute(client, &nodeId, UA_ATTRIBUTEID_DESCRIPTION,

newDescription,

&UA_TYPES[UA_TYPES_LOCALIZEDTEXT]);

}

static UA_INLINE UA_StatusCode

UA_Client_writeWriteMaskAttribute(UA_Client *client, const UA_NodeId nodeId,

const UA_UInt32 *newWriteMask) {

return __UA_Client_writeAttribute(client, &nodeId, UA_ATTRIBUTEID_WRITEMASK,

newWriteMask, &UA_TYPES[UA_TYPES_UINT32]);

}

static UA_INLINE UA_StatusCode

UA_Client_writeUserWriteMaskAttribute(UA_Client *client, const UA_NodeId nodeId,

const UA_UInt32 *newUserWriteMask) {

return __UA_Client_writeAttribute(client, &nodeId,

UA_ATTRIBUTEID_USERWRITEMASK,

newUserWriteMask,

&UA_TYPES[UA_TYPES_UINT32]);

}

static UA_INLINE UA_StatusCode

UA_Client_writeIsAbstractAttribute(UA_Client *client, const UA_NodeId nodeId,

const UA_Boolean *newIsAbstract) {

return __UA_Client_writeAttribute(client, &nodeId, UA_ATTRIBUTEID_ISABSTRACT,

newIsAbstract, &UA_TYPES[UA_TYPES_BOOLEAN]);

}

static UA_INLINE UA_StatusCode

UA_Client_writeSymmetricAttribute(UA_Client *client, const UA_NodeId nodeId,

const UA_Boolean *newSymmetric) {

return __UA_Client_writeAttribute(client, &nodeId, UA_ATTRIBUTEID_SYMMETRIC,

newSymmetric, &UA_TYPES[UA_TYPES_BOOLEAN]);

}

static UA_INLINE UA_StatusCode

UA_Client_writeInverseNameAttribute(UA_Client *client, const UA_NodeId nodeId,

const UA_LocalizedText *newInverseName) {

return __UA_Client_writeAttribute(client, &nodeId, UA_ATTRIBUTEID_INVERSENAME,

newInverseName,

&UA_TYPES[UA_TYPES_LOCALIZEDTEXT]);

}

static UA_INLINE UA_StatusCode

UA_Client_writeContainsNoLoopsAttribute(UA_Client *client, const UA_NodeId nodeId,

const UA_Boolean *newContainsNoLoops) {

return __UA_Client_writeAttribute(client, &nodeId,

UA_ATTRIBUTEID_CONTAINSNOLOOPS,

newContainsNoLoops,

&UA_TYPES[UA_TYPES_BOOLEAN]);

}

static UA_INLINE UA_StatusCode

UA_Client_writeEventNotifierAttribute(UA_Client *client, const UA_NodeId nodeId,

const UA_Byte *newEventNotifier) {

return __UA_Client_writeAttribute(client, &nodeId,

UA_ATTRIBUTEID_EVENTNOTIFIER,

newEventNotifier,

&UA_TYPES[UA_TYPES_BYTE]);

}

static UA_INLINE UA_StatusCode

UA_Client_writeValueAttribute(UA_Client *client, const UA_NodeId nodeId,

const UA_Variant *newValue) {

return __UA_Client_writeAttribute(client, &nodeId, UA_ATTRIBUTEID_VALUE,

newValue, &UA_TYPES[UA_TYPES_VARIANT]);

}

static UA_INLINE UA_StatusCode

UA_Client_writeDataTypeAttribute(UA_Client *client, const UA_NodeId nodeId,

const UA_NodeId *newDataType) {

return __UA_Client_writeAttribute(client, &nodeId, UA_ATTRIBUTEID_DATATYPE,

newDataType, &UA_TYPES[UA_TYPES_NODEID]);

}

static UA_INLINE UA_StatusCode

UA_Client_writeValueRankAttribute(UA_Client *client, const UA_NodeId nodeId,

const UA_Int32 *newValueRank) {

return __UA_Client_writeAttribute(client, &nodeId, UA_ATTRIBUTEID_VALUERANK,

newValueRank, &UA_TYPES[UA_TYPES_INT32]);

}

UA_StatusCode UA_EXPORT

UA_Client_writeArrayDimensionsAttribute(UA_Client *client, const UA_NodeId nodeId,

size_t newArrayDimensionsSize,

const UA_UInt32 *newArrayDimensions);

static UA_INLINE UA_StatusCode

UA_Client_writeAccessLevelAttribute(UA_Client *client, const UA_NodeId nodeId,

const UA_Byte *newAccessLevel) {

return __UA_Client_writeAttribute(client, &nodeId, UA_ATTRIBUTEID_ACCESSLEVEL,

newAccessLevel, &UA_TYPES[UA_TYPES_BYTE]);

}

static UA_INLINE UA_StatusCode

UA_Client_writeUserAccessLevelAttribute(UA_Client *client, const UA_NodeId nodeId,

const UA_Byte *newUserAccessLevel) {

return __UA_Client_writeAttribute(client, &nodeId,

UA_ATTRIBUTEID_USERACCESSLEVEL,

newUserAccessLevel,

&UA_TYPES[UA_TYPES_BYTE]);

}

static UA_INLINE UA_StatusCode

UA_Client_writeMinimumSamplingIntervalAttribute(UA_Client *client,

const UA_NodeId nodeId,

const UA_Double *newMinInterval) {

return __UA_Client_writeAttribute(client, &nodeId,

UA_ATTRIBUTEID_MINIMUMSAMPLINGINTERVAL,

newMinInterval, &UA_TYPES[UA_TYPES_DOUBLE]);

}

static UA_INLINE UA_StatusCode

UA_Client_writeHistorizingAttribute(UA_Client *client, const UA_NodeId nodeId,

const UA_Boolean *newHistorizing) {

return __UA_Client_writeAttribute(client, &nodeId, UA_ATTRIBUTEID_HISTORIZING,

newHistorizing, &UA_TYPES[UA_TYPES_BOOLEAN]);

}

static UA_INLINE UA_StatusCode

UA_Client_writeExecutableAttribute(UA_Client *client, const UA_NodeId nodeId,

const UA_Boolean *newExecutable) {

return __UA_Client_writeAttribute(client, &nodeId, UA_ATTRIBUTEID_EXECUTABLE,

newExecutable, &UA_TYPES[UA_TYPES_BOOLEAN]);

}

static UA_INLINE UA_StatusCode

UA_Client_writeUserExecutableAttribute(UA_Client *client, const UA_NodeId nodeId,

const UA_Boolean *newUserExecutable) {

return __UA_Client_writeAttribute(client, &nodeId,

UA_ATTRIBUTEID_USEREXECUTABLE,

newUserExecutable,

&UA_TYPES[UA_TYPES_BOOLEAN]);

}

函数命名几乎和读一样，根据函数名称一目了然。

订阅模式

static void

handler_TheAnswerChanged(UA_Client *client, UA_UInt32 subId, void *subContext,

UA_UInt32 monId, void *monContext, UA_DataValue *value) {

UA_String valueStr = *(UA_String*)value->value.data;

printf("The Answer has changed! %s

",valueStr.data);

}

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

", subId);

UA_MonitoredItemCreateRequest monRequest =

UA_MonitoredItemCreateRequest_default(UA_NODEID_STRING(2, "CX62KX63.ER.Queue.CarVin"));

UA_MonitoredItemCreateResult monResponse =

UA_Client_MonitoredItems_createDataChange(client, response.subscriptionId,

UA_TIMESTAMPSTORETURN_BOTH,

monRequest, NULL, handler_TheAnswerChanged, NULL);

if (monResponse.statusCode == UA_STATUSCODE_GOOD)

printf("Monitoring 'the.answer', id %u

", monResponse.monitoredItemId);

//UA_Client_Subscriptions_manuallySendPublishRequest(client);

UA_StatusCode code = UA_Client_run_iterate(client, 10);  //lw这里报错，所以先注释掉

对于订阅模式，open62541.c 和 open62541.h和源代码不一致，找不到UA_StatusCode code = UA_Client_run_iterate(client, 10);这个函数(其实用了这个函数程序就编译不过去，我这里是因为我把源代码的一些东西拿过来了，所以能编译过)。也可以不用这个函数，用UA_Client_Subscriptions_manuallySendPublishRequest(client);这个函数，但是这个函数被标记废弃了

不过我测试了下，还可以用。

未测试的功能

添加NODE

/* Add new nodes*/

/* New ReferenceType */

UA_NodeId ref_id;

UA_ReferenceTypeAttributes ref_attr = UA_ReferenceTypeAttributes_default;

ref_attr.displayName = UA_LOCALIZEDTEXT("en-US", "NewReference");

ref_attr.description = UA_LOCALIZEDTEXT("en-US", "References something that might or might not exist");

ref_attr.inverseName = UA_LOCALIZEDTEXT("en-US", "IsNewlyReferencedBy");

retval = UA_Client_addReferenceTypeNode(client,

UA_NODEID_NUMERIC(1, 12133),

UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES),

UA_NODEID_NUMERIC(0, UA_NS0ID_HASSUBTYPE),

UA_QUALIFIEDNAME(1, "NewReference"),

ref_attr, &ref_id);

if (retval == UA_STATUSCODE_GOOD)

printf("Created 'NewReference' with numeric NodeID %u

", ref_id.identifier.numeric);

/* New ObjectType */

UA_NodeId objt_id;

UA_ObjectTypeAttributes objt_attr = UA_ObjectTypeAttributes_default;

objt_attr.displayName = UA_LOCALIZEDTEXT("en-US", "TheNewObjectType");

objt_attr.description = UA_LOCALIZEDTEXT("en-US", "Put innovative description here");

retval = UA_Client_addObjectTypeNode(client,

UA_NODEID_NUMERIC(1, 12134),

UA_NODEID_NUMERIC(0, UA_NS0ID_BASEOBJECTTYPE),

UA_NODEID_NUMERIC(0, UA_NS0ID_HASSUBTYPE),

UA_QUALIFIEDNAME(1, "NewObjectType"),

objt_attr, &objt_id);

if (retval == UA_STATUSCODE_GOOD)

printf("Created 'NewObjectType' with numeric NodeID %u

", objt_id.identifier.numeric);

/* New Object */

UA_NodeId obj_id;

UA_ObjectAttributes obj_attr = UA_ObjectAttributes_default;

obj_attr.displayName = UA_LOCALIZEDTEXT("en-US", "TheNewGreatNode");

obj_attr.description = UA_LOCALIZEDTEXT("de-DE", "Hier koennte Ihre Webung stehen!");

retval = UA_Client_addObjectNode(client,

UA_NODEID_NUMERIC(1, 0),

UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER),

UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES),

UA_QUALIFIEDNAME(1, "TheGreatNode"),

UA_NODEID_NUMERIC(1, 12134),

obj_attr, &obj_id);

if (retval == UA_STATUSCODE_GOOD)

printf("Created 'NewObject' with numeric NodeID %u

", obj_id.identifier.numeric);

/* New Integer Variable */

UA_NodeId var_id;

UA_VariableAttributes var_attr = UA_VariableAttributes_default;

var_attr.displayName = UA_LOCALIZEDTEXT("en-US", "TheNewVariableNode");

var_attr.description =

UA_LOCALIZEDTEXT("en-US", "This integer is just amazing - it has digits and everything.");

UA_Int32 int_value = 1234;

/* This does not copy the value */

UA_Variant_setScalar(&var_attr.value, &int_value, &UA_TYPES[UA_TYPES_INT32]);

var_attr.dataType = UA_TYPES[UA_TYPES_INT32].typeId;

retval = UA_Client_addVariableNode(client,

UA_NODEID_NUMERIC(1, 0), // Assign new/random NodeID

UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER),

UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES),

UA_QUALIFIEDNAME(0, "VariableNode"),

UA_NODEID_NULL, // no variable type

var_attr, &var_id);

if (retval == UA_STATUSCODE_GOOD)

printf("Created 'NewVariable' with numeric NodeID %u

", var_id.identifier.numeric);

这个功能我暂时还没有测试，等有时间再深入研究。

结束

---------------------

作者：liwen9016

来源：优快云

原文：https://blog.youkuaiyun.com/liwen9016/article/details/81982662

open62541 linux编译,OPCUA学习记录——open62541.c|open62541.h|open62541.a文件生成
weixin_36336256的博客
05-04 2352
这些时间一直在进行OPCUA服务器代码的学习，一开始最麻烦的是进行在gethub上下载下来open62541的开源项目进行.c和.h的生成，由于本人在window下生成的.c和.h文件在项目移植到ubuntu下后出现了下图所示错误。 最后定位错误为在gethub网站下载的代码缺少部分代码和使能，导致.h中的函数无法定位到.c文件中的函数引发的错误。最后还是在ubuntu下编译工程文件后使用其.c和...
opc62541linux编译,【一】基于open62541的OPC UA服务器和客户端
weixin_31512775的博客
05-01 1038
OPC UA的好处就不说了，既然你找到了这篇文章，说明你对其已经有了必定的了解。htmlopen62541是在Mozilla Public License v2.0下受权的一个开源的、可跨平台的OPC UA库，采用C(C99)实现。node在open62541的官网有详细的帮助文档，推荐直接查看该文档，做者也是根据其文档的帮助实现的基本功能。github 在下方可根据须要自行下载相关文件安全 固然...
Open62541 Linux静态库
08-24
Linux 下编译的OPC UA Open62541 静态库文件，包括server Client
【OpcUA开发笔记 2】open62541在Linux下编译及Qt开发
jam12315的专栏
02-19 1860
在上一篇中，我们记录了在windows下通过CMake编译minigw版本的open62541，事实上是为了这一篇做铺垫，我们本次就在ubuntu下编译open62541，并通过Qt来调用它。
Qt+OPC开发笔记（三）：OPC客户端订阅特点消息的Demo
最新发布
weixin_33507566的博客
07-02 37
本篇介绍opc客户端订阅消息，实现一个opc事件的订阅，当订阅的数据在服务器发生变化是，客户端能立即得到更新。
linux系统下open62541的安装
canyuemanyue的博客
07-22 1118
前言open62541是OPC的一个开源实现，本文就在ubuntu20.04系统下编译、使用open62541。
opc62541linux编译,open62541
weixin_31613423的博客
05-01 409
软件简介open62541 是 OPC UA 规范的C语言开源实现。OPC通信标准的核心是互通性 (Interoperability) 和标准化 (Standardization)问题。传统的OPC技术在控制级别很好地解决了硬件设备间的互通性问题，在企业层面的通信标准化是同样需要的。OPCUA之前的访问规范都是基于微软的COM/DCOM技术， 这会给新增层面的通信带来不可根除的弱点。加上传统OPC...
Linux编译open62541,open ua统一标准指导文档(ice 62541)
weixin_32159633的博客
05-11 418
【实例简介】open ua统一标准指导文档，基于C语言的。包含了节点，函数，类型等基础说明。以及open ua服务器/客户端建立的一些基本实例。Contents1 IntroductionI1 OPC Unified Architectureen62541 Features1.3 Getting Hel1. 4 Contributing2 Building open 625412.1 Buildi...
open62541-arm-linux服务器
02-04
"open62541-arm-linux服务器" 指的是一个基于Open62541协议栈的服务器实现，该实现是专为ARM架构的Linux操作系统设计的。Open62541是一个开源项目，提供了一套符合OPC统一架构（OPC UA）标准的软件开发工具包，用于...
OPCUA开源文件open62541及demo
11-10
open62541库的两个主要文件是open62541.c和open62541.h。open62541.c包含了库的源代码实现，而open62541.h则是库的头文件，包含了定义和声明，供开发者在项目中引用。该库支持OPC UA的基本功能，如数据模型、会话...
手把手教--Arm Linux 移植 open62541
weixin_46158019的博客
08-23 1511
系统：Ubuntu 22.04.03open62541 版本：V1.4。
学习open62541 — [24] 定时执行任务
01-06
open62541提供定时执行任务功能，这个功能很实用，在前面的文章中，有时我们想定时的去修改一些变量节点的值，都是开一个线程去做的，相对来说有点小麻烦。使用open62541自带的定时器就会简单很多。 下面来看下如何使用open62541提供定时功能。 一 相关api 首先要知道一些关于定时任务的简单知识， 定时任务分为定时执行一次（也叫one shot）和定时循环执行（有个定时周期）2种 当定时任务被添加到定时器的执行列表里后，就开始计时 也可以看下linux系统提供的api，促进理解，点击这里。 api分为Server端和Client端，如下， Server端 /** * Timed
基于open62541的服务器和客户端
07-09
基于open62541的服务器和客户端，使用vs2015开发工具，有服务器和客户端代码和执行文件，程序为32位。
opc62541linux编译,【零】基于open62541项目编译单独的open62541源文件和头文件
weixin_39681486的博客
05-01 450
本文是如何编译C语言的OPC UA源码open62541生成适用于Windows平台单独的.c和.h的教程，本文使用的是Windows 10 家庭版，cmake-3.15.0-rc3-win64-x64，Visual Studio Community 2017首先安装git，这个网上一堆教程，我就不详细写了安装cmake，这个可以直接在官网下载，安装的网上也有相应的教程，一路next就行下载ope...
OPC UA开源库Open62541源码编译及Client客户端Server服务器端测试[一]
lzc881012的博客
01-19 5130
pen62541 是一款开源的嵌入式系统开发手册，旨在帮助开发者快速掌握 Open62541 的开发技能。本文将从 Open62541 的概述、功能、开发环境、编程接口和应用案例五个方面进行介绍。
linux/windows下基于opc ua协议使用open62541开发客户端-上
山河君的分享博客
03-01 3070
最近公司想把windows下软件迁移到linux下，在与plc通讯方面西门子只提供windows下的库，linux下没有对应库，幸好发现有open62541这个协议外接库，对应的plc最低型号为s1200，还必须升级固件才行。官方貌似有实例代码，但是看起来杂乱无章，现在整理一下。 很想直接上代码，但是先简单介绍一下，使用博图16版本进行配合使用，连接有两种方式，一种匿名连接，一种有名连接，根据需要...
学习open62541 --- [74] 软链接的妙用
爱就是是恒久忍耐的专栏
02-12 1043
使用软链接操作open62541
open62541_arm_linux移植
占毛毛
02-04 321
open62541_arm_linux移植
OPEN62541编译选项
BJ4015的博客
08-14 332
open62541编译选项
open62541 编译 linux
06-02
要在 Linux 上编译 open62541，可以按照以下步骤进行操作： 1. 下载 open62541 的源代码，可以在官网下载或者使用 Git 克隆代码库。 2. 安装必要的依赖库，包括 cmake、build-essential、python等。 3. 进入 open...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值