opcua 0.12 → 0.13

data/example/array/servertest.c

@@ -0,0 +1,142 @@
+/* This work is licensed under a Creative Commons CCZero 1.0 Universal License.
+ * See http://creativecommons.org/publicdomain/zero/1.0/ for more information. */
+
+/**
+ * Adding Variables to a Server
+ * ----------------------------
+ *
+ * This tutorial shows how to work with data types and how to add variable nodes
+ * to a server. First, we add a new variable to the server. Take a look at the
+ * definition of the ``UA_VariableAttributes`` structure to see the list of all
+ * attributes defined for VariableNodes.
+ *
+ * Note that the default settings have the AccessLevel of the variable value as
+ * read only. See below for making the variable writable.
+ */
+
+#include <open62541.h>
+
+#include <signal.h>
+#include <stdlib.h>
+
+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_NodeId myIntegerNodeId = UA_NODEID_STRING(1, "the.answer");
+    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, myIntegerNodeId, parentNodeId,
+                              parentReferenceNodeId, myIntegerName,
+                              UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE), attr, NULL, NULL);
+}
+
+static UA_NodeId pointTypeId;
+static void addVariableType2DPoint(UA_Server *server) {
+    UA_VariableAttributes vtAttr = UA_VariableAttributes_default;
+    vtAttr.dataType = UA_TYPES[UA_TYPES_DOUBLE].typeId;
+    vtAttr.valueRank = UA_VALUERANK_ONE_DIMENSION;
+    UA_UInt32 arrayDims[1] = {5};
+    vtAttr.arrayDimensions = arrayDims;
+    vtAttr.arrayDimensionsSize = 1;
+    vtAttr.displayName = UA_LOCALIZEDTEXT("en-US", "2DPoint Type");
+    vtAttr.accessLevel = UA_ACCESSLEVELMASK_READ | UA_ACCESSLEVELMASK_WRITE;
+    UA_NodeId myArrayNodeId = UA_NODEID_STRING(1, "MyArray");
+    /* a matching default value is required */
+    UA_Double zero[2] = {0.0, 0.0};
+    UA_Variant_setArray(&vtAttr.value, zero, 5, &UA_TYPES[UA_TYPES_DOUBLE]);
+
+    UA_Server_addVariableNode(server, myArrayNodeId,
+                                  UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER),
+                                  UA_NODEID_NUMERIC(0, UA_NS0ID_HASSUBTYPE),
+                                  UA_QUALIFIEDNAME(1, "2DPoint Type"), UA_NODEID_NULL,
+                                  vtAttr, NULL, &pointTypeId);
+}
+/**
+ * Now we change the value with the write service. This uses the same service
+ * implementation that can also be reached over the network by an OPC UA client.
+ */
+
+static void writeVariable(UA_Server *server) {
+    UA_NodeId myIntegerNodeId = UA_NODEID_STRING(1, "the.answer");
+
+    /* Write a different integer value */
+    UA_Int32 myInteger = 43;
+    UA_Variant myVar;
+    UA_Variant_init(&myVar);
+    UA_Variant_setScalar(&myVar, &myInteger, &UA_TYPES[UA_TYPES_INT32]);
+    UA_Server_writeValue(server, myIntegerNodeId, myVar);
+
+    /* Set the status code of the value to an error code. The function
+     * UA_Server_write provides access to the raw service. The above
+     * UA_Server_writeValue is syntactic sugar for writing a specific node
+     * attribute with the write service. */
+    UA_WriteValue wv;
+    UA_WriteValue_init(&wv);
+    wv.nodeId = myIntegerNodeId;
+    wv.attributeId = UA_ATTRIBUTEID_VALUE;
+    wv.value.status = UA_STATUSCODE_BADNOTCONNECTED;
+    wv.value.hasStatus = true;
+    UA_Server_write(server, &wv);
+
+    /* Reset the variable to a good statuscode with a value */
+    wv.value.hasStatus = false;
+    wv.value.value = myVar;
+    wv.value.hasValue = true;
+    UA_Server_write(server, &wv);
+}
+
+/**
+ * Note how we initially set the DataType attribute of the variable node to the
+ * NodeId of the Int32 data type. This forbids writing values that are not an
+ * Int32. The following code shows how this consistency check is performed for
+ * every write.
+ */
+
+static void
+writeWrongVariable(UA_Server *server) {
+    UA_NodeId myIntegerNodeId = UA_NODEID_STRING(1, "the.answer");
+
+    /* Write a string */
+    UA_String myString = UA_STRING("test");
+    UA_Variant myVar;
+    UA_Variant_init(&myVar);
+    UA_Variant_setScalar(&myVar, &myString, &UA_TYPES[UA_TYPES_STRING]);
+    UA_StatusCode retval = UA_Server_writeValue(server, myIntegerNodeId, myVar);
+    printf("Writing a string returned statuscode %s\n", UA_StatusCode_name(retval));
+}
+
+/** It follows the main server code, making use of the above definitions. */
+
+UA_Boolean running = true;
+static void stopHandler(int sign) {
+    UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, "received ctrl-c");
+    running = false;
+}
+
+int main(void) {
+    signal(SIGINT, stopHandler);
+    signal(SIGTERM, stopHandler);
+    UA_ServerConfig *config = UA_ServerConfig_new_default();
+    UA_Server *server = UA_Server_new(config);
+
+
+    addVariable(server);
+    writeVariable(server);
+    writeWrongVariable(server);
+    addVariableType2DPoint(server);
+
+    UA_StatusCode retval = UA_Server_run(server, &running);
+
+    UA_Server_delete(server);
+    return retval == UA_STATUSCODE_GOOD ? EXIT_SUCCESS : EXIT_FAILURE;
+}

data/example/bug5.rb

@@ -0,0 +1,22 @@
+#!/usr/bin/ruby
+require_relative '../lib/opcua/server'
+
+Daemonite.new do
+  server = OPCUA::Server.new
+  server.add_namespace "https://centurio.work/kelch"
+
+  mt = server.types.add_object_type(:MeasurementType).tap{ |t|
+    t.add_variable :SollWertX
+    t.add_variable :SollWertY
+    t.add_variable :SollWertZ
+  }
+  tt = server.types.add_object_type(:ToolType).tap{ |t|
+    t.add_object :M, mt, OPCUA::MANDATORY
+  }
+
+  tools = server.objects.instantiate(:KalimatC34, tt)
+
+  run do
+    sleep server.run
+  end
+end.loop!

data/example/client_method.rb

@@ -9,6 +9,10 @@ client = OPCUA::Client.new("opc.tcp://localhost:4840")
 client.debug = false
 client.default_ns = 2
 
-node = client.get '/KalimatC34/Tools/Tool3/testMethod'
-node.call 'abcde', Time.now
-client.disconnect
+# node = client.get '/KalimatC34/Tools/Tool3/testMethod'
+# p node.call 'abcde', Time.now
+# client.disconnect
+
+node = client.get 0, 11492
+p node
+p node.call 2

data/example/server.rb

@@ -48,12 +48,12 @@ Daemonite.new do
     opts[:tn].description = 'test test'
     opts[:tn].value = [0,1]
     p opts[:tn].description
+    p opts[:tn].to_s
+    p opts[:tn].name
 
     measurments_t1 = t1.find(:Measurements)
     measurments_t1.manifest(:M1,mt)
-    measurments_t1.manifest(:M2,mt)
-
-    p opts['server'].namespaces
+    m2 = measurments_t1.manifest(:M2,mt)
   rescue => e
     puts e.message
   end

data/ext/opcua/client/client.c

@@ -9,7 +9,7 @@ VALUE cVarNode = Qnil;
 VALUE cMethodNode = Qnil;
 VALUE cNode = Qnil;
 
-#include "../values.h"
+#include "values.h"
 
 #include <signal.h>
 
@@ -64,7 +64,14 @@ static VALUE node_value_set(VALUE self, VALUE value) { //{{{
   if (!ns->master->started) rb_raise(rb_eRuntimeError, "Client disconnected.");
 
   UA_Variant variant;
-  if (value_to_variant(value,&variant)) {
+  UA_NodeId pdt;
+  UA_Client_readDataTypeAttribute(ns->master->master, ns->id, &pdt);
+  UA_UInt32 proposal = -1;
+  if (pdt.namespaceIndex == 0) {
+    proposal = pdt.identifier.numeric - 1; // what a dirty hack TODO, translate node to value
+  }
+
+  if (value_to_variant(value,&variant,proposal)) {
     // printf("-----------------------------------------%ld\n",variant.arrayDimensionsSize);
     if (variant.arrayDimensionsSize > 0) {
        UA_Int32 ads = (UA_Int32) variant.arrayDimensionsSize;
@@ -96,7 +103,8 @@ static VALUE node_on_change(VALUE self) { //{{{
 
   return self;
 } //}}}
-static void node_on_value_change_handler(UA_Client *client, UA_UInt32 subId, void *subContext, UA_UInt32 monId, void *monContext, UA_DataValue *value) {
+
+static void node_on_value_change_handler(UA_Client *client, UA_UInt32 subId, void *subContext, UA_UInt32 monId, void *monContext, UA_DataValue *value) { // {{{
   VALUE ins = (VALUE)monContext;
   VALUE blk = RARRAY_AREF(ins,1);
 
@@ -120,8 +128,8 @@ static void node_on_value_change_handler(UA_Client *client, UA_UInt32 subId, voi
     rb_ary_store(args,2,rb_ary_entry(ret,1));
     rb_proc_call(blk,args);
   }
-}
-static VALUE node_on_value_change(VALUE self) {
+} // }}}
+static VALUE node_on_value_change(VALUE self) { // {{{
   node_struct *ns;
   Data_Get_Struct(self, node_struct, ns);
   if (!ns->master->started) rb_raise(rb_eRuntimeError, "Client disconnected.");
@@ -171,7 +179,7 @@ static VALUE node_on_value_change(VALUE self) {
   UA_CreateSubscriptionRequest_clear(&sreq);
 
   return self;
-}
+} // }}}
 
 /* -- */
 static void  client_free(client_struct *pss) { //{{{
@@ -486,24 +494,40 @@ static VALUE node_to_s(VALUE self) { //{{{
 
 static VALUE node_call(int argc, VALUE* argv, VALUE self) { //{{{
   node_struct *ns;
+  UA_StatusCode retval;
 
   VALUE splat;
   rb_scan_args(argc, argv, "*", &splat);
 
   Data_Get_Struct(self, node_struct, ns);
 
+  UA_NodeId parent;
+  client_node_get_reference_by_type(ns->master->master, ns->id, UA_NODEID_NUMERIC(0,UA_NS0ID_HASCOMPONENT), &parent, true);
+
+  UA_NodeId ia;
+  client_node_get_reference_by_name(ns->master->master, ns->id, UA_QUALIFIEDNAME(0,"InputArguments"), &ia, false);
+  UA_Variant iaval;
+  UA_Variant_init(&iaval);
+  UA_Client_readValueAttribute(ns->master->master, ia, &iaval);
+
+  UA_UInt32 proposal[RARRAY_LEN(splat)];
+  for (int i=0; i < iaval.arrayLength; i++) {
+    UA_ExtensionObject* eoarg= (UA_ExtensionObject *)(iaval.data);
+    UA_Argument* arg = (UA_Argument *)(eoarg[i].content.decoded.data);
+
+    if (arg->dataType.namespaceIndex == 0) {
+		  proposal[i] = arg->dataType.identifier.numeric - 1; // what a dirty hack TODO, translate node to value
+    }
+  }
+
   UA_Variant inputArguments[RARRAY_LEN(splat)];
   for (long i=0; i<RARRAY_LEN(splat); i++) {
-    value_to_variant(RARRAY_AREF(splat, i),&inputArguments[i]);
+    value_to_variant(RARRAY_AREF(splat, i),&inputArguments[i],proposal[i]);
   }
 
-  VALUE path = rb_str_new((const char *)ns->id.identifier.string.data,ns->id.identifier.string.length);
-  VALUE pat  = rb_str_new2("\\/[a-z0-9A-Z]+\\/?$");
-  VALUE obj  = rb_funcall(path,rb_intern("sub"),2,rb_reg_new_str(pat, 0),rb_str_new2(""));
-
-  UA_StatusCode retval = UA_Client_call(
+  retval = UA_Client_call(
     ns->master->master,
-    UA_NODEID_STRING(ns->id.namespaceIndex,StringValuePtr(obj)),
+    parent,
     ns->id,
     RARRAY_LEN(splat),
     (UA_Variant *)&inputArguments,
@@ -511,6 +535,7 @@ static VALUE node_call(int argc, VALUE* argv, VALUE self) { //{{{
     NULL
   );
 
+
   if(retval == UA_STATUSCODE_GOOD) {
     return Qtrue;
   } else {

data/ext/opcua/client/client.h

@@ -1,7 +1,8 @@
 #include <ruby.h>
 #include <stdio.h>
 #include <open62541.h>
-#include "../log_none.h"
+#include "log_none.h"
+#include "finders.h"
 
 typedef struct client_struct {
   UA_ClientConfig *config;

data/ext/opcua/client/finders.c

@@ -0,0 +1 @@
+../helpers/finders.c

data/ext/opcua/client/finders.h

@@ -0,0 +1 @@
+../helpers/finders.h

data/ext/opcua/client/log_none.c

@@ -0,0 +1 @@
+../helpers/log_none.c

data/ext/opcua/client/log_none.h

@@ -0,0 +1 @@
+../helpers/log_none.h

data/ext/opcua/client/strnautocat.c

@@ -0,0 +1 @@
+../helpers/strnautocat.c

data/ext/opcua/client/strnautocat.h

@@ -0,0 +1 @@
+../helpers/strnautocat.h

data/ext/opcua/client/values.c

@@ -0,0 +1 @@
+../helpers/values.c

data/ext/opcua/client/values.h

@@ -0,0 +1 @@
+../helpers/values.h

data/ext/opcua/helpers/finders.c

@@ -0,0 +1,142 @@
+#include "finders.h"
+
+UA_BrowsePathResult node_browse_path(UA_Server *server, UA_NodeId relative, UA_NodeId ref, UA_QualifiedName mqn, bool inverse) {
+  UA_RelativePathElement rpe;
+  UA_RelativePathElement_init(&rpe);
+  rpe.referenceTypeId = ref;
+  rpe.isInverse = inverse;
+  rpe.includeSubtypes = false;
+  rpe.targetName = mqn;
+
+  UA_BrowsePath bp;
+  UA_BrowsePath_init(&bp);
+  bp.startingNode = relative;
+  bp.relativePath.elementsSize = 1;
+  bp.relativePath.elements = &rpe;
+
+  return UA_Server_translateBrowsePathToNodeIds(server, &bp);
+}
+
+bool server_node_get_reference(UA_Server *server, UA_NodeId parent, UA_NodeId *result, bool inverse) {
+	UA_BrowseDescription bDes;
+  UA_BrowseDescription_init(&bDes);
+  bDes.nodeId = parent;
+  bDes.resultMask = UA_BROWSERESULTMASK_ALL;
+  bDes.browseDirection = inverse ? 1 : 0;
+  UA_BrowseResult bRes = UA_Server_browse(server, 2, &bDes);
+
+  if (bRes.referencesSize > 0) {
+    UA_ReferenceDescription *ref = &(bRes.references[0]);
+
+    UA_NodeId_copy(&ref->nodeId.nodeId,result);
+
+		// UA_QualifiedName qn;  UA_QualifiedName_init(&qn);
+		// UA_Server_readBrowseName(server, ref->nodeId.nodeId, &qn);
+		// printf("NS: %d ---> NodeId %u; %-16.*s\n",
+		// 			 ref->nodeId.nodeId.namespaceIndex,
+		// 			 ref->nodeId.nodeId.identifier.numeric,
+		// 			 (int)qn.name.length,
+		// 			 qn.name.data
+		// );
+
+    UA_BrowseResult_deleteMembers(&bRes);
+    UA_BrowseResult_clear(&bRes);
+    return true;
+  }
+  return false;
+}
+
+bool client_node_get_reference_by_name(UA_Client *client, UA_NodeId parent, UA_QualifiedName name, UA_NodeId *result, bool inverse) {
+  UA_BrowseRequest bReq;
+  UA_BrowseRequest_init(&bReq);
+  bReq.requestedMaxReferencesPerNode = 0;
+  bReq.nodesToBrowse = UA_BrowseDescription_new();
+  bReq.nodesToBrowseSize = 1;
+  bReq.nodesToBrowse[0].nodeId = parent;
+  bReq.nodesToBrowse[0].browseDirection = inverse ? 1 : 0;
+  bReq.nodesToBrowse[0].resultMask = UA_BROWSERESULTMASK_ALL;
+  UA_BrowseResponse bResp = UA_Client_Service_browse(client, bReq);
+
+  bool success = false;
+  for (int i=0; i < bResp.resultsSize && !success; i++) {
+    for (int j=0; j < bResp.results[i].referencesSize && !success; j++) {
+      UA_ReferenceDescription *ref = &(bResp.results[i].references[j]);
+
+      UA_QualifiedName qn;  UA_QualifiedName_init(&qn);
+      UA_Client_readBrowseNameAttribute(client, ref->nodeId.nodeId, &qn);
+
+      if (UA_QualifiedName_equal(&qn,&name)) {
+        UA_NodeId_copy(&ref->nodeId.nodeId,result);
+        success = true;
+      }
+    }
+  }
+
+  UA_BrowseResponse_deleteMembers(&bResp);
+  UA_BrowseResponse_clear(&bResp);
+  return success;
+}
+bool client_node_get_reference_by_type(UA_Client *client, UA_NodeId parent, UA_NodeId type, UA_NodeId *result, bool inverse) {
+  UA_BrowseRequest bReq;
+  UA_BrowseRequest_init(&bReq);
+  bReq.requestedMaxReferencesPerNode = 0;
+  bReq.nodesToBrowse = UA_BrowseDescription_new();
+  bReq.nodesToBrowseSize = 1;
+  bReq.nodesToBrowse[0].nodeId = parent;
+  bReq.nodesToBrowse[0].browseDirection = inverse ? 1 : 0;
+  bReq.nodesToBrowse[0].resultMask = UA_BROWSERESULTMASK_ALL;
+  UA_BrowseResponse bResp = UA_Client_Service_browse(client, bReq);
+
+  bool success = false;
+  for (int i=0; i < bResp.resultsSize && !success; i++) {
+    for (int j=0; j < bResp.results[i].referencesSize && !success; j++) {
+      UA_ReferenceDescription *ref = &(bResp.results[i].references[j]);
+      if (UA_NodeId_equal(&ref->referenceTypeId,&type)) {
+        UA_NodeId_copy(&ref->nodeId.nodeId,result);
+        success = true;
+      }
+    }
+  }
+
+  UA_BrowseResponse_deleteMembers(&bResp);
+  UA_BrowseResponse_clear(&bResp);
+  return success;
+}
+
+bool client_node_list_references(UA_Client *client, UA_NodeId parent, bool inverse) {
+  UA_BrowseRequest bReq;
+  UA_BrowseRequest_init(&bReq);
+  bReq.requestedMaxReferencesPerNode = 0;
+  bReq.nodesToBrowse = UA_BrowseDescription_new();
+  bReq.nodesToBrowseSize = 1;
+  bReq.nodesToBrowse[0].nodeId = parent;
+  bReq.nodesToBrowse[0].browseDirection = inverse ? 1 : 0;
+  bReq.nodesToBrowse[0].resultMask = UA_BROWSERESULTMASK_ALL;
+  UA_BrowseResponse bResp = UA_Client_Service_browse(client, bReq);
+
+  for (int i=0; i < bResp.resultsSize; i++) {
+    for (int j=0; j < bResp.results[i].referencesSize; j++) {
+      UA_ReferenceDescription *ref = &(bResp.results[i].references[j]);
+
+      UA_QualifiedName qn;  UA_QualifiedName_init(&qn);
+      UA_Client_readBrowseNameAttribute(client, ref->nodeId.nodeId, &qn);
+      UA_QualifiedName tqn;  UA_QualifiedName_init(&tqn);
+      UA_Client_readBrowseNameAttribute(client, ref->referenceTypeId, &tqn);
+      printf("ns=%d;i=%u - %-16.*s(ns=%d;i=%u) -> %d:%-16.*s\n",
+             ref->nodeId.nodeId.namespaceIndex,
+             ref->nodeId.nodeId.identifier.numeric,
+             (int)tqn.name.length,
+             tqn.name.data,
+             ref->referenceTypeId.namespaceIndex,
+             ref->referenceTypeId.identifier.numeric,
+             qn.namespaceIndex,
+             (int)qn.name.length,
+             qn.name.data
+      );
+
+    }
+  }
+  UA_BrowseResponse_deleteMembers(&bResp);
+  UA_BrowseResponse_clear(&bResp);
+  return false;
+}