opcua_client 0.0.2 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6d5c48f943609a5cff626ade2e52495427fc8c3b3af175c2ac9b7231146209ec
-  data.tar.gz: f0ec2ea830a866681352b2048950382a06d199ea1f53b47a31857b1f066a3c2f
+  metadata.gz: ae12c435f33aa7b57384562385a22dafb562fe3620573697b5d3bc57e1e58798
+  data.tar.gz: 29ac2ff75077f30b9c614103033c43e53186db66a428352f2bdfc369203715ae
 SHA512:
-  metadata.gz: 54bacd20dd2f8f73c10dacd29f1b9ab3776ee1cec0933aa1c56423a9cc077161c5d1c0fb676111b679f80eae434640cbeb5cce2d12d254fd5877927d18142acc
-  data.tar.gz: 270a0757c4d3469e7e3e6cbf57e874d4ec13911d221bc3befb4a257abf237b0b7307bed5f14960b5381d3ddcf74e4c77d014e778d09efb389c75a957056bb9f3
+  metadata.gz: 96f3ec5185c7072203f003ec35a3db4a984277333fe413f600248e7ffadcf92c815fbb6fc593f0b2b3d5fffd7983b71e0685188a0909ec826f63ad56ddb6a09a
+  data.tar.gz: f11e9e5101902d4a4715741c455762ba8bcd4eb28715e80eb8644319267d66d7e52d6c850d29234fd72a6938b18eaface6f20788bd613b3052fc96489c2ce2dd

data/README.md

@@ -2,6 +2,8 @@
 
 Incomplete OPC-UA client library for Ruby. Wraps open62541: <https://open62541.org>.
 
