mirror of
https://github.com/open62541/open62541.git
synced 2026-10-18 13:42:32 +08:00
Klaus Schick
271 lines
11 KiB
C
271 lines
11 KiB
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/client_config_default.h>
|
|
#include <open62541/client_highlevel_async.h>
|
|
#include <open62541/client_subscriptions.h>
|
|
#include <open62541/plugin/log_stdout.h>
|
|
#include <open62541/server_config_default.h>
|
|
#include <open62541/client_subscriptions.h>
|
|
|
|
#include <stdlib.h>
|
|
#include <signal.h>
|
|
|
|
UA_Boolean running = true;
|
|
static void InitCallMulti(UA_Client* client);
|
|
|
|
#ifdef UA_ENABLE_METHODCALLS
|
|
|
|
static void
|
|
methodCalled(UA_Client *client, void *userdata, UA_UInt32 requestId,
|
|
UA_CallResponse *response) {
|
|
UA_UInt32 i;
|
|
UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND, "**** CallRequest Response - Req:%u with %u results",
|
|
requestId, (UA_UInt32)response->resultsSize);
|
|
UA_StatusCode retval = response->responseHeader.serviceResult;
|
|
if (retval == UA_STATUSCODE_GOOD) {
|
|
for (i = 0; i < response->resultsSize; i++) {
|
|
if (response->resultsSize >= i)
|
|
retval = response->results[i].statusCode;
|
|
else
|
|
retval = UA_STATUSCODE_BADUNEXPECTEDERROR;
|
|
if (retval != UA_STATUSCODE_GOOD) {
|
|
UA_CallResponse_clear(response);
|
|
UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND, "**** CallRequest Response - Req: %u (%u) failed", requestId,i);
|
|
if (i == response->resultsSize)
|
|
return;
|
|
else
|
|
continue;
|
|
}
|
|
|
|
/* Move the output arguments */
|
|
UA_Variant *output = response->results[i].outputArguments;
|
|
size_t outputSize = response->results[i].outputArgumentsSize;
|
|
response->results[i].outputArguments = NULL;
|
|
response->results[i].outputArgumentsSize = 0;
|
|
|
|
if (retval == UA_STATUSCODE_GOOD) {
|
|
printf("---Method call was successful, returned %lu values.\n",
|
|
(unsigned long)outputSize);
|
|
UA_Array_delete(output, outputSize, &UA_TYPES[UA_TYPES_VARIANT]);
|
|
}
|
|
else {
|
|
printf("---Method call was unsuccessful, returned %x values.\n",
|
|
retval);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND, "**** CallRequest Response - Req:%u FAILED", requestId);
|
|
}
|
|
UA_CallResponse_clear(response);
|
|
|
|
/* We initiate the MultiCall (2 methods within one CallRequest) */
|
|
InitCallMulti(client);
|
|
}
|
|
|
|
#ifdef UA_ENABLE_METHODCALLS
|
|
/* Workaround because we do not have an API for that yet */
|
|
|
|
static UA_StatusCode
|
|
UA_Client_call_asyncMulti(UA_Client *client,
|
|
const UA_NodeId objectId1, const UA_NodeId methodId1, size_t inputSize1, const UA_Variant *input1,
|
|
const UA_NodeId objectId2, const UA_NodeId methodId2, size_t inputSize2, const UA_Variant *input2,
|
|
UA_ClientAsyncServiceCallback callback, void *userdata, UA_UInt32 *reqId) {
|
|
UA_CallRequest request;
|
|
UA_CallRequest_init(&request);
|
|
UA_CallMethodRequest item[2];
|
|
UA_CallMethodRequest_init(&item[0]);
|
|
item[0].methodId = methodId1;
|
|
item[0].objectId = objectId1;
|
|
item[0].inputArguments = (UA_Variant *)(void*)(uintptr_t)input1; // cast const...
|
|
item[0].inputArgumentsSize = inputSize1;
|
|
|
|
UA_CallMethodRequest_init(&item[1]);
|
|
item[1].methodId = methodId2;
|
|
item[1].objectId = objectId2;
|
|
item[1].inputArguments = (UA_Variant *)(void*)(uintptr_t)input2; // cast const...
|
|
item[1].inputArgumentsSize = inputSize2;
|
|
|
|
request.methodsToCall = &item[0];
|
|
request.methodsToCallSize = 2;
|
|
|
|
return __UA_Client_AsyncService(client, &request,
|
|
&UA_TYPES[UA_TYPES_CALLREQUEST], callback,
|
|
&UA_TYPES[UA_TYPES_CALLRESPONSE], userdata, reqId);
|
|
}
|
|
/* End Workaround */
|
|
|
|
static void InitCallMulti(UA_Client* client) {
|
|
UA_UInt32 reqId = 0;
|
|
UA_Variant input;
|
|
UA_Variant_init(&input);
|
|
UA_String stringValue = UA_String_fromChars("World 3 (multi)");
|
|
UA_Variant_setScalar(&input, &stringValue, &UA_TYPES[UA_TYPES_STRING]);
|
|
|
|
UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND, "**** Initiating CallRequest 3");
|
|
UA_Client_call_asyncMulti(client,
|
|
UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER),
|
|
UA_NODEID_NUMERIC(1, 62542), 1, &input,
|
|
UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER),
|
|
UA_NODEID_NUMERIC(1, 62541), 1, &input,
|
|
(UA_ClientAsyncServiceCallback)methodCalled, NULL, &reqId);
|
|
UA_String_clear(&stringValue);
|
|
}
|
|
#endif
|
|
#endif /* UA_ENABLE_METHODCALLS */
|
|
|
|
static void stopHandler(int sign) {
|
|
UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND, "Received Ctrl-C");
|
|
running = 0;
|
|
}
|
|
|
|
static void
|
|
handler_currentTimeChanged(UA_Client *client, UA_UInt32 subId, void *subContext,
|
|
UA_UInt32 monId, void *monContext, UA_DataValue *value) {
|
|
//UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND, "currentTime has changed!");
|
|
if (UA_Variant_hasScalarType(&value->value, &UA_TYPES[UA_TYPES_DATETIME])) {
|
|
UA_DateTime raw_date = *(UA_DateTime *)value->value.data;
|
|
UA_DateTimeStruct dts = UA_DateTime_toStruct(raw_date);
|
|
UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND,
|
|
"date is: %02u-%02u-%04u %02u:%02u:%02u.%03u",
|
|
dts.day, dts.month, dts.year, dts.hour, dts.min, dts.sec, dts.milliSec);
|
|
}
|
|
}
|
|
|
|
static void
|
|
deleteSubscriptionCallback(UA_Client *client, UA_UInt32 subscriptionId, void *subscriptionContext) {
|
|
UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND,
|
|
"Subscription Id %u was deleted", subscriptionId);
|
|
}
|
|
|
|
static void
|
|
subscriptionInactivityCallback(UA_Client *client, UA_UInt32 subId, void *subContext) {
|
|
UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND, "Inactivity for subscription %u", subId);
|
|
}
|
|
|
|
static void
|
|
stateCallback(UA_Client *client, UA_ClientState clientState) {
|
|
switch (clientState) {
|
|
case UA_CLIENTSTATE_DISCONNECTED:
|
|
UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND, "The client is disconnected");
|
|
break;
|
|
case UA_CLIENTSTATE_WAITING_FOR_ACK:
|
|
UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND, "Waiting for ack");
|
|
break;
|
|
case UA_CLIENTSTATE_CONNECTED:
|
|
UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND,
|
|
"A TCP connection to the server is open");
|
|
break;
|
|
case UA_CLIENTSTATE_SECURECHANNEL:
|
|
UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND,
|
|
"A SecureChannel to the server is open");
|
|
break;
|
|
case UA_CLIENTSTATE_SESSION: {
|
|
UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND, "A session with the server is open");
|
|
/* A new session was created. We need to create the subscription. */
|
|
/* Create a subscription */
|
|
UA_CreateSubscriptionRequest request = UA_CreateSubscriptionRequest_default();
|
|
UA_CreateSubscriptionResponse response = UA_Client_Subscriptions_create(client, request,
|
|
NULL, NULL, deleteSubscriptionCallback);
|
|
|
|
if (response.responseHeader.serviceResult == UA_STATUSCODE_GOOD)
|
|
UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND,
|
|
"Create subscription succeeded, id %u", response.subscriptionId);
|
|
else
|
|
return;
|
|
|
|
/* Add a MonitoredItem */
|
|
UA_MonitoredItemCreateRequest monRequest =
|
|
UA_MonitoredItemCreateRequest_default(UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_SERVERSTATUS_CURRENTTIME));
|
|
|
|
UA_MonitoredItemCreateResult monResponse =
|
|
UA_Client_MonitoredItems_createDataChange(client, response.subscriptionId,
|
|
UA_TIMESTAMPSTORETURN_BOTH,
|
|
monRequest, NULL, handler_currentTimeChanged, NULL);
|
|
if (monResponse.statusCode == UA_STATUSCODE_GOOD)
|
|
UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND,
|
|
"Monitoring UA_NS0ID_SERVER_SERVERSTATUS_CURRENTTIME', id %u",
|
|
monResponse.monitoredItemId);
|
|
|
|
//TODO: check the existance of the nodes inside these functions (otherwise seg faults)
|
|
#ifdef UA_ENABLE_METHODCALLS
|
|
UA_UInt32 reqId = 0;
|
|
UA_Variant input;
|
|
UA_Variant_init(&input);
|
|
UA_String stringValue = UA_String_fromChars("World 1");
|
|
UA_Variant_setScalar(&input, &stringValue, &UA_TYPES[UA_TYPES_STRING]);
|
|
|
|
/* Initiate Call 1 */
|
|
UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND, "**** Initiating CallRequest 1");
|
|
UA_Client_call_async(client,
|
|
UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER),
|
|
UA_NODEID_NUMERIC(1, 62541), 1, &input,
|
|
methodCalled, NULL, &reqId);
|
|
UA_String_clear(&stringValue);
|
|
|
|
/* Initiate Call 2 */
|
|
UA_Variant_init(&input);
|
|
stringValue = UA_String_fromChars("World 2");
|
|
UA_Variant_setScalar(&input, &stringValue, &UA_TYPES[UA_TYPES_STRING]);
|
|
|
|
UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND, "**** Initiating CallRequest 2");
|
|
UA_Client_call_async(client,
|
|
UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER),
|
|
UA_NODEID_NUMERIC(1, 62542), 1, &input,
|
|
methodCalled, NULL, &reqId);
|
|
UA_String_clear(&stringValue);
|
|
|
|
#endif /* UA_ENABLE_METHODCALLS */
|
|
}
|
|
break;
|
|
case UA_CLIENTSTATE_SESSION_RENEWED:
|
|
UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND,
|
|
"A session with the server is open (renewed)");
|
|
/* The session was renewed. We don't need to recreate the subscription. */
|
|
break;
|
|
case UA_CLIENTSTATE_SESSION_DISCONNECTED:
|
|
UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND, "Session disconnected");
|
|
break;
|
|
}
|
|
return;
|
|
}
|
|
|
|
int
|
|
main(int argc, char *argv[]) {
|
|
signal(SIGINT, stopHandler); /* catches ctrl-c */
|
|
|
|
UA_Client *client = UA_Client_new();
|
|
UA_ClientConfig *cc = UA_Client_getConfig(client);
|
|
UA_ClientConfig_setDefault(cc);
|
|
/* we use a high timeout because there may be other client and
|
|
* processing may take long if many method calls are waiting */
|
|
cc->timeout = 60000;
|
|
|
|
/* Set stateCallback */
|
|
cc->stateCallback = stateCallback;
|
|
cc->subscriptionInactivityCallback = subscriptionInactivityCallback;
|
|
|
|
UA_StatusCode retval = UA_Client_connect(client, "opc.tcp://localhost:4840");
|
|
if(retval != UA_STATUSCODE_GOOD) {
|
|
UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND,
|
|
"Not connected. Retrying to connect in 1 second");
|
|
UA_Client_delete(client);
|
|
return EXIT_SUCCESS;
|
|
}
|
|
|
|
/* Endless loop runAsync */
|
|
while (running) {
|
|
UA_Client_run_iterate(client, 100);
|
|
}
|
|
|
|
/* Clean up */
|
|
/* Async disconnect kills unprocessed requests */
|
|
// UA_Client_disconnect_async (client, &reqId); //can only be used when connected = true
|
|
// UA_Client_run_iterate (client, &timedOut);
|
|
UA_Client_disconnect(client);
|
|
UA_Client_delete(client);
|
|
return EXIT_SUCCESS;
|
|
}
|