open62541 Alarm&Condition

最新推荐文章于 2024-06-11 11:57:41 发布
最新推荐文章于 2024-06-11 11:57:41 发布
阅读量950 收藏 1
点赞数
分类专栏： open62541 文章标签： c语言 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_47722349/article/details/124879333
版权

概述

Alarm&Condition是基于事件之上的，它提供了更多的操作方式，比如对告警的确认（ack）、提交（commit）等。举个简单例子，一个机器开始启动时向操作人员发送了一个告警，在操作人员进行确认（ack）后机器才会继续运行。前面提到的事件是通过手动触发的，而对于Alarm来说，在某个状态改变后，事件是由服务器内部进行触发。事件类型的模型如下
在这里插入图片描述
更详细的说明在UA Part 9中有讲述，可以自行阅读，这里主要讲述OffNormalAlarm类型条件变量大致的使用，在此之前可先浏览事件这篇文章。

编译open62541

这里使用cmake进行编译，勾选选项如下
在这里插入图片描述
在这里插入图片描述
这里需要将UA_NAMESPACE_ZERO选择为FULL选项。点击Generate后会发现生成不成功，如下
在这里插入图片描述
可以看到提示信息我们缺少Opc.Ua.NodeSet2.xml这个NodeSet文件。这里我们去下载官方提供的一些NodeSet，其中就包括我们需要的这个NodeSet。NodeSet集下载地址下载完毕后可以看到其内容如下
在这里插入图片描述
其中Schema文件夹中就含有我们需要的Opc.Ua.NodeSet2.xml，将Schema整个文件夹复制去Generate生成的报错信息那个路径，以我路径为例
在这里插入图片描述
重新Generate后就可以看到成功了，
在这里插入图片描述
除此之外也可以修改CMakeLists.txt中的路径去进行设置，
在这里插入图片描述
最后编译vs工程就可得到open62541.h和open62541.c文件。

解释一下这里为啥要修改UA_NAMESPACE_ZERO为FULL，主要是MINIMAL和REDUCED属于不完全版本，有些类型并没有进行添加，我们可以发现编译FULL出来的文件大了很多主要就是这个原因。同时CMakeLists.txt中指明了我们需要进行修改
在这里插入图片描述

触发alarm&condition

这里以tutorial_server_alarms_conditions.c例程进行讲述，其代码如下，稍作修改。

/* 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/server.h>
//#include <open62541/server_config_default.h>
#include "open62541.h"

#include <signal.h>
#include <stdlib.h>

/**
 * Using Alarms and Conditions Server
 * ----------------------------------
 *
 * Besides the usage of monitored items and events to observe the changes in the
 * server, it is also important to make use of the Alarms and Conditions Server
 * Model. Alarms are events which are triggered automatically by the server
 * dependent on internal server logic or user specific logic when the states of
 * server components change. The state of a component is represented through a
 * condition. So the values of all the condition children (Fields) are the
 * actual state of the component.
 *
 * Trigger Alarm events by changing States
 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 *
 * The following example will be based on the server events tutorial. Please
 * make sure to understand the principle of normal events before proceeding with
 * this example! */

static UA_NodeId conditionSource;
static UA_NodeId conditionInstance_1;
static UA_NodeId conditionInstance_2;

static UA_StatusCode
addConditionSourceObject(UA_Server *server) {
    UA_ObjectAttributes object_attr = UA_ObjectAttributes_default;
    object_attr.eventNotifier = 1;

    object_attr.displayName = UA_LOCALIZEDTEXT("en", "ConditionSourceObject");
    UA_StatusCode retval =  UA_Server_addObjectNode(server, UA_NODEID_NULL,
                                      UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER),
                                      UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES),
                                      UA_QUALIFIEDNAME(0, "ConditionSourceObject"),
                                      UA_NODEID_NUMERIC(0, UA_NS0ID_BASEOBJECTTYPE),
                                      object_attr, NULL, &conditionSource);

    if(retval != UA_STATUSCODE_GOOD) {
        UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND,
                     "Creating Condition Source failed. StatusCode %s",
                     UA_StatusCode_name(retval));
    }

    /* ConditionSource should be EventNotifier of another Object (usually the
     * Server Object). If this Reference is not created by user then the A&C
     * Server will create "HasEventSource" reference to the Server Object
     * automatically when the condition is created*/
    retval = UA_Server_addReference(server, UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER),
                                     UA_NODEID_NUMERIC(0, UA_NS0ID_HASNOTIFIER),
                                     UA_EXPANDEDNODEID_NUMERIC(conditionSource.namespaceIndex,
                                     							conditionSource.identifier.numeric),
                                     UA_TRUE);


    return retval;
}

/**
 * Create a condition instance from OffNormalAlarmType. The condition source is
 * the Object created in addConditionSourceObject(). The condition will be
 * exposed in Address Space through the HasComponent reference to the condition
 * source. */
static UA_StatusCode
addCondition_1(UA_Server *server) {
    UA_StatusCode retval = addConditionSourceObject(server);
    if(retval != UA_STATUSCODE_GOOD) {
        UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND,
                     "creating Condition Source failed. StatusCode %s",
                     UA_StatusCode_name(retval));
    }

    retval = UA_Server_createCondition(server,
                                       UA_NODEID_NULL,
									   UA_NODEID_NUMERIC(0,UA_NS0ID_OFFNORMALALARMTYPE),
                                       UA_QUALIFIEDNAME(0, "Condition 1"), 			conditionSource,
                                       UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT),
                                       &conditionInstance_1);

    return retval;
}

/**
 * Create a condition instance from OffNormalAlarmType. The condition source is
 * the server Object. The condition won't be exposed in Address Space. */
static UA_StatusCode
addCondition_2(UA_Server *server) {
    UA_StatusCode retval =
        UA_Server_createCondition(server, UA_NODEID_NULL,
                                  UA_NODEID_NUMERIC(0,UA_NS0ID_OFFNORMALALARMTYPE),
                                  UA_QUALIFIEDNAME(0, "Condition 2"),
								  UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER),
								  UA_NODEID_NULL,
								  &conditionInstance_2);

    return retval;
}