+![ci-badge](https://github.com/mak-it/opcua-client-ruby/actions/workflows/build.yml/badge.svg)
+
 ## Installation
 
 Add it to your Gemfile:
@@ -53,15 +55,21 @@ end
 All methods raise OPCUAClient::Error if unsuccessful.
 
 * ```client.read_int16(Fixnum ns, String name) => Fixnum```
+* ```client.read_uint16(Fixnum ns, String name) => Fixnum```
 * ```client.read_int32(Fixnum ns, String name) => Fixnum```
+* ```client.read_uint32(Fixnum ns, String name) => Fixnum```
 * ```client.read_float(Fixnum ns, String name) => Float```
 * ```client.read_boolean(Fixnum ns, String name) => true/false```
 * ```client.write_int16(Fixnum ns, String name, Fixnum value)```
+* ```client.write_uint16(Fixnum ns, String name, Fixnum value)```
 * ```client.write_int32(Fixnum ns, String name, Fixnum value)```
+* ```client.write_uint32(Fixnum ns, String name, Fixnum value)```
 * ```client.write_float(Fixnum ns, String name, Float value)```
 * ```client.write_boolean(Fixnum ns, String name, bool value)```
 * ```client.multi_write_int16(Fixnum ns, Array[String] names, Array[Fixnum] values)```
+* ```client.multi_write_uint16(Fixnum ns, Array[String] names, Array[Fixnum] values)```
 * ```client.multi_write_int32(Fixnum ns, Array[String] names, Array[Fixnum] values)```
+* ```client.multi_write_uint32(Fixnum ns, Array[String] names, Array[Fixnum] values)```
 * ```client.multi_write_float(Fixnum ns, Array[String] names, Array[Float] values)```
 * ```client.multi_write_boolean(Fixnum ns, Array[String] names, Array[bool] values)```
 
@@ -118,7 +126,15 @@ bundle
 ### Try out changes
 
 ```console
-$ rake compile
+$ bin/rake compile
 $ bin/console
 pry> client = OPCUAClient::Client.new
+pry> client.connect("opc.tcp://127.0.0.1:4840")
+```
+
+### Test it
+
+```console
+$ bin/rake compile
+$ bin/rake spec
 ```

data/ext/opcua_client/opcua_client.c

@@ -34,29 +34,29 @@ handler_dataChanged(UA_Client *client, UA_UInt32 subId, void *subContext,
     struct OpcuaClientContext *ctx = UA_Client_getContext(client);
     VALUE self = ctx->rubyClientInstance;
     VALUE callback = rb_ivar_get(self, rb_intern("@callback_after_data_changed"));
-    
+
     if (NIL_P(callback)) {
         return;
     }
-    
+
     VALUE v_serverTime = Qnil;
     if (value->hasServerTimestamp) {
         v_serverTime = toRubyTime(value->serverTimestamp);
     }
-    
+
     VALUE v_sourceTime = Qnil;
     if (value->hasSourceTimestamp) {
         v_sourceTime = toRubyTime(value->sourceTimestamp);
     }
-    
+
     VALUE params = rb_ary_new();
     rb_ary_push(params, UINT2NUM(subId));
     rb_ary_push(params, UINT2NUM(monId));
     rb_ary_push(params, v_serverTime);
     rb_ary_push(params, v_sourceTime);
-    
+
     VALUE v_newValue = Qnil;
-    
+
     if(UA_Variant_hasScalarType(&value->value, &UA_TYPES[UA_TYPES_DATETIME])) {
         UA_DateTime raw_date = *(UA_DateTime *) value->value.data;
         v_newValue = toRubyTime(raw_date);
@@ -73,7 +73,7 @@ handler_dataChanged(UA_Client *client, UA_UInt32 subId, void *subContext,
         UA_Float dbl = *(UA_Float *) value->value.data;
         v_newValue = DBL2NUM(dbl);
     }
-    
+
     rb_ary_push(params, v_newValue);
     rb_proc_call(callback, params);
 }
@@ -91,7 +91,7 @@ subscriptionInactivityCallback(UA_Client *client, UA_UInt32 subscriptionId, void
 static void
 stateCallback (UA_Client *client, UA_ClientState clientState) {
     struct OpcuaClientContext *ctx = UA_Client_getContext(client);
-    
+
     switch(clientState) {
         case UA_CLIENTSTATE_DISCONNECTED:
             ; // printf("%s\n", "The client is disconnected");
@@ -105,14 +105,14 @@ stateCallback (UA_Client *client, UA_ClientState clientState) {
         case UA_CLIENTSTATE_SESSION:
             ; // printf("%s\n", "A new session was created!");
             VALUE self = ctx->rubyClientInstance;
-            
+
             VALUE callback = rb_ivar_get(self, rb_intern("@callback_after_session_created"));
             if (!NIL_P(callback)) {
                 VALUE params = rb_ary_new();
                 rb_ary_push(params, self);
                 rb_proc_call(callback, params); // rescue?
             }
-            
+
             break;
         case UA_CLIENTSTATE_SESSION_RENEWED:
             /* The session was renewed. We don't need to recreate the subscription. */
@@ -134,7 +134,7 @@ static VALUE raise_ua_status_error(UA_StatusCode status) {
 static void UA_Client_free(void *self) {
     // printf("free client\n");
     struct UninitializedClient *uclient = self;
-    
+
     if (uclient->client) {
         struct OpcuaClientContext *ctx = UA_Client_getContext(uclient->client);
         xfree(ctx);
@@ -154,26 +154,26 @@ static VALUE allocate(VALUE klass) {
     // printf("allocate client\n");
     struct UninitializedClient *uclient = ALLOC(struct UninitializedClient);
     *uclient = (const struct UninitializedClient){ 0 };
-    
+
     return TypedData_Wrap_Struct(klass, &UA_Client_Type, uclient);
 }
 
 static VALUE rb_initialize(VALUE self) {
     struct UninitializedClient * uclient;
     TypedData_Get_Struct(self, struct UninitializedClient, &UA_Client_Type, uclient);
-    
+
     UA_ClientConfig customConfig = UA_ClientConfig_default;
     customConfig.stateCallback = stateCallback;
     customConfig.subscriptionInactivityCallback = subscriptionInactivityCallback;
-    
+
     struct OpcuaClientContext *ctx = ALLOC(struct OpcuaClientContext);
     *ctx = (const struct OpcuaClientContext){ 0 };
-    
+
     ctx->rubyClientInstance = self;
     customConfig.clientContext = ctx;
-    
+
     uclient->client = UA_Client_new(customConfig);
-    
+
     return Qnil;
 }
 
@@ -181,15 +181,15 @@ static VALUE rb_connect(VALUE self, VALUE v_connectionString) {
     if (RB_TYPE_P(v_connectionString, T_STRING) != 1) {
         return raise_invalid_arguments_error();
     }
-    
+
     char *connectionString = StringValueCStr(v_connectionString);
-    
+
     struct UninitializedClient * uclient;
     TypedData_Get_Struct(self, struct UninitializedClient, &UA_Client_Type, uclient);
     UA_Client *client = uclient->client;
-    
+
     UA_StatusCode status = UA_Client_connect(client, connectionString);
-    
+
     if (status == UA_STATUSCODE_GOOD) {
         return Qnil;
     } else {
@@ -201,10 +201,10 @@ static VALUE rb_createSubscription(VALUE self) {
     struct UninitializedClient * uclient;
     TypedData_Get_Struct(self, struct UninitializedClient, &UA_Client_Type, uclient);
     UA_Client *client = uclient->client;
-    
+
     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_UInt32 subscriptionId = response.subscriptionId;
         return UINT2NUM(subscriptionId);
@@ -217,13 +217,13 @@ static VALUE rb_addMonitoredItem(VALUE self, VALUE v_subscriptionId, VALUE v_mon
     struct UninitializedClient * uclient;
     TypedData_Get_Struct(self, struct UninitializedClient, &UA_Client_Type, uclient);
     UA_Client *client = uclient->client;
-    
+
     UA_UInt32 subscriptionId = NUM2UINT(v_subscriptionId); // TODO: check type
     UA_UInt16 monNsIndex = NUM2USHORT(v_monNsIndex); // TODO: check type
     char* monNsName = StringValueCStr(v_monNsName); // TODO: check type
 
     UA_MonitoredItemCreateRequest monRequest = UA_MonitoredItemCreateRequest_default(UA_NODEID_STRING(monNsIndex, monNsName));
-    
+
     UA_MonitoredItemCreateResult monResponse =
     UA_Client_MonitoredItems_createDataChange(client, subscriptionId,
                                               UA_TIMESTAMPSTORETURN_BOTH,
@@ -242,18 +242,78 @@ static VALUE rb_disconnect(VALUE self) {
     struct UninitializedClient * uclient;
     TypedData_Get_Struct(self, struct UninitializedClient, &UA_Client_Type, uclient);
     UA_Client *client = uclient->client;
-    
+
     UA_StatusCode status = UA_Client_disconnect(client);
     return RB_UINT2NUM(status);
 }
 
+static UA_StatusCode multiRead(UA_Client *client, const UA_NodeId *nodeId, UA_Variant *out, const long varsCount) {
+
+    UA_UInt16 rvSize = UA_TYPES[UA_TYPES_READVALUEID].memSize;
+    UA_ReadValueId *rValues = UA_calloc(varsCount, rvSize);
+
+    for (int i=0; i<varsCount; i++) {
+        UA_ReadValueId *readItem = &rValues[i];
+        readItem->nodeId = nodeId[i];
+        readItem->attributeId = UA_ATTRIBUTEID_VALUE;
+    }
+
+    UA_ReadRequest request;
+    UA_ReadRequest_init(&request);
+    request.nodesToRead = rValues;
+    request.nodesToReadSize = varsCount;
+
+    UA_ReadResponse response = UA_Client_Service_read(client, request);
+    UA_StatusCode retval = response.responseHeader.serviceResult;
+    if(retval == UA_STATUSCODE_GOOD) {
+        if(response.resultsSize == varsCount)
+            retval = response.results[0].status;
+        else
+            retval = UA_STATUSCODE_BADUNEXPECTEDERROR;
+    }
+
+    if(retval != UA_STATUSCODE_GOOD) {
+        UA_ReadResponse_deleteMembers(&response);
+        UA_free(rValues);
+        return retval;
+    }
+
+    /* Set the StatusCode */
+    UA_DataValue *results = response.results;
+
+    if (response.resultsSize != varsCount) {
+        retval = UA_STATUSCODE_BADUNEXPECTEDERROR;
+        UA_ReadResponse_deleteMembers(&response);
+        UA_free(rValues);
+        return retval;
+    }
+
+    for (int i=0; i<varsCount; i++) {
+        if ((results[i].hasStatus && results[i].status != UA_STATUSCODE_GOOD) || !results[i].hasValue) {
+            retval = UA_STATUSCODE_BADUNEXPECTEDERROR;
+            UA_ReadResponse_deleteMembers(&response);
+            UA_free(rValues);
+            return retval;
+        }
+    }
+
+    for (int i=0; i<varsCount; i++) {
+        out[i] = results[i].value;
+        UA_Variant_init(&results[i].value);
+    }
+
+    UA_ReadResponse_deleteMembers(&response);
+    UA_free(rValues);
+    return retval;
+}
+
 static UA_StatusCode multiWrite(UA_Client *client, const UA_NodeId *nodeId, const UA_Variant *in, const long varsSize) {
     UA_AttributeId attributeId = UA_ATTRIBUTEID_VALUE;
-    
+
     UA_UInt16 wvSize = UA_TYPES[UA_TYPES_WRITEVALUE].memSize;
-    
+
     UA_WriteValue *wValues = UA_calloc(varsSize, wvSize);
-    
+
     for (int i=0; i<varsSize; i++) {
         UA_WriteValue *wValue = &wValues[i];
         wValue->attributeId = attributeId;
@@ -261,7 +321,7 @@ static UA_StatusCode multiWrite(UA_Client *client, const UA_NodeId *nodeId, cons
         wValue->value.value = in[i];
         wValue->value.hasValue = true;
     }
-    
+
     UA_WriteRequest wReq;
     UA_WriteRequest_init(&wReq);
     wReq.nodesToWrite = wValues;
@@ -273,7 +333,7 @@ static UA_StatusCode multiWrite(UA_Client *client, const UA_NodeId *nodeId, cons
     if(retval == UA_STATUSCODE_GOOD) {
         if(wResp.resultsSize == varsSize) {
             retval = wResp.results[0];
-            
+
             for (int i=0; i<wResp.resultsSize; i++) {
                 if (wResp.results[i] != UA_STATUSCODE_GOOD) {
                     retval = wResp.results[i];
@@ -281,7 +341,7 @@ static UA_StatusCode multiWrite(UA_Client *client, const UA_NodeId *nodeId, cons
                     break;
                 }
             }
-            
+
             if (retval == UA_STATUSCODE_GOOD) {
                 // printf("%s\n", "multiWrite: all vars written");
             }
@@ -295,66 +355,168 @@ static UA_StatusCode multiWrite(UA_Client *client, const UA_NodeId *nodeId, cons
 
     UA_WriteResponse_deleteMembers(&wResp);
     UA_free(wValues);
-    
+
     return retval;
 }
 
+static VALUE rb_readUaValues(VALUE self, VALUE v_nsIndex, VALUE v_aryNames) {
+    if (RB_TYPE_P(v_nsIndex, T_FIXNUM) != 1) {
+        return raise_invalid_arguments_error();
+    }
+
+    Check_Type(v_aryNames, T_ARRAY);
+    const long namesCount = RARRAY_LEN(v_aryNames);
+
+    int nsIndex = FIX2INT(v_nsIndex);
+
+    struct UninitializedClient * uclient;
+    TypedData_Get_Struct(self, struct UninitializedClient, &UA_Client_Type, uclient);
+    UA_Client *client = uclient->client;
+
+    UA_UInt16 nidSize = UA_TYPES[UA_TYPES_NODEID].memSize;
+    UA_UInt16 variantSize = UA_TYPES[UA_TYPES_VARIANT].memSize;
+
+    UA_NodeId *nodes = UA_calloc(namesCount, nidSize);
+    UA_Variant *readValues = UA_calloc(namesCount, variantSize);
+
+    for (int i=0; i<namesCount; i++) {
+        VALUE v_name = rb_ary_entry(v_aryNames, i);
+
+        if (RB_TYPE_P(v_name, T_STRING) != 1) {
+            return raise_invalid_arguments_error();
+        }
+
+        char *name = StringValueCStr(v_name);
+        nodes[i] = UA_NODEID_STRING(nsIndex, name);
+    }
+
+    UA_StatusCode status = multiRead(client, nodes, readValues, namesCount);
+
+    VALUE resultArray = Qnil;
+
+    if (status == UA_STATUSCODE_GOOD) {
+        // printf("%s\n", "value read successful");
+
+        resultArray = rb_ary_new2(namesCount);
+
+        for (int i=0; i<namesCount; i++) {
+            // printf("the value is: %i\n", val);
+
+            VALUE rubyVal = Qnil;
+
+            if (UA_Variant_hasScalarType(&readValues[i], &UA_TYPES[UA_TYPES_INT16])) {
+                UA_Int16 val = *(UA_Int16*)readValues[i].data;
+                rubyVal = INT2FIX(val);
+            } else if (UA_Variant_hasScalarType(&readValues[i], &UA_TYPES[UA_TYPES_UINT16])) {
+                UA_UInt16 val = *(UA_UInt16*)readValues[i].data;
+                rubyVal = INT2FIX(val);
+            } else if (UA_Variant_hasScalarType(&readValues[i], &UA_TYPES[UA_TYPES_INT32])) {
+                 UA_Int32 val = *(UA_Int32*)readValues[i].data;
+                 rubyVal = INT2FIX(val);
+            } else if (UA_Variant_hasScalarType(&readValues[i], &UA_TYPES[UA_TYPES_UINT32])) {
+                 UA_UInt32 val = *(UA_UInt32*)readValues[i].data;
+                 rubyVal = INT2FIX(val);
+            } else if (UA_Variant_hasScalarType(&readValues[i], &UA_TYPES[UA_TYPES_BOOLEAN])) {
+                 UA_Boolean val = *(UA_Boolean*)readValues[i].data;
+                 rubyVal = val ? Qtrue : Qfalse;
+            } else if (UA_Variant_hasScalarType(&readValues[i], &UA_TYPES[UA_TYPES_FLOAT])) {
+                 UA_Float val = *(UA_Float*)readValues[i].data;
+                 rubyVal = DBL2NUM(val);
+            } else {
+                rubyVal = Qnil; // unsupported
+            }
+
+            rb_ary_push(resultArray, rubyVal);
+        }
+    } else {
+        /* Clean up */
+        for (int i=0; i<namesCount; i++) {
+            UA_Variant_deleteMembers(&readValues[i]);
+        }
+        UA_free(nodes);
+        UA_free(readValues);
+
+        return raise_ua_status_error(status);
+    }
+
+    /* Clean up */
+    for (int i=0; i<namesCount; i++) {
+        UA_Variant_deleteMembers(&readValues[i]);
+    }
+    UA_free(nodes);
+    UA_free(readValues);
+
+    return resultArray;
+}
+
 static VALUE rb_writeUaValues(VALUE self, VALUE v_nsIndex, VALUE v_aryNames, VALUE v_aryNewValues, int uaType) {
     if (RB_TYPE_P(v_nsIndex, T_FIXNUM) != 1) {
         return raise_invalid_arguments_error();
     }
-    
+
     Check_Type(v_aryNames, T_ARRAY);
     Check_Type(v_aryNewValues, T_ARRAY);
-    
+
     const long namesCount = RARRAY_LEN(v_aryNames);
     const long valuesCount = RARRAY_LEN(v_aryNewValues);
-    
+
     if (namesCount != valuesCount) {
         return raise_invalid_arguments_error();
     }
-    
+
     int nsIndex = FIX2INT(v_nsIndex);
-    
+
     struct UninitializedClient * uclient;
     TypedData_Get_Struct(self, struct UninitializedClient, &UA_Client_Type, uclient);
     UA_Client *client = uclient->client;
-    
+
     UA_UInt16 nidSize = UA_TYPES[UA_TYPES_NODEID].memSize;
     UA_UInt16 variantSize = UA_TYPES[UA_TYPES_VARIANT].memSize;
-    
+
     UA_NodeId *nodes = UA_calloc(namesCount, nidSize);
     UA_Variant *values = UA_calloc(namesCount, variantSize);
-    
+
     for (int i=0; i<namesCount; i++) {
         VALUE v_name = rb_ary_entry(v_aryNames, i);
         VALUE v_newValue = rb_ary_entry(v_aryNewValues, i);
-        
+
         if (RB_TYPE_P(v_name, T_STRING) != 1) {
             return raise_invalid_arguments_error();
         }
-        
+
         char *name = StringValueCStr(v_name);
         nodes[i] = UA_NODEID_STRING(nsIndex, name);
-        
-        if (uaType == UA_TYPES_INT16) {
+
+        if (uaType == UA_TYPES_UINT16) {
+            Check_Type(v_newValue, T_FIXNUM);
+            UA_UInt16 newValue = NUM2USHORT(v_newValue);
+            values[i].data = UA_malloc(sizeof(UA_UInt16));
+            *(UA_UInt16*)values[i].data = newValue;
+            values[i].type = &UA_TYPES[uaType];
+        } else if (uaType == UA_TYPES_INT16) {
             Check_Type(v_newValue, T_FIXNUM);
             UA_Int16 newValue = NUM2SHORT(v_newValue);
             values[i].data = UA_malloc(sizeof(UA_Int16));
             *(UA_Int16*)values[i].data = newValue;
-            values[i].type = &UA_TYPES[UA_TYPES_INT16];
+            values[i].type = &UA_TYPES[uaType];
+        } else if (uaType == UA_TYPES_UINT32) {
+            Check_Type(v_newValue, T_FIXNUM);
+            UA_UInt32 newValue = NUM2UINT(v_newValue);
+            values[i].data = UA_malloc(sizeof(UA_UInt32));
+            *(UA_UInt32*)values[i].data = newValue;
+            values[i].type = &UA_TYPES[uaType];
         } else if (uaType == UA_TYPES_INT32) {
             Check_Type(v_newValue, T_FIXNUM);
             UA_Int32 newValue = NUM2INT(v_newValue);
             values[i].data = UA_malloc(sizeof(UA_Int32));
             *(UA_Int32*)values[i].data = newValue;
-            values[i].type = &UA_TYPES[UA_TYPES_INT32];
+            values[i].type = &UA_TYPES[uaType];
         } else if (uaType == UA_TYPES_FLOAT) {
             Check_Type(v_newValue, T_FLOAT);
             UA_Float newValue = NUM2DBL(v_newValue);
             values[i].data = UA_malloc(sizeof(UA_Float));
             *(UA_Float*)values[i].data = newValue;
-            values[i].type = &UA_TYPES[UA_TYPES_FLOAT];
+            values[i].type = &UA_TYPES[uaType];
         } else if (uaType == UA_TYPES_BOOLEAN) {
             if (RB_TYPE_P(v_newValue, T_TRUE) != 1 && RB_TYPE_P(v_newValue, T_FALSE) != 1) {
                 return raise_invalid_arguments_error();
@@ -367,9 +529,9 @@ static VALUE rb_writeUaValues(VALUE self, VALUE v_nsIndex, VALUE v_aryNames, VAL
             rb_raise(cError, "Unsupported type");
         }
     }
-    
+
     UA_StatusCode status = multiWrite(client, nodes, values, namesCount);
-    
+
     if (status == UA_STATUSCODE_GOOD) {
         // printf("%s\n", "value write successful");
     } else {
@@ -379,17 +541,17 @@ static VALUE rb_writeUaValues(VALUE self, VALUE v_nsIndex, VALUE v_aryNames, VAL
         }
         UA_free(nodes);
         UA_free(values);
-        
+
         return raise_ua_status_error(status);
     }
-    
+
     /* Clean up */
     for (int i=0; i<namesCount; i++) {
         UA_Variant_deleteMembers(&values[i]);
     }
     UA_free(nodes);
     UA_free(values);
-    
+
     return Qnil;
 }
 
@@ -397,35 +559,45 @@ static VALUE rb_writeUaValue(VALUE self, VALUE v_nsIndex, VALUE v_name, VALUE v_
     if (RB_TYPE_P(v_name, T_STRING) != 1) {
         return raise_invalid_arguments_error();
     }
-    
+
     if (RB_TYPE_P(v_nsIndex, T_FIXNUM) != 1) {
         return raise_invalid_arguments_error();
     }
-    
+
     if (uaType == UA_TYPES_INT16 && RB_TYPE_P(v_newValue, T_FIXNUM) != 1) {
         return raise_invalid_arguments_error();
     }
-    
+
     char *name = StringValueCStr(v_name);
     int nsIndex = FIX2INT(v_nsIndex);
-    
+
     struct UninitializedClient * uclient;
     TypedData_Get_Struct(self, struct UninitializedClient, &UA_Client_Type, uclient);
     UA_Client *client = uclient->client;
-    
+
     UA_Variant value;
     UA_Variant_init(&value);
-    
+
     if (uaType == UA_TYPES_INT16) {
         UA_Int16 newValue = NUM2SHORT(v_newValue);
         value.data = UA_malloc(sizeof(UA_Int16));
         *(UA_Int16*)value.data = newValue;
         value.type = &UA_TYPES[UA_TYPES_INT16];
+    } else if (uaType == UA_TYPES_UINT16) {
+        UA_UInt16 newValue = NUM2USHORT(v_newValue);
+        value.data = UA_malloc(sizeof(UA_UInt16));
+        *(UA_UInt16*)value.data = newValue;
+        value.type = &UA_TYPES[UA_TYPES_UINT16];
     } else if (uaType == UA_TYPES_INT32) {
         UA_Int32 newValue = NUM2INT(v_newValue);
         value.data = UA_malloc(sizeof(UA_Int32));
         *(UA_Int32*)value.data = newValue;
         value.type = &UA_TYPES[UA_TYPES_INT32];
+    } else if (uaType == UA_TYPES_UINT32) {
+        UA_UInt32 newValue = NUM2UINT(v_newValue);
+        value.data = UA_malloc(sizeof(UA_UInt32));
+        *(UA_UInt32*)value.data = newValue;
+        value.type = &UA_TYPES[UA_TYPES_UINT32];
     } else if (uaType == UA_TYPES_FLOAT) {
         UA_Float newValue = NUM2DBL(v_newValue);
         value.data = UA_malloc(sizeof(UA_Float));
@@ -441,7 +613,7 @@ static VALUE rb_writeUaValue(VALUE self, VALUE v_nsIndex, VALUE v_name, VALUE v_
     }
 
     UA_StatusCode status = UA_Client_writeValueAttribute(client, UA_NODEID_STRING(nsIndex, name), &value);
-    
+
     if (status == UA_STATUSCODE_GOOD) {
         // printf("%s\n", "value write successful");
     } else {
@@ -449,13 +621,21 @@ static VALUE rb_writeUaValue(VALUE self, VALUE v_nsIndex, VALUE v_name, VALUE v_
         UA_Variant_deleteMembers(&value);
         return raise_ua_status_error(status);
     }
-    
+
     /* Clean up */
     UA_Variant_deleteMembers(&value);
-    
+
     return Qnil;
 }
 
+static VALUE rb_writeUInt16Value(VALUE self, VALUE v_nsIndex, VALUE v_name, VALUE v_newValue) {
+    return rb_writeUaValue(self, v_nsIndex, v_name, v_newValue, UA_TYPES_UINT16);
+}
+
+static VALUE rb_writeUInt16Values(VALUE self, VALUE v_nsIndex, VALUE v_aryNames, VALUE v_aryNewValues) {
+    return rb_writeUaValues(self, v_nsIndex, v_aryNames, v_aryNewValues, UA_TYPES_UINT16);
+}
+
 static VALUE rb_writeInt16Value(VALUE self, VALUE v_nsIndex, VALUE v_name, VALUE v_newValue) {
     return rb_writeUaValue(self, v_nsIndex, v_name, v_newValue, UA_TYPES_INT16);
 }
@@ -472,6 +652,14 @@ static VALUE rb_writeInt32Values(VALUE self, VALUE v_nsIndex, VALUE v_aryNames,
     return rb_writeUaValues(self, v_nsIndex, v_aryNames, v_aryNewValues, UA_TYPES_INT32);
 }
 
+static VALUE rb_writeUInt32Value(VALUE self, VALUE v_nsIndex, VALUE v_name, VALUE v_newValue) {
+    return rb_writeUaValue(self, v_nsIndex, v_name, v_newValue, UA_TYPES_UINT32);
+}
+
+static VALUE rb_writeUInt32Values(VALUE self, VALUE v_nsIndex, VALUE v_aryNames, VALUE v_aryNewValues) {
+    return rb_writeUaValues(self, v_nsIndex, v_aryNames, v_aryNewValues, UA_TYPES_UINT32);
+}
+
 static VALUE rb_writeBooleanValue(VALUE self, VALUE v_nsIndex, VALUE v_name, VALUE v_newValue) {
     return rb_writeUaValue(self, v_nsIndex, v_name, v_newValue, UA_TYPES_BOOLEAN);
 }
@@ -492,22 +680,22 @@ static VALUE rb_readUaValue(VALUE self, VALUE v_nsIndex, VALUE v_name, int type)
     if (RB_TYPE_P(v_name, T_STRING) != 1) {
         return raise_invalid_arguments_error();
     }
-    
+
     if (RB_TYPE_P(v_nsIndex, T_FIXNUM) != 1) {
         return raise_invalid_arguments_error();
     }
-    
+
     char *name = StringValueCStr(v_name);
     int nsIndex = FIX2INT(v_nsIndex);
-    
+
     struct UninitializedClient * uclient;
     TypedData_Get_Struct(self, struct UninitializedClient, &UA_Client_Type, uclient);
     UA_Client *client = uclient->client;
-    
+
     UA_Variant value;
     UA_Variant_init(&value);
     UA_StatusCode status = UA_Client_readValueAttribute(client, UA_NODEID_STRING(nsIndex, name), &value);
-    
+
     if (status == UA_STATUSCODE_GOOD) {
         // printf("%s\n", "value read successful");
     } else {
@@ -515,16 +703,23 @@ static VALUE rb_readUaValue(VALUE self, VALUE v_nsIndex, VALUE v_name, int type)
         UA_Variant_deleteMembers(&value);
         return raise_ua_status_error(status);
     }
-    
+
     VALUE result = Qnil;
-    
+
     if (type == UA_TYPES_INT16 && UA_Variant_hasScalarType(&value, &UA_TYPES[UA_TYPES_INT16])) {
         UA_Int16 val =*(UA_Int16*)value.data;
         // printf("the value is: %i\n", val);
         result = INT2FIX(val);
+    } else if (type == UA_TYPES_UINT16 && UA_Variant_hasScalarType(&value, &UA_TYPES[UA_TYPES_UINT16])) {
+        UA_UInt16 val =*(UA_UInt16*)value.data;
+        // printf("the value is: %i\n", val);
+        result = INT2FIX(val);
     } else if (type == UA_TYPES_INT32 && UA_Variant_hasScalarType(&value, &UA_TYPES[UA_TYPES_INT32])) {
         UA_Int32 val =*(UA_Int32*)value.data;
         result = INT2FIX(val);
+    } else if (type == UA_TYPES_UINT32 && UA_Variant_hasScalarType(&value, &UA_TYPES[UA_TYPES_UINT32])) {
+        UA_UInt32 val =*(UA_UInt32*)value.data;
+        result = INT2FIX(val);
     } else if (type == UA_TYPES_BOOLEAN && UA_Variant_hasScalarType(&value, &UA_TYPES[UA_TYPES_BOOLEAN])) {
         UA_Boolean val =*(UA_Boolean*)value.data;
         result = val ? Qtrue : Qfalse;
@@ -532,13 +727,13 @@ static VALUE rb_readUaValue(VALUE self, VALUE v_nsIndex, VALUE v_name, int type)
         UA_Float val =*(UA_Float*)value.data;
         result = DBL2NUM(val);
     } else {
-        rb_raise(cError, "Not an int16");
+        rb_raise(cError, "UA type mismatch");
         return Qnil;
     }
-    
+
     /* Clean up */
     UA_Variant_deleteMembers(&value);
-    
+
     return result;
 }
 
@@ -546,10 +741,18 @@ static VALUE rb_readInt16Value(VALUE self, VALUE v_nsIndex, VALUE v_name) {
     return rb_readUaValue(self, v_nsIndex, v_name, UA_TYPES_INT16);
 }
 
+static VALUE rb_readUInt16Value(VALUE self, VALUE v_nsIndex, VALUE v_name) {
+    return rb_readUaValue(self, v_nsIndex, v_name, UA_TYPES_UINT16);
+}
+
 static VALUE rb_readInt32Value(VALUE self, VALUE v_nsIndex, VALUE v_name) {
     return rb_readUaValue(self, v_nsIndex, v_name, UA_TYPES_INT32);
 }
 
+static VALUE rb_readUInt32Value(VALUE self, VALUE v_nsIndex, VALUE v_name) {
+    return rb_readUaValue(self, v_nsIndex, v_name, UA_TYPES_UINT32);
+}
+
 static VALUE rb_readBooleanValue(VALUE self, VALUE v_nsIndex, VALUE v_name) {
     return rb_readUaValue(self, v_nsIndex, v_name, UA_TYPES_BOOLEAN);
 }
@@ -572,7 +775,7 @@ static VALUE rb_run_single_monitoring_cycle(VALUE self) {
     struct UninitializedClient * uclient;
     TypedData_Get_Struct(self, struct UninitializedClient, &UA_Client_Type, uclient);
     UA_Client *client = uclient->client;
-    
+
     UA_StatusCode status = UA_Client_runAsync(client, 1000);
     return UINT2NUM(status);
 }
@@ -581,13 +784,13 @@ static VALUE rb_run_single_monitoring_cycle_bang(VALUE self) {
     struct UninitializedClient * uclient;
     TypedData_Get_Struct(self, struct UninitializedClient, &UA_Client_Type, uclient);
     UA_Client *client = uclient->client;
-    
+
     UA_StatusCode status = UA_Client_runAsync(client, 1000);
-    
+
     if (status != UA_STATUSCODE_GOOD) {
         return raise_ua_status_error(status);
     }
-    
+
     return Qnil;
 }
 
@@ -595,7 +798,7 @@ static VALUE rb_state(VALUE self) {
     struct UninitializedClient * uclient;
     TypedData_Get_Struct(self, struct UninitializedClient, &UA_Client_Type, uclient);
     UA_Client *client = uclient->client;
-    
+
     UA_ClientState state = UA_Client_getState(client);
     return INT2NUM(state);
 }
@@ -613,47 +816,58 @@ void Init_opcua_client()
 #ifdef UA_ENABLE_SUBSCRIPTIONS
     // printf("%s\n", "ok! opcua-client-ruby built with subscriptions enabled.");
 #endif
-    
+
     mOPCUAClient = rb_const_get(rb_cObject, rb_intern("OPCUAClient"));
+    rb_global_variable(&mOPCUAClient);
     defineStateContants(mOPCUAClient);
-    
+
     cError = rb_define_class_under(mOPCUAClient, "Error", rb_eStandardError);
+    rb_global_variable(&cError);
     cClient = rb_define_class_under(mOPCUAClient, "Client", rb_cObject);
-    
+    rb_global_variable(&cClient);
+
     rb_define_alloc_func(cClient, allocate);
-    
+
     rb_define_method(cClient, "initialize", rb_initialize, 0);
-    
+
     rb_define_method(cClient, "run_single_monitoring_cycle", rb_run_single_monitoring_cycle, 0);
     rb_define_method(cClient, "run_mon_cycle", rb_run_single_monitoring_cycle, 0);
     rb_define_method(cClient, "do_mon_cycle", rb_run_single_monitoring_cycle, 0);
-    
+
     rb_define_method(cClient, "run_single_monitoring_cycle!", rb_run_single_monitoring_cycle_bang, 0);
     rb_define_method(cClient, "run_mon_cycle!", rb_run_single_monitoring_cycle_bang, 0);
     rb_define_method(cClient, "do_mon_cycle!", rb_run_single_monitoring_cycle_bang, 0);
-    
+
     rb_define_method(cClient, "connect", rb_connect, 1);
     rb_define_method(cClient, "disconnect", rb_disconnect, 0);
     rb_define_method(cClient, "state", rb_state, 0);
-    
+
     rb_define_method(cClient, "read_int16", rb_readInt16Value, 2);
+    rb_define_method(cClient, "read_uint16", rb_readUInt16Value, 2);
     rb_define_method(cClient, "read_int32", rb_readInt32Value, 2);
+    rb_define_method(cClient, "read_uint32", rb_readUInt32Value, 2);
     rb_define_method(cClient, "read_float", rb_readFloatValue, 2);
     rb_define_method(cClient, "read_boolean", rb_readBooleanValue, 2);
     rb_define_method(cClient, "read_bool", rb_readBooleanValue, 2);
-    
+
     rb_define_method(cClient, "write_int16", rb_writeInt16Value, 3);
+    rb_define_method(cClient, "write_uint16", rb_writeUInt16Value, 3);
     rb_define_method(cClient, "write_int32", rb_writeInt32Value, 3);
+    rb_define_method(cClient, "write_uint32", rb_writeUInt32Value, 3);
     rb_define_method(cClient, "write_float", rb_writeFloatValue, 3);
     rb_define_method(cClient, "write_boolean", rb_writeBooleanValue, 3);
     rb_define_method(cClient, "write_bool", rb_writeBooleanValue, 3);
-    
+
     rb_define_method(cClient, "multi_write_int16", rb_writeInt16Values, 3);
+    rb_define_method(cClient, "multi_write_uint16", rb_writeUInt16Values, 3);
     rb_define_method(cClient, "multi_write_int32", rb_writeInt32Values, 3);
+    rb_define_method(cClient, "multi_write_uint32", rb_writeUInt32Values, 3);
     rb_define_method(cClient, "multi_write_float", rb_writeFloatValues, 3);
     rb_define_method(cClient, "multi_write_boolean", rb_writeBooleanValues, 3);
     rb_define_method(cClient, "multi_write_bool", rb_writeBooleanValues, 3);
-    
+
+    rb_define_method(cClient, "multi_read", rb_readUaValues, 2);
+
     rb_define_method(cClient, "create_subscription", rb_createSubscription, 0);
     rb_define_method(cClient, "add_monitored_item", rb_addMonitoredItem, 3);
 

data/lib/opcua_client/version.rb

@@ -1,3 +1,3 @@
 module OPCUAClient
-  VERSION = "0.0.2".freeze
+  VERSION = "0.0.5".freeze
 end

data/spec/core_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+RSpec.describe OPCUAClient::Client do
+  context "unconnected" do
+    it "allows disconnect for unconnected clients" do
+      result = new_client(connect: false).disconnect
+      expect(result).to eq(0)
+    end
+
+    it "returns 0 state" do
+      state = new_client(connect: false).state
+      expect(state).to eq(0)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,22 @@
+require 'rspec'
+require 'opcua_client'
+
+# https://github.com/brianmario/mysql2/commit/0ee20536501848a354f1c3a007333167120c7457
+if GC.respond_to?(:verify_compaction_references)
+  # This method was added in Ruby 3.0.0. Calling it this way asks the GC to
+  # move objects around, helping to find object movement bugs.
+  GC.verify_compaction_references(double_heap: true, toward: :empty)
+end
+
+def new_client(connect: true)
+  client = OPCUAClient::Client.new
+
+  if connect
+    # TODO
+  end
+
+  client
+end
+
+RSpec.configure do |config|
+end

metadata

@@ -1,16 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: opcua_client
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.5
 platform: ruby
 authors:
 - Ritvars Rundzans
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-02-04 00:00:00.000000000 Z
+date: 2022-08-25 00:00:00.000000000 Z
 dependencies: []
-description: 
+description:
 email:
 - ritvars.rundzans@makit.lv
 executables: []
@@ -26,11 +26,13 @@ files:
 - lib/opcua_client.rb
 - lib/opcua_client/client.rb
 - lib/opcua_client/version.rb
+- spec/core_spec.rb
+- spec/spec_helper.rb
 homepage: https://github.com/mak-it/opcua-client-ruby
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options:
 - "--charset=UTF-8"
 require_paths:
@@ -46,10 +48,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.9
-signing_key: 
+rubygems_version: 3.3.7
+signing_key:
 specification_version: 4
 summary: Basic OPC-UA client library for Ruby. Uses open62541 (https://open62541.org)
   under the hood.
-test_files: []
+test_files:
+- spec/core_spec.rb
+- spec/spec_helper.rb