static void
addVariable_1_triggerAlarmOfCondition_1(UA_Server *server, UA_NodeId* outNodeId) {
    UA_VariableAttributes attr = UA_VariableAttributes_default;
    attr.displayName = UA_LOCALIZEDTEXT("en", "Activate Condition 1");
    attr.accessLevel = UA_ACCESSLEVELMASK_READ | UA_ACCESSLEVELMASK_WRITE;
    UA_Boolean tboolValue = UA_FALSE;
    UA_Variant_setScalar(&attr.value, &tboolValue, &UA_TYPES[UA_TYPES_BOOLEAN]); 

    UA_QualifiedName CallbackTestVariableName = UA_QUALIFIEDNAME(0, "Activate Condition 1");
    UA_NodeId parentNodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER);
    UA_NodeId parentReferenceNodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES);
    UA_NodeId variableTypeNodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE);
    UA_Server_addVariableNode(server, UA_NODEID_NULL, parentNodeId,
                              parentReferenceNodeId, CallbackTestVariableName,
                              variableTypeNodeId, attr, NULL, outNodeId);
}

static void
addVariable_2_changeSeverityOfCondition_2(UA_Server *server,
                                          UA_NodeId* outNodeId) {
    UA_VariableAttributes attr = UA_VariableAttributes_default;
    attr.displayName = UA_LOCALIZEDTEXT("en", "Change Severity Condition 2");
    attr.accessLevel = UA_ACCESSLEVELMASK_READ | UA_ACCESSLEVELMASK_WRITE;
    UA_UInt16 severityValue = 0;
    UA_Variant_setScalar(&attr.value, &severityValue, &UA_TYPES[UA_TYPES_UINT16]);

    UA_QualifiedName CallbackTestVariableName =
        UA_QUALIFIEDNAME(0, "Change Severity Condition 2");
    UA_NodeId parentNodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER);
    UA_NodeId parentReferenceNodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES);
    UA_NodeId variableTypeNodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE);
    UA_Server_addVariableNode(server, UA_NODEID_NULL, parentNodeId,
                              parentReferenceNodeId, CallbackTestVariableName,
                              variableTypeNodeId, attr, NULL, outNodeId);
}

static void
addVariable_3_returnCondition_1_toNormalState(UA_Server *server,
                                              UA_NodeId* outNodeId) {
    UA_VariableAttributes attr = UA_VariableAttributes_default;
    attr.displayName = UA_LOCALIZEDTEXT("en", "Return to Normal Condition 1");
    attr.accessLevel = UA_ACCESSLEVELMASK_READ | UA_ACCESSLEVELMASK_WRITE;
    UA_Boolean rtn = 0;
    UA_Variant_setScalar(&attr.value, &rtn, &UA_TYPES[UA_TYPES_BOOLEAN]);

    UA_QualifiedName CallbackTestVariableName =
        UA_QUALIFIEDNAME(0, "Return to Normal Condition 1");
    UA_NodeId parentNodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER);
    UA_NodeId parentReferenceNodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES);
    UA_NodeId variableTypeNodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE);
    UA_Server_addVariableNode(server, UA_NODEID_NULL, parentNodeId,
                              parentReferenceNodeId, CallbackTestVariableName,
                              variableTypeNodeId, attr, NULL, outNodeId);
}

static void
afterWriteCallbackVariable_1(UA_Server *server, const UA_NodeId *sessionId,
                             void *sessionContext, const UA_NodeId *nodeId,
                             void *nodeContext, const UA_NumericRange *range,
                             const UA_DataValue *data) {
    UA_QualifiedName activeStateField = UA_QUALIFIEDNAME(0,"ActiveState");
    UA_QualifiedName activeStateIdField = UA_QUALIFIEDNAME(0,"Id");
    UA_Variant value;

    UA_StatusCode retval =
        UA_Server_writeObjectProperty_scalar(server, conditionInstance_1,
                                             UA_QUALIFIEDNAME(0, "Time"),
                                             &data->sourceTimestamp,
                                             &UA_TYPES[UA_TYPES_DATETIME]);

    if(*(UA_Boolean *)(data->value.data) == true) {
        /* By writing "true" in ActiveState/Id, the A&C server will set the
         * related fields automatically and then will trigger event
         * notification. */
        UA_Boolean activeStateId = true;
        UA_Variant_setScalar(&value, &activeStateId, &UA_TYPES[UA_TYPES_BOOLEAN]);
        retval |= UA_Server_setConditionVariableFieldProperty(server, conditionInstance_1,
                                                              &value, activeStateField,
                                                              activeStateIdField);
        if(retval != UA_STATUSCODE_GOOD) {
            UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND,
                         "Setting ActiveState/Id Field failed. StatusCode %s",
                         UA_StatusCode_name(retval));
            return;
        }
    } else {
        /* By writing "false" in ActiveState/Id, the A&C server will set only
         * the ActiveState field automatically to the value "Inactive". The user
         * should trigger the event manually by calling
         * UA_Server_triggerConditionEvent inside the application or call
         * ConditionRefresh method with client to update the event notification. */
        UA_Boolean activeStateId = false;
        UA_Variant_setScalar(&value, &activeStateId, &UA_TYPES[UA_TYPES_BOOLEAN]);
        retval = UA_Server_setConditionVariableFieldProperty(server, conditionInstance_1,
                                                             &value, activeStateField,
                                                             activeStateIdField);
        if(retval != UA_STATUSCODE_GOOD) {
            UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND,
                         "Setting ActiveState/Id Field failed. StatusCode %s",
                         UA_StatusCode_name(retval));
            return;
        }

        retval = UA_Server_triggerConditionEvent(server, conditionInstance_1,
                                                 conditionSource, NULL);
        if(retval != UA_STATUSCODE_GOOD) {
            UA_LOG_WARNING(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND,
                           "Triggering condition event failed. StatusCode %s",
                           UA_StatusCode_name(retval));
            return;
        }
    }
}

/**
 * The callback only changes the severity field of the condition 2. The severity
 * field is of ConditionVariableType, so changes in it triggers an event
 * notification automatically by the server. */
static void
afterWriteCallbackVariable_2(UA_Server *server, const UA_NodeId *sessionId,
                             void *sessionContext, const UA_NodeId *nodeId,
                             void *nodeContext, const UA_NumericRange *range,
                             const UA_DataValue *data) {

	UA_String str = UA_STRING_ALLOC("test call");
   /* Another way to set fields of conditions */
	UA_Server_writeObjectProperty_scalar(server, conditionInstance_2,
		UA_QUALIFIEDNAME(0, "Severity"),
		(UA_UInt16 *)data->value.data,
		&UA_TYPES[UA_TYPES_UINT16]);
}

/**
 * RTN = return to normal.
 *
 * Retain will be set to false, thus no events will be generated for condition 1
 * (although EnabledState/=true). To set Retain to true again, the disable and
 * enable methods should be called respectively.
 */
static void
afterWriteCallbackVariable_3(UA_Server *server,
               const UA_NodeId *sessionId, void *sessionContext,
               const UA_NodeId *nodeId, void *nodeContext,
               const UA_NumericRange *range, const UA_DataValue *data) {

    //UA_QualifiedName enabledStateField = UA_QUALIFIEDNAME(0,"EnabledState");
    UA_QualifiedName ackedStateField = UA_QUALIFIEDNAME(0,"AckedState");
    UA_QualifiedName confirmedStateField = UA_QUALIFIEDNAME(0,"ConfirmedState");
    UA_QualifiedName activeStateField = UA_QUALIFIEDNAME(0,"ActiveState");
    UA_QualifiedName severityField = UA_QUALIFIEDNAME(0,"Severity");
    UA_QualifiedName messageField = UA_QUALIFIEDNAME(0,"Message");
    UA_QualifiedName commentField = UA_QUALIFIEDNAME(0,"Comment");
    UA_QualifiedName retainField = UA_QUALIFIEDNAME(0,"Retain");
    UA_QualifiedName idField = UA_QUALIFIEDNAME(0,"Id");

    UA_StatusCode retval =
        UA_Server_writeObjectProperty_scalar(server, conditionInstance_1,
                                             UA_QUALIFIEDNAME(0, "Time"),
                                             &data->serverTimestamp,
                                             &UA_TYPES[UA_TYPES_DATETIME]);
    UA_Variant value;
    UA_Boolean idValue = false;
    UA_Variant_setScalar(&value, &idValue, &UA_TYPES[UA_TYPES_BOOLEAN]);
    retval |= UA_Server_setConditionVariableFieldProperty(server, conditionInstance_1,
                                                          &value, activeStateField,
                                                          idField);
    if(retval != UA_STATUSCODE_GOOD) {
        UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND,
                     "Setting ActiveState/Id Field failed. StatusCode %s",
                     UA_StatusCode_name(retval));
        return;
    }

    retval = UA_Server_setConditionVariableFieldProperty(server, conditionInstance_1,
                                                         &value, ackedStateField,
                                                         idField);
    if(retval != UA_STATUSCODE_GOOD) {
        UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND,
                     "Setting AckedState/Id Field failed. StatusCode %s",
                     UA_StatusCode_name(retval));
        return;
    }

    retval = UA_Server_setConditionVariableFieldProperty(server, conditionInstance_1,
                                                         &value, confirmedStateField,
                                                         idField);
    if(retval != UA_STATUSCODE_GOOD) {
        UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND,
                     "Setting ConfirmedState/Id Field failed. StatusCode %s",
                     UA_StatusCode_name(retval));
        return;
    }

    UA_UInt16 severityValue = 100;
    UA_Variant_setScalar(&value, &severityValue, &UA_TYPES[UA_TYPES_UINT16]);
    retval = UA_Server_setConditionField(server, conditionInstance_1,
                                         &value, severityField);
    if(retval != UA_STATUSCODE_GOOD) {
        UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND,
                     "Setting Severity Field failed. StatusCode %s",
                     UA_StatusCode_name(retval));
        return;
    }

    UA_LocalizedText messageValue =
        UA_LOCALIZEDTEXT("en", "Condition returned to normal state");
    UA_Variant_setScalar(&value, &messageValue, &UA_TYPES[UA_TYPES_LOCALIZEDTEXT]);
    retval = UA_Server_setConditionField(server, conditionInstance_1,
                                         &value, messageField);
    if(retval != UA_STATUSCODE_GOOD) {
        UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND,
                     "Setting Message Field failed. StatusCode %s",
                     UA_StatusCode_name(retval));
        return;
    }

    UA_LocalizedText commentValue = UA_LOCALIZEDTEXT("en", "Normal State");
    UA_Variant_setScalar(&value, &commentValue, &UA_TYPES[UA_TYPES_LOCALIZEDTEXT]);
    retval = UA_Server_setConditionField(server, conditionInstance_1,
                                         &value, commentField);
    if(retval != UA_STATUSCODE_GOOD) {
        UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND,
                     "Setting Comment Field failed. StatusCode %s",
                     UA_StatusCode_name(retval));
        return;
    }

    UA_Boolean retainValue = false;
    UA_Variant_setScalar(&value, &retainValue, &UA_TYPES[UA_TYPES_BOOLEAN]);
    retval = UA_Server_setConditionField(server, conditionInstance_1,
                                         &value, retainField);
    if(retval != UA_STATUSCODE_GOOD) {
        UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND,
                     "Setting Retain Field failed. StatusCode %s",
                     UA_StatusCode_name(retval));
        return;
    }

    retval = UA_Server_triggerConditionEvent(server, conditionInstance_1,
                                             conditionSource, NULL);
    if (retval != UA_STATUSCODE_GOOD) {
     UA_LOG_WARNING(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND,
                    "Triggering condition event failed. StatusCode %s",
                    UA_StatusCode_name(retval));
     return;
    }
}

static UA_StatusCode
enteringEnabledStateCallback(UA_Server *server, const UA_NodeId *condition) {
	printf("enteringEnabledStateCallback\n");
    UA_Boolean retain = true;
    return UA_Server_writeObjectProperty_scalar(server, *condition,
                                                UA_QUALIFIEDNAME(0, "Retain"),
                                                &retain,
                                                &UA_TYPES[UA_TYPES_BOOLEAN]);
}

/**
 * This is user specific function which will be called upon acknowledging an
 * alarm notification. In this example we will set the Alarm to Inactive state.
 * The server is responsible of setting standard fields related to Acknowledge
 * Method and triggering the alarm notification. */
static UA_StatusCode
enteringAckedStateCallback(UA_Server *server, const UA_NodeId *condition) {
	printf("enteringAckedStateCallback\n");
    /* deactivate Alarm when acknowledging*/
    UA_Boolean activeStateId = false;
    UA_Variant value;
    UA_QualifiedName activeStateField = UA_QUALIFIEDNAME(0,"ActiveState");
    UA_QualifiedName activeStateIdField = UA_QUALIFIEDNAME(0,"Id");

    UA_Variant_setScalar(&value, &activeStateId, &UA_TYPES[UA_TYPES_BOOLEAN]);
    UA_StatusCode retval =
        UA_Server_setConditionVariableFieldProperty(server, *condition,
                                                    &value, activeStateField,
                                                    activeStateIdField);

    if(retval != UA_STATUSCODE_GOOD) {
        UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND,
                     "Setting ActiveState/Id Field failed. StatusCode %s",
                     UA_StatusCode_name(retval));
    }

    return retval;
}

static UA_StatusCode
enteringConfirmedStateCallback(UA_Server *server, const UA_NodeId *condition) {
	printf("enteringConfirmedStateCallback\n");
	/* Deactivate Alarm and put it out of the interesting state (by writing
     * false to Retain field) when confirming*/
    UA_Boolean activeStateId = false;
    UA_Boolean retain = false;
    UA_Variant value;
    UA_QualifiedName activeStateField = UA_QUALIFIEDNAME(0,"ActiveState");
    UA_QualifiedName activeStateIdField = UA_QUALIFIEDNAME(0,"Id");
    UA_QualifiedName retainField = UA_QUALIFIEDNAME(0,"Retain");

    UA_Variant_setScalar(&value, &activeStateId, &UA_TYPES[UA_TYPES_BOOLEAN]);
    UA_StatusCode retval =
        UA_Server_setConditionVariableFieldProperty(server, *condition,
                                                    &value, activeStateField,
                                                    activeStateIdField);
    if(retval != UA_STATUSCODE_GOOD) {
        UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND,
                     "Setting ActiveState/Id Field failed. StatusCode %s",
                     UA_StatusCode_name(retval));
        return retval;
    }

    UA_Variant_setScalar(&value, &retain, &UA_TYPES[UA_TYPES_BOOLEAN]);
    retval = UA_Server_setConditionField(server, *condition,
                                         &value, retainField);
    if(retval != UA_STATUSCODE_GOOD) {
        UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND,
                     "Setting ActiveState/Id Field failed. StatusCode %s",
                     UA_StatusCode_name(retval));
    }

    return retval;
}

static UA_StatusCode
setUpEnvironment(UA_Server *server) {
    UA_NodeId variable_1;
    UA_NodeId variable_2;
    UA_NodeId variable_3;
    UA_ValueCallback callback;
    callback.onRead = NULL;

    /* Exposed condition 1. We will add to it user specific callbacks when
     * entering enabled state, when acknowledging and when confirming. */
    UA_StatusCode retval = addCondition_1(server);
    if(retval != UA_STATUSCODE_GOOD) {
        UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND,
                     "adding condition 1 failed. StatusCode %s",
                     UA_StatusCode_name(retval));
        return retval;
    }
#if 1
    /* Unexposed condition 2. No user specific callbacks, so the server will
     * behave in a standard manner upon entering enabled state, acknowledging
     * and confirming. We will set Retain field to true and enable the condition
     * so we can receive event notifications (we cannot call enable method on
     * unexposed condition using a client like UaExpert or Softing). */
    retval = addCondition_2(server);
    if(retval != UA_STATUSCODE_GOOD) {
        UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND,
                     "adding condition 2 failed. StatusCode %s",
                     UA_StatusCode_name(retval));
        return retval;
    }

    UA_Boolean retain = UA_TRUE;
    UA_Server_writeObjectProperty_scalar(server, conditionInstance_2,
                                         UA_QUALIFIEDNAME(0, "Retain"),
                                         &retain, &UA_TYPES[UA_TYPES_BOOLEAN]);

    UA_Variant value;
    UA_Boolean enabledStateId = true;
    UA_QualifiedName enabledStateField = UA_QUALIFIEDNAME(0,"EnabledState");
    UA_QualifiedName enabledStateIdField = UA_QUALIFIEDNAME(0,"Id");
    UA_Variant_setScalar(&value, &enabledStateId, &UA_TYPES[UA_TYPES_BOOLEAN]);
    retval = UA_Server_setConditionVariableFieldProperty(server, conditionInstance_2,
                                                         &value, enabledStateField,
                                                         enabledStateIdField);

    if(retval != UA_STATUSCODE_GOOD) {
        UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND,
                     "Setting EnabledState/Id Field failed. StatusCode %s",
                     UA_StatusCode_name(retval));
        return retval;
    }


    /* Add 3 variables to trigger condition events */
    addVariable_1_triggerAlarmOfCondition_1(server, &variable_1);

    callback.onWrite = afterWriteCallbackVariable_1;
    retval = UA_Server_setVariableNode_valueCallback(server, variable_1, callback);
    if(retval != UA_STATUSCODE_GOOD) {
        UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND,
                     "Setting variable 1 Callback failed. StatusCode %s",
                     UA_StatusCode_name(retval));
        return retval;
    }

    /* Severity can change internally also when the condition disabled and
     * retain is false. However, in this case no events will be generated. */
    addVariable_2_changeSeverityOfCondition_2(server, &variable_2);

    callback.onWrite = afterWriteCallbackVariable_2;
    retval = UA_Server_setVariableNode_valueCallback(server, variable_2, callback);
    if(retval != UA_STATUSCODE_GOOD) {
        UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND,
                     "Setting variable 2 Callback failed. StatusCode %s",
                     UA_StatusCode_name(retval));
        return retval;
    }

    addVariable_3_returnCondition_1_toNormalState(server, &variable_3);

    callback.onWrite = afterWriteCallbackVariable_3;
    retval = UA_Server_setVariableNode_valueCallback(server, variable_3, callback);
    if(retval != UA_STATUSCODE_GOOD) {
        UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND,
                     "Setting variable 3 Callback failed. StatusCode %s",
                     UA_StatusCode_name(retval));
    }
#endif
    return retval;
}

/**
 * It follows the main server code, making use of the above definitions. */

static UA_Boolean running = true;
static void stopHandler(int sig) {
    running = false;
}

int main (void) {
    /* default server values */
    signal(SIGINT, stopHandler);
    signal(SIGTERM, stopHandler);

    UA_Server *server = UA_Server_new();
    UA_ServerConfig_setDefault(UA_Server_getConfig(server));

    UA_StatusCode retval = setUpEnvironment(server);

    //if(retval == UA_STATUSCODE_GOOD)
        retval = UA_Server_run(server, &running);

    UA_Server_delete(server);

	system("pause");
    return retval == UA_STATUSCODE_GOOD ? EXIT_SUCCESS : EXIT_FAILURE;
}

这里共添加了两个条件变量conditionInstance_1和conditionInstance_2，中conditionInstance_1是以显示的方式展现出来，conditionInstance_2以隐示方式进行添加的。主要区别就是在createCondition时没有设置条件源对象以及引用。三个变量variable_1、variable_2和variable_3都绑定了对应的写回调函数，目的是为了通过改变条件变量的字段从而产生报警事件。条件变量相关字段信息在open62541.c中有对应的定义，如下

/* Condition Field Names */
#define CONDITION_FIELD_EVENTID                                "EventId"
#define CONDITION_FIELD_EVENTTYPE                              "EventType"
#define CONDITION_FIELD_SOURCENODE                             "SourceNode"
#define CONDITION_FIELD_SOURCENAME                             "SourceName"
#define CONDITION_FIELD_TIME                                   "Time"
#define CONDITION_FIELD_RECEIVETIME                            "ReceiveTime"
#define CONDITION_FIELD_MESSAGE                                "Message"
#define CONDITION_FIELD_SEVERITY                               "Severity"
#define CONDITION_FIELD_CONDITIONNAME                          "ConditionName"
#define CONDITION_FIELD_BRANCHID                               "BranchId"
#define CONDITION_FIELD_RETAIN                                 "Retain"
#define CONDITION_FIELD_ENABLEDSTATE                           "EnabledState"
#define CONDITION_FIELD_TWOSTATEVARIABLE_ID                    "Id"
#define CONDITION_FIELD_QUALITY                                "Quality"
#define CONDITION_FIELD_LASTSEVERITY                           "LastSeverity"
#define CONDITION_FIELD_COMMENT                                "Comment"
#define CONDITION_FIELD_CLIENTUSERID                           "ClientUserId"
#define CONDITION_FIELD_CONDITIONVARIABLE_SOURCETIMESTAMP      "SourceTimestamp"
#define CONDITION_FIELD_DISABLE                                "Disable"
#define CONDITION_FIELD_ENABLE                                 "Enable"
#define CONDITION_FIELD_ADDCOMMENT                             "AddComment"
#define CONDITION_FIELD_CONDITIONREFRESH                       "ConditionRefresh"
#define CONDITION_FIELD_ACKEDSTATE                             "AckedState"
#define CONDITION_FIELD_CONFIRMEDSTATE                         "ConfirmedState"
#define CONDITION_FIELD_ACKNOWLEDGE                            "Acknowledge"
#define CONDITION_FIELD_CONFIRM                                "Confirm"
#define CONDITION_FIELD_ACTIVESTATE                            "ActiveState"
#define CONDITION_FIELD_INPUTNODE                              "InputNode"
#define CONDITION_FIELD_SUPPRESSEDORSHELVED                    "SuppressedOrShelved"
#define CONDITION_FIELD_NORMALSTATE                            "NormalState"
#define CONDITION_FIELD_HIGHHIGHLIMIT                          "HighHighLimit"
#define CONDITION_FIELD_HIGHLIMIT                              "HighLimit"
#define CONDITION_FIELD_LOWLIMIT                               "LowLimit"
#define CONDITION_FIELD_LOWLOWLIMIT                            "LowLowLimit"
#define CONDITION_FIELD_PROPERTY_EFFECTIVEDISPLAYNAME          "EffectiveDisplayName"
#define CONDITION_FIELD_LIMITSTATE                             "LimitState"
#define CONDITION_FIELD_CURRENTSTATE                           "CurrentState"
#define CONDITION_FIELD_HIGHHIGHSTATE                          "HighHighState"
#define CONDITION_FIELD_HIGHSTATE                              "HighState"
#define CONDITION_FIELD_LOWSTATE                               "LowState"
#define CONDITION_FIELD_LOWLOWSTATE                            "LowLowState"
#define CONDITION_FIELD_DIALOGSTATE                            "DialogState"
#define CONDITION_FIELD_PROMPT                                 "Prompt"
#define CONDITION_FIELD_RESPONSEOPTIONSET                      "ResponseOptionSet"
#define CONDITION_FIELD_DEFAULTRESPONSE                        "DefaultResponse"
#define CONDITION_FIELD_LASTRESPONSE                           "LastResponse"
#define CONDITION_FIELD_OKRESPONSE                             "OkResponse"
#define CONDITION_FIELD_CANCELRESPONSE                         "CancelResponse"
#define CONDITION_FIELD_RESPOND                                "Respond"

使用Uaexpert连接server后，Root目录如下
在这里插入图片描述
其中Condition1可见，Condition2不可见。由于condition2在初始化的时候就设置了EnabledState/Id字段为true表示为启动这个条件变量，在没有对这个报警做处理的情况下，每次连接我们都能获取到这个报警信息，
在这里插入图片描述
通过右键我们可以对这个报警进行确认（Ack）和提交信息（Commit）
在这里插入图片描述
在确认和提交后我们可以看到对应的报警事件其字段已改变
在这里插入图片描述
除此之外，我们还可以通过调用method的方式，
在这里插入图片描述
每次修改后eventId都会进行变化，我们要找到其对应的id，在确认和提交后就表示这个警报已经被处理了。

接收Alarm

client端接收Alarm的方式与接收普通事件的方式一致，在筛选字段那部分做做处理即可，代码如下

/* 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/client.h>
//#include <open62541/client_config_default.h>
//#include <open62541/client_highlevel.h>
//#include <open62541/client_subscriptions.h>
//#include <open62541/plugin/log_stdout.h>
//#include <open62541/server.h>
//#include <open62541/server_config_default.h>
//#include <open62541/util.h>

#include "open62541.h"

#include <signal.h>

#ifdef _MSC_VER
#pragma warning(disable:4996) // warning C4996: 'UA_Client_Subscriptions_addMonitoredEvent': was declared deprecated
#endif

#ifdef __clang__
#pragma clang diagnostic ignored "-Wdeprecated-declarations"
#endif

#ifdef __GNUC__
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif

static UA_Boolean running = true;
static void stopHandler(int sig) {
	UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND, "received ctrl-c");
	running = false;
}

#ifdef UA_ENABLE_SUBSCRIPTIONS

static void
handler_events(UA_Client *client, UA_UInt32 subId, void *subContext,
UA_UInt32 monId, void *monContext,
size_t nEventFields, UA_Variant *eventFields) {
	UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND, "Notification");

	/* The context should point to the monId on the stack */
	UA_assert(*(UA_UInt32*)monContext == monId);

	for (size_t i = 0; i < nEventFields; ++i) {
		UA_Variant *variant = &eventFields[i];
		if (UA_Variant_hasScalarType(&eventFields[i], &UA_TYPES[UA_TYPES_UINT16])) {
			UA_UInt16 severity = *(UA_UInt16 *)eventFields[i].data;
			UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND, "Severity: %u", severity);
		}
		else if (UA_Variant_hasScalarType(&eventFields[i], &UA_TYPES[UA_TYPES_LOCALIZEDTEXT])) {
			UA_LocalizedText *lt = (UA_LocalizedText *)eventFields[i].data;
			UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND,
				"Message: '%.*s'", (int)lt->text.length, lt->text.data);
		}
		else if (UA_Variant_hasScalarType(&eventFields[i], &UA_TYPES[UA_TYPES_STRING])) {
			UA_String *lt = (UA_LocalizedText *)eventFields[i].data;
			UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND,
				"SourceName: '%.*s'", (int)lt->length, lt->data);
		}
		else if (UA_Variant_hasScalarType(&eventFields[i], &UA_TYPES[UA_TYPES_DATETIME])) {
			UA_DateTime *lt = (UA_DateTime *)eventFields[i].data;
			UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND,
				"Time: '%u'", *lt);
		}
		else if (UA_Variant_hasScalarType(&eventFields[i], &UA_TYPES[UA_TYPES_NODEID]))
		{
			UA_NodeId *lt = (UA_NodeId *)eventFields[i].data;
			UA_String str;
			UA_NodeId_print(lt, &str);
			UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND,
				"Node: '%.*s'", (int)str.length, str.data);
		}
		else {
#ifdef UA_ENABLE_TYPEDESCRIPTION
			UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND,
				"Don't know how to handle type: '%s'", eventFields[i].type->typeName);
#else
			UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND,
				"Don't know how to handle type, enable UA_ENABLE_TYPEDESCRIPTION "
				"for typename");
#endif
		}
	}
}

const size_t nSelectClauses = 4;

static UA_SimpleAttributeOperand *
setupSelectClauses(void) {
	UA_SimpleAttributeOperand *selectClauses = (UA_SimpleAttributeOperand*)
		UA_Array_new(nSelectClauses, &UA_TYPES[UA_TYPES_SIMPLEATTRIBUTEOPERAND]);
	if (!selectClauses)
		return NULL;
	
	for (size_t i = 0; i<nSelectClauses; ++i) {
		UA_SimpleAttributeOperand_init(&selectClauses[i]);
	}

	selectClauses[0].typeDefinitionId = UA_NODEID_NUMERIC(0, UA_NS0ID_BASEEVENTTYPE);
	selectClauses[0].browsePathSize = 1;
	selectClauses[0].browsePath = (UA_QualifiedName*)
		UA_Array_new(selectClauses[0].browsePathSize, &UA_TYPES[UA_TYPES_QUALIFIEDNAME]);
	if (!selectClauses[0].browsePath) {
		UA_SimpleAttributeOperand_delete(selectClauses);
		return NULL;
	}
	selectClauses[0].attributeId = UA_ATTRIBUTEID_VALUE;
	selectClauses[0].browsePath[0] = UA_QUALIFIEDNAME_ALLOC(0, "Message");

	selectClauses[1].typeDefinitionId = UA_NODEID_NUMERIC(0, UA_NS0ID_BASEEVENTTYPE);
	selectClauses[1].browsePathSize = 1;
	selectClauses[1].browsePath = (UA_QualifiedName*)
		UA_Array_new(selectClauses[1].browsePathSize, &UA_TYPES[UA_TYPES_QUALIFIEDNAME]);
	if (!selectClauses[1].browsePath) {
		UA_SimpleAttributeOperand_delete(selectClauses);
		return NULL;
	}
	selectClauses[1].attributeId = UA_ATTRIBUTEID_VALUE;
	selectClauses[1].browsePath[0] = UA_QUALIFIEDNAME_ALLOC(0, "Severity");

	selectClauses[2].typeDefinitionId = UA_NODEID_NUMERIC(0, UA_NS0ID_BASEEVENTTYPE);
	selectClauses[2].browsePathSize = 1;
	selectClauses[2].browsePath = (UA_QualifiedName*)
		UA_Array_new(selectClauses[2].browsePathSize, &UA_TYPES[UA_TYPES_QUALIFIEDNAME]);
	if (!selectClauses[2].browsePath) {
		UA_SimpleAttributeOperand_delete(selectClauses);
		return NULL;
	}
	selectClauses[2].attributeId = UA_ATTRIBUTEID_VALUE;
	selectClauses[2].browsePath[0] = UA_QUALIFIEDNAME_ALLOC(0, "SourceName");

	selectClauses[3].typeDefinitionId = UA_NODEID_NUMERIC(0, UA_NS0ID_BASEEVENTTYPE);
	selectClauses[3].browsePathSize = 1;
	selectClauses[3].browsePath = (UA_QualifiedName*)
		UA_Array_new(selectClauses[3].browsePathSize, &UA_TYPES[UA_TYPES_QUALIFIEDNAME]);
	if (!selectClauses[3].browsePath) {
		UA_SimpleAttributeOperand_delete(selectClauses);
		return NULL;
	}
	selectClauses[3].attributeId = UA_ATTRIBUTEID_VALUE;
	selectClauses[3].browsePath[0] = UA_QUALIFIEDNAME_ALLOC(0, "EventType");


	return selectClauses;
}

#endif

int main(int argc, char *argv[]) {
	signal(SIGINT, stopHandler);
	signal(SIGTERM, stopHandler);


	UA_Client *client = UA_Client_new();
	UA_ClientConfig_setDefault(UA_Client_getConfig(client));

	/* opc.tcp://uademo.prosysopc.com:53530/OPCUA/SimulationServer */
	/* opc.tcp://opcua.demo-this.com:51210/UA/SampleServer */
	UA_StatusCode retval = UA_Client_connect(client, "opc.tcp://127.0.0.1:4840");
	if (retval != UA_STATUSCODE_GOOD) {
		UA_Client_delete(client);
		return EXIT_FAILURE;
	}

#ifdef UA_ENABLE_SUBSCRIPTIONS
	/* Create a subscription */
	UA_CreateSubscriptionRequest request = UA_CreateSubscriptionRequest_default();
	UA_CreateSubscriptionResponse response = UA_Client_Subscriptions_create(client, request,
		NULL, NULL, NULL);
	if (response.responseHeader.serviceResult != UA_STATUSCODE_GOOD) {
		UA_Client_disconnect(client);
		UA_Client_delete(client);
		return EXIT_FAILURE;
	}
	UA_UInt32 subId = response.subscriptionId;
	UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND, "Create subscription succeeded, id %u", subId);

	/* Add a MonitoredItem */
	UA_MonitoredItemCreateRequest item;
	UA_MonitoredItemCreateRequest_init(&item);
	item.itemToMonitor.nodeId = UA_NODEID_NUMERIC(0, 2253); // Root->Objects->Server
	item.itemToMonitor.attributeId = UA_ATTRIBUTEID_EVENTNOTIFIER;
	item.monitoringMode = UA_MONITORINGMODE_REPORTING;

	UA_EventFilter filter;
	UA_EventFilter_init(&filter);
	filter.selectClauses = setupSelectClauses();
	filter.selectClausesSize = nSelectClauses;

	item.requestedParameters.filter.encoding = UA_EXTENSIONOBJECT_DECODED;
	item.requestedParameters.filter.content.decoded.data = &filter;
	item.requestedParameters.filter.content.decoded.type = &UA_TYPES[UA_TYPES_EVENTFILTER];

	UA_UInt32 monId = 0;

	UA_MonitoredItemCreateResult result =
		UA_Client_MonitoredItems_createEvent(client, subId,
		UA_TIMESTAMPSTORETURN_BOTH, item,
		&monId, handler_events, NULL);

	if (result.statusCode != UA_STATUSCODE_GOOD) {
		UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND,
			"Could not add the MonitoredItem with %s", UA_StatusCode_name(retval));
		goto cleanup;
	}
	else {
		UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND,
			"Monitoring 'Root->Objects->Server', id %u", response.subscriptionId);
	}

	monId = result.monitoredItemId;

	UA_Variant input;
	UA_Int32 value = subId;
	UA_Variant_init(&input);
	UA_Variant_setScalarCopy(&input, &value, &UA_TYPES[UA_TYPES_INTEGERID]);
	UA_StatusCode lret = 0;
	lret = UA_Client_call(client, UA_NODEID_NUMERIC(0, 2782),
		UA_NODEID_NUMERIC(0, 3875), 1, &input, NULL, NULL);
	if (lret != 0)
	{
		printf("call failed, %s\n", UA_StatusCode_name(lret));
	}

	while (running)
		retval = UA_Client_run_iterate(client, 100);

	/* Delete the subscription */
cleanup:
	UA_MonitoredItemCreateResult_clear(&result);
	UA_Client_Subscriptions_deleteSingle(client, response.subscriptionId);
	UA_Array_delete(filter.selectClauses, nSelectClauses, &UA_TYPES[UA_TYPES_SIMPLEATTRIBUTEOPERAND]);
#endif

	UA_Client_disconnect(client);
	UA_Client_delete(client);
	return retval == UA_STATUSCODE_GOOD ? EXIT_SUCCESS : EXIT_FAILURE;
}

这里多添加了一个EventType字段，其他的字段也可以进行添加，以便于区分是Alarm还是普通事件。

字段名称以及数据类型可通过文档或者使用Uaexpert连接后去进行查看，每个字段类型需要一一进行对应。

UA_Variant input;
	UA_Int32 value = subId;
	UA_Variant_init(&input);
	UA_Variant_setScalarCopy(&input, &value, &UA_TYPES[UA_TYPES_INTEGERID]);
	UA_StatusCode lret = 0;
	lret = UA_Client_call(client, UA_NODEID_NUMERIC(0, UA_NS0ID_CONDITIONTYPE),
		UA_NODEID_NUMERIC(0, UA_NS0ID_CONDITIONTYPE_CONDITIONREFRESH), 1, &input, NULL, NULL);
	if (lret != UA_STATUSCODE_GOOD)
	{
		printf("call failed, %s\n", UA_StatusCode_name(lret));
	}

注意这部分代码是用来刷新alarm的，在连接server端发现原先存在的Alarm我们并不知晓，通过refresh一下能够获取原触发的Alarm以及状态。
在这里插入图片描述
Uaexpert的刷新按钮便是这个含义。运行client端结果如下，
在这里插入图片描述
可以看到与Uaexpert中结果是一致的。

结尾

Alarm&Condition部分感觉其功能有点强大，内容还是比较多的，需要结合文档以及例程进行查看。

复杂的世界311
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
open62541.rar
02-02
vs2015编译的OPC UA open62541.lib、open62541.dll。配套含open62541.h 、WS2_32.Lib，可直接引用。
Open62541 Linux静态库
08-24
Linux 下编译的OPC UA Open62541 静态库文件，包括server Client
【OpcUA开发笔记 1】open62541在Win10下编译及Qt开发
jam12315的专栏
02-08 1113
为了统一公司的驱动层开发，准备采用OpcUA的方式转发底层数据，而服务器有Windows Server，也有CentOS，因此想用Qt开发一个基于MinGW的OpcUA Server，这样就能跨平台部署。这里记录一下，希望对你也有用。
OPC UA开源库Open62541源码编译及Client客户端Server服务器端测试[一]
lzc881012的博客
01-19 2223
pen62541 是一款开源的嵌入式系统开发手册，旨在帮助开发者快速掌握 Open62541 的开发技能。本文将从 Open62541 的概述、功能、开发环境、编程接口和应用案例五个方面进行介绍。
open62541中文文档
热门推荐
mikasoi的博客
12-04 4万+
  介绍 open62541（http://open62541.org）是一个开源的免费实现OPC UA（OPC统一架构），用C99和C ++ 98语言的通用子集编写。该库可与所有主要编译器一起使用，并提供实现专用OPC UA客户端和服务器的必要工具，或将基于OPC UA的通信集成到现有应用程序中。open62541库与平台无关。所有特定于平台的功能都是通过可交换的插件实现的。为主要操作系统提...
Open62541 为硬件设备（PLC）构建OPC UA模型
姚家湾博客
06-26 2424
open62541直接导入NodeSet文件，不再需要uaCompiler。这对设计通用的OPC UA Server 更方便灵活。
学习open62541 --- [13] 历史数据
爱就是是恒久忍耐的专栏
01-12 4425
当我们使用OPC UA时，有时想观察一个变量的变化情况，就需要记录其历史数据，最后呈现出一个随时间变化的趋势图，下面就讲述如何在open62541里历史数据功能。 一 配置open62541 在open62541源码目录下的CMakeLists.txt里找到下面2个option，把默认值改为ON， UA_ENABLE_AMALGAMATION UA_ENABLE_HISTORIZING 第2...
open62541学习(1)-windows
qq_54227351的博客
03-07 1058
open62541 是 OPC UA的一种实现方式（开源库），OPC UA 可用于PLC通信，可用于 PLC 跟 PC 之间进行通信。
OPC UA - Open62541学习
liwen9016的博客
08-23 1万+
前言 这几天看了看Open62541，这是用C语言遵循C99标准实现的一个开源跨平台OPC UA库。学习过程中发现好多不明白的运行结果，可能是自己没搞太明白，也可能是源码有些潜在bug，希望大神看到指导下小弟。这里简单记录下自己的学习过程和测试结果，算是个小笔记？ 一：编译 按着文档编译下 Linux： sudo apt-get install git build-essential g...
open62541-win32.zip_mainory_opc_open62541_open62541 加密_open62541
07-15
Open62541是OPC基金会的开源动态库，免去了需要企业邮箱才能注册下载的麻烦。
Open62541中文文档-第一篇-1.1.2.docx
03-09
open62541 （R 1.1.2）中文文档第一篇 ，open ua开发提供便利
使用pybind11导出open62541接口
05-17
使用pybind11导出open62541接口
open62541简单的封装类
10-13
将常用的open62541的功能进行简单的封装。可以将其进行简单的改造之后用于MFC中。仅供参考使用。
学习open62541 --- [74] 软链接的妙用
爱就是是恒久忍耐的专栏
02-12 865
使用软链接操作open62541
Open62541 NodeSet loader 编译与使用
姚家湾博客
06-27 916
比如uaModeler，Opc foundation 的UA ModelCompiler 以及Open62541 提供的nodeset_Compiler 都是如此，这种方式在载入配套规范的Nodeset 无疑是比较方便的，但是对于用户自定义的信息模型，需要灵活地加载。另一个问题是cmake 时。但是值得注意的是 node-loader 的编译过程中，需要引用Open62541 package ,如何实现他们的联系，十分重要。显然，open62541 ，nodeset_loader 都是以静态库使用的。
open62541 事件
m0_47722349的博客
06-18 1515
监控项目能够监测到数据的变化，但是有时候并不能传递足够的信息，使用事件可以带有信息以及其可以在任何时候进行触发，同时其属性可以被客户端进行过滤，只接收自己感兴趣的特定属性。本文将描述server端事件的触发以及client端事件的过滤及接收。在使用之前我们需要编译open62541，我们使用CMake勾选对应的选项进行编译即可得到对应的.h和.c文件，勾选选项如下 重新编译后即可得到对应.h和.c文件。这里以例程tutorial_server_events.c为例，描述server端去触发事件，代码如下
学习open62541 --- [38] 避坑指南
爱就是是恒久忍耐的专栏
11-18 5445
如何正确使用open62541
open62541自定义数据类型
m0_47722349的博客
04-26 672
概述
c，c++，go语言字符串的演进
最新发布
lnwaycool的专栏
06-11 897
而字符串天生就有长度的要求，于是增加了一个字符串结束符，来判断该char数组是否字符串，以及判断长度，结束符之后的内容就被忽略了。golang中的字符串去掉了有争议的'\0'(代码中出现会编译错误)，字符串可以表示为[]byte和string，存储上，这两者没多大区别。string中增加了截取，查找等常规操作，string中的字符无法直接修改，每次变动都会引起重新内存分配，方便，但效率较低。C++增加了类的支持，这样可以把长度作为类的成员变量而存在，.zise()反应了数组的真实长度。
open62541 客户端
09-17
open62541是一个开源的OPC-UA协议的实现，是一个C开发库，用于构建OPC-UA客户端和服务器应用程序。它提供了一个灵活且易于使用的API，使得开发者可以方便地创建自己的OPC-UA客户端。 open62541提供了一系列的函数和数据结构，可以帮助开发者与OPC-UA服务器进行连接、创建会话、浏览服务端的对象、读写节点的值、监听事件等操作。开发者可以根据自己的需求选择调用相应的函数，进行相应的操作。 open62541还支持安全性，包括对服务器的认证和加密传输。开发者可以使用open62541提供的功能来配置安全策略，确保与服务器的通信是安全可靠的。 通过open62541，开发者可以快速构建自己的OPC-UA客户端应用程序。无论是在工业自动化、物联网等领域，使用open62541都可以轻松地与OPC-UA服务器进行通信，实现数据传输和控制操作。同时，由于open62541是一个开源项目，开发者还可以自由地修改和定制代码，以满足自己的特定需求。 总之，open62541是一个强大而灵活的OPC-UA客户端实现，为开发者提供了方便、快速构建自己的客户端应用程序的能力。无论是对于初学者还是有经验的开发者来说，open62541都是一个值得推荐的工具。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

复杂的世界311

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

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

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

打赏作者

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

抵扣说明：

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

余额充值