Merge pull request #2313 from fengzeroz/v2.10

version: 2.10.1

.github/workflows/ci.yml

@@ -8,7 +8,7 @@ on:
       - published
 
 env:
-  VERSION: 2.10.0
+  VERSION: 2.10.1
   UI_VERSION: 2.6.1
   BRANCH: v2.10
 

include/neuron/define.h

@@ -24,7 +24,7 @@
 
 #define NEU_VERSION_MAJOR 2
 #define NEU_VERSION_MINOR 10
-#define NEU_VERSION_FIX 0
+#define NEU_VERSION_FIX 1
 
 #define NEU_GET_VERSION_MAJOR(V) ((0xffff0000 & V) >> 16)
 #define NEU_GET_VERSION_MINOR(V) ((0x0000ff00 & V) >> 8)

include/neuron/errcodes.h

@@ -83,6 +83,7 @@ typedef enum {
     NEU_ERR_TAG_DESCRIPTION_TOO_LONG   = 2208,
     NEU_ERR_TAG_PRECISION_INVALID      = 2209,
     NEU_ERR_TAG_EXIST                  = 2210,
+    NEU_ERR_TAG_DECIMAL_INVALID        = 2211,
     NEU_ERR_TAG_BIAS_INVALID           = 2212,
 
     NEU_ERR_LIBRARY_NOT_FOUND                 = 2301,

include/neuron/json/json.h

@@ -37,24 +37,94 @@ typedef enum neu_json_type {
     NEU_JSON_FLOAT,
     NEU_JSON_BOOL,
     NEU_JSON_OBJECT,
-    NEU_JSON_BYTES,
+    NEU_JSON_ARRAY_INT8,
+    NEU_JSON_ARRAY_UINT8,
+    NEU_JSON_ARRAY_INT16,
+    NEU_JSON_ARRAY_UINT16,
+    NEU_JSON_ARRAY_INT32,
+    NEU_JSON_ARRAY_UINT32,
+    NEU_JSON_ARRAY_INT64,
+    NEU_JSON_ARRAY_UINT64,
+    NEU_JSON_ARRAY_FLOAT,
+    NEU_JSON_ARRAY_DOUBLE,
+    NEU_JSON_ARRAY_BOOL,
     NEU_JSON_VALUE = NEU_JSON_UNDEFINE
 } neu_json_type_e;
 
 typedef struct {
-    uint8_t *bytes;
+    int8_t *i8s;
+    uint8_t length;
+} neu_json_value_array_int8_t;
+
+typedef struct {
+    uint8_t *u8s;
     uint8_t  length;
-} neu_json_value_bytes_t;
+} neu_json_value_array_uint8_t;
+
+typedef struct {
+    int16_t *i16s;
+    uint8_t  length;
+} neu_json_value_array_int16_t;
+
+typedef struct {
+    uint16_t *u16s;
+    uint8_t   length;
+} neu_json_value_array_uint16_t;
+
+typedef struct {
+    int32_t *i32s;
+    uint8_t  length;
+} neu_json_value_array_int32_t;
+
+typedef struct {
+    uint32_t *u32s;
+    uint8_t   length;
+} neu_json_value_array_uint32_t;
+
+typedef struct {
+    int64_t *i64s;
+    uint8_t  length;
+} neu_json_value_array_int64_t;
+
+typedef struct {
+    uint64_t *u64s;
+    uint8_t   length;
+} neu_json_value_array_uint64_t;
+
+typedef struct {
+    float * f32s;
+    uint8_t length;
+} neu_json_value_array_float_t;
+
+typedef struct {
+    double *f64s;
+    uint8_t length;
+} neu_json_value_array_double_t;
+
+typedef struct {
+    bool *  bools;
+    uint8_t length;
+} neu_json_value_array_bool_t;
 
 typedef union neu_json_value {
-    int64_t                val_int;
-    uint8_t                val_bit;
-    float                  val_float;
-    double                 val_double;
-    bool                   val_bool;
-    char *                 val_str;
-    void *                 val_object;
-    neu_json_value_bytes_t val_bytes;
+    int64_t                       val_int;
+    uint8_t                       val_bit;
+    float                         val_float;
+    double                        val_double;
+    bool                          val_bool;
+    char *                        val_str;
+    void *                        val_object;
+    neu_json_value_array_int8_t   val_array_int8;
+    neu_json_value_array_uint8_t  val_array_uint8;
+    neu_json_value_array_int16_t  val_array_int16;
+    neu_json_value_array_uint16_t val_array_uint16;
+    neu_json_value_array_int32_t  val_array_int32;
+    neu_json_value_array_uint32_t val_array_uint32;
+    neu_json_value_array_int64_t  val_array_int64;
+    neu_json_value_array_uint64_t val_array_uint64;
+    neu_json_value_array_float_t  val_array_float;
+    neu_json_value_array_double_t val_array_double;
+    neu_json_value_array_bool_t   val_array_bool;
 } neu_json_value_u;
 
 typedef enum neu_json_attribute {

include/neuron/msg.h

@@ -962,6 +962,7 @@ static inline void neu_tag_value_to_json(neu_resp_tag_value_meta_t *tag_value,
     case NEU_TYPE_STRING:
     case NEU_TYPE_TIME:
     case NEU_TYPE_DATA_AND_TIME:
+    case NEU_TYPE_ARRAY_CHAR:
         tag_json->t             = NEU_JSON_STR;
         tag_json->value.val_str = tag_value->value.value.str;
         break;
@@ -970,9 +971,82 @@ static inline void neu_tag_value_to_json(neu_resp_tag_value_meta_t *tag_value,
         tag_json->value.val_str = (char *) tag_value->value.value.ptr.ptr;
         break;
     case NEU_TYPE_BYTES:
-        tag_json->t                      = NEU_JSON_BYTES;
-        tag_json->value.val_bytes.length = tag_value->value.value.bytes.length;
-        tag_json->value.val_bytes.bytes  = tag_value->value.value.bytes.bytes;
+        tag_json->t = NEU_JSON_ARRAY_UINT8;
+        tag_json->value.val_array_uint8.length =
+            tag_value->value.value.bytes.length;
+        tag_json->value.val_array_uint8.u8s =
+            tag_value->value.value.bytes.bytes;
+        break;
+    case NEU_TYPE_ARRAY_BOOL:
+        tag_json->t = NEU_JSON_ARRAY_BOOL;
+        tag_json->value.val_array_bool.length =
+            tag_value->value.value.bools.length;
+        tag_json->value.val_array_bool.bools =
+            tag_value->value.value.bools.bools;
+        break;
+    case NEU_TYPE_ARRAY_INT8:
+        tag_json->t = NEU_JSON_ARRAY_INT8;
+        tag_json->value.val_array_int8.length =
+            tag_value->value.value.i8s.length;
+        tag_json->value.val_array_int8.i8s = tag_value->value.value.i8s.i8s;
+        break;
+    case NEU_TYPE_ARRAY_UINT8:
+        tag_json->t = NEU_JSON_ARRAY_UINT8;
+        tag_json->value.val_array_uint8.length =
+            tag_value->value.value.u8s.length;
+        tag_json->value.val_array_uint8.u8s = tag_value->value.value.u8s.u8s;
+        break;
+    case NEU_TYPE_ARRAY_INT16:
+        tag_json->t = NEU_JSON_ARRAY_INT16;
+        tag_json->value.val_array_int16.length =
+            tag_value->value.value.i16s.length;
+        tag_json->value.val_array_int16.i16s = tag_value->value.value.i16s.i16s;
+        break;
+    case NEU_TYPE_ARRAY_UINT16:
+        tag_json->t = NEU_JSON_ARRAY_UINT16;
+        tag_json->value.val_array_uint16.length =
+            tag_value->value.value.u16s.length;
+        tag_json->value.val_array_uint16.u16s =
+            tag_value->value.value.u16s.u16s;
+        break;
+    case NEU_TYPE_ARRAY_INT32:
+        tag_json->t = NEU_JSON_ARRAY_INT32;
+        tag_json->value.val_array_int32.length =
+            tag_value->value.value.i32s.length;
+        tag_json->value.val_array_int32.i32s = tag_value->value.value.i32s.i32s;
+        break;
+    case NEU_TYPE_ARRAY_UINT32:
+        tag_json->t = NEU_JSON_ARRAY_UINT32;
+        tag_json->value.val_array_uint32.length =
+            tag_value->value.value.u32s.length;
+        tag_json->value.val_array_uint32.u32s =
+            tag_value->value.value.u32s.u32s;
+        break;
+    case NEU_TYPE_ARRAY_INT64:
+        tag_json->t = NEU_JSON_ARRAY_INT64;
+        tag_json->value.val_array_int64.length =
+            tag_value->value.value.i64s.length;
+        tag_json->value.val_array_int64.i64s = tag_value->value.value.i64s.i64s;
+        break;
+    case NEU_TYPE_ARRAY_UINT64:
+        tag_json->t = NEU_JSON_ARRAY_UINT64;
+        tag_json->value.val_array_uint64.length =
+            tag_value->value.value.u64s.length;
+        tag_json->value.val_array_uint64.u64s =
+            tag_value->value.value.u64s.u64s;
+        break;
+    case NEU_TYPE_ARRAY_FLOAT:
+        tag_json->t = NEU_JSON_ARRAY_FLOAT;
+        tag_json->value.val_array_float.length =
+            tag_value->value.value.f32s.length;
+        tag_json->value.val_array_float.f32s = tag_value->value.value.f32s.f32s;
+        break;
+    case NEU_TYPE_ARRAY_DOUBLE:
+        tag_json->t = NEU_JSON_ARRAY_DOUBLE;
+        tag_json->value.val_array_double.length =
+            tag_value->value.value.f64s.length;
+        tag_json->value.val_array_double.f64s =
+            tag_value->value.value.f64s.f64s;
         break;
     default:
         break;
@@ -1086,6 +1160,7 @@ neu_tag_value_to_json_paginate(neu_resp_tag_value_meta_paginate_t *tag_value,
     case NEU_TYPE_STRING:
     case NEU_TYPE_TIME:
     case NEU_TYPE_DATA_AND_TIME:
+    case NEU_TYPE_ARRAY_CHAR:
         tag_json->t             = NEU_JSON_STR;
         tag_json->value.val_str = tag_value->value.value.str;
         break;
@@ -1094,9 +1169,82 @@ neu_tag_value_to_json_paginate(neu_resp_tag_value_meta_paginate_t *tag_value,
         tag_json->value.val_str = (char *) tag_value->value.value.ptr.ptr;
         break;
     case NEU_TYPE_BYTES:
-        tag_json->t                      = NEU_JSON_BYTES;
-        tag_json->value.val_bytes.length = tag_value->value.value.bytes.length;
-        tag_json->value.val_bytes.bytes  = tag_value->value.value.bytes.bytes;
+        tag_json->t = NEU_JSON_ARRAY_UINT8;
+        tag_json->value.val_array_uint8.length =
+            tag_value->value.value.bytes.length;
+        tag_json->value.val_array_uint8.u8s =
+            tag_value->value.value.bytes.bytes;
+        break;
+    case NEU_TYPE_ARRAY_BOOL:
+        tag_json->t = NEU_JSON_ARRAY_BOOL;
+        tag_json->value.val_array_bool.length =
+            tag_value->value.value.bools.length;
+        tag_json->value.val_array_bool.bools =
+            tag_value->value.value.bools.bools;
+        break;
+    case NEU_TYPE_ARRAY_INT8:
+        tag_json->t = NEU_JSON_ARRAY_INT8;
+        tag_json->value.val_array_int8.length =
+            tag_value->value.value.i8s.length;
+        tag_json->value.val_array_int8.i8s = tag_value->value.value.i8s.i8s;
+        break;
+    case NEU_TYPE_ARRAY_UINT8:
+        tag_json->t = NEU_JSON_ARRAY_UINT8;
+        tag_json->value.val_array_uint8.length =
+            tag_value->value.value.u8s.length;
+        tag_json->value.val_array_uint8.u8s = tag_value->value.value.u8s.u8s;
+        break;
+    case NEU_TYPE_ARRAY_INT16:
+        tag_json->t = NEU_JSON_ARRAY_INT16;
+        tag_json->value.val_array_int16.length =
+            tag_value->value.value.i16s.length;
+        tag_json->value.val_array_int16.i16s = tag_value->value.value.i16s.i16s;
+        break;
+    case NEU_TYPE_ARRAY_UINT16:
+        tag_json->t = NEU_JSON_ARRAY_UINT16;
+        tag_json->value.val_array_uint16.length =
+            tag_value->value.value.u16s.length;
+        tag_json->value.val_array_uint16.u16s =
+            tag_value->value.value.u16s.u16s;
+        break;
+    case NEU_TYPE_ARRAY_INT32:
+        tag_json->t = NEU_JSON_ARRAY_INT32;
+        tag_json->value.val_array_int32.length =
+            tag_value->value.value.i32s.length;
+        tag_json->value.val_array_int32.i32s = tag_value->value.value.i32s.i32s;
+        break;
+    case NEU_TYPE_ARRAY_UINT32:
+        tag_json->t = NEU_JSON_ARRAY_UINT32;
+        tag_json->value.val_array_uint32.length =
+            tag_value->value.value.u32s.length;
+        tag_json->value.val_array_uint32.u32s =
+            tag_value->value.value.u32s.u32s;
+        break;
+    case NEU_TYPE_ARRAY_INT64:
+        tag_json->t = NEU_JSON_ARRAY_INT64;
+        tag_json->value.val_array_int64.length =
+            tag_value->value.value.i64s.length;
+        tag_json->value.val_array_int64.i64s = tag_value->value.value.i64s.i64s;
+        break;
+    case NEU_TYPE_ARRAY_UINT64:
+        tag_json->t = NEU_JSON_ARRAY_UINT64;
+        tag_json->value.val_array_uint64.length =
+            tag_value->value.value.u64s.length;
+        tag_json->value.val_array_uint64.u64s =
+            tag_value->value.value.u64s.u64s;
+        break;
+    case NEU_TYPE_ARRAY_FLOAT:
+        tag_json->t = NEU_JSON_ARRAY_FLOAT;
+        tag_json->value.val_array_float.length =
+            tag_value->value.value.f32s.length;
+        tag_json->value.val_array_float.f32s = tag_value->value.value.f32s.f32s;
+        break;
+    case NEU_TYPE_ARRAY_DOUBLE:
+        tag_json->t = NEU_JSON_ARRAY_DOUBLE;
+        tag_json->value.val_array_double.length =
+            tag_value->value.value.f64s.length;
+        tag_json->value.val_array_double.f64s =
+            tag_value->value.value.f64s.f64s;
         break;
     default:
         break;

include/neuron/type.h

@@ -52,6 +52,18 @@ typedef enum {
     NEU_TYPE_PTR           = 19,
     NEU_TYPE_TIME          = 20,
     NEU_TYPE_DATA_AND_TIME = 21,
+    NEU_TYPE_ARRAY_CHAR    = 22,
+    NEU_TYPE_ARRAY_INT8    = 23,
+    NEU_TYPE_ARRAY_UINT8   = 24,
+    NEU_TYPE_ARRAY_INT16   = 25,
+    NEU_TYPE_ARRAY_UINT16  = 26,
+    NEU_TYPE_ARRAY_INT32   = 27,
+    NEU_TYPE_ARRAY_UINT32  = 28,
+    NEU_TYPE_ARRAY_INT64   = 29,
+    NEU_TYPE_ARRAY_UINT64  = 30,
+    NEU_TYPE_ARRAY_FLOAT   = 31,
+    NEU_TYPE_ARRAY_DOUBLE  = 32,
+    NEU_TYPE_ARRAY_BOOL    = 33,
 } neu_type_e;
 
 inline static const char *neu_type_string(neu_type_e type)
@@ -99,6 +111,30 @@ inline static const char *neu_type_string(neu_type_e type)
         return "NEU_TYPE_TIME";
     case NEU_TYPE_DATA_AND_TIME:
         return "NEU_TYPE_DATA_AND_TIME";
+    case NEU_TYPE_ARRAY_CHAR:
+        return "NEU_TYPE_ARRAY_CHAR";
+    case NEU_TYPE_ARRAY_INT8:
+        return "NEU_TYPE_ARRAY_INT8";
+    case NEU_TYPE_ARRAY_UINT8:
+        return "NEU_TYPE_ARRAY_UINT8";
+    case NEU_TYPE_ARRAY_INT16:
+        return "NEU_TYPE_ARRAY_INT16";
+    case NEU_TYPE_ARRAY_UINT16:
+        return "NEU_TYPE_ARRAY_UINT16";
+    case NEU_TYPE_ARRAY_INT32:
+        return "NEU_TYPE_ARRAY_INT32";
+    case NEU_TYPE_ARRAY_UINT32:
+        return "NEU_TYPE_ARRAY_UINT32";
+    case NEU_TYPE_ARRAY_INT64:
+        return "NEU_TYPE_ARRAY_INT64";
+    case NEU_TYPE_ARRAY_UINT64:
+        return "NEU_TYPE_ARRAY_UINT64";
+    case NEU_TYPE_ARRAY_FLOAT:
+        return "NEU_TYPE_ARRAY_FLOAT";
+    case NEU_TYPE_ARRAY_DOUBLE:
+        return "NEU_TYPE_ARRAY_FLOAT";
+    case NEU_TYPE_ARRAY_BOOL:
+        return "NEU_TYPE_ARRAY_BOOL";
     }
 
     return "";
@@ -115,23 +151,89 @@ typedef struct {
 typedef struct {
     uint8_t bytes[NEU_VALUE_SIZE];
     uint8_t length;
-} __attribute__((packed)) neu_value_bytes_t;
+} neu_value_bytes_t;
+
+typedef struct {
+    int8_t  i8s[NEU_VALUE_SIZE];
+    uint8_t length;
+} neu_value_array_int8_t;
+
+typedef struct {
+    uint8_t u8s[NEU_VALUE_SIZE];
+    uint8_t length;
+} neu_value_array_uint8_t;
+
+typedef struct {
+    int16_t i16s[NEU_VALUE_SIZE];
+    uint8_t length;
+} neu_value_array_int16_t;
+
+typedef struct {
+    uint16_t u16s[NEU_VALUE_SIZE];
+    uint8_t  length;
+} neu_value_array_uint16_t;
+
+typedef struct {
+    int32_t i32s[NEU_VALUE_SIZE];
+    uint8_t length;
+} neu_value_array_int32_t;
+
+typedef struct {
+    uint32_t u32s[NEU_VALUE_SIZE];
+    uint8_t  length;
+} neu_value_array_uint32_t;
+
+typedef struct {
+    int64_t i64s[NEU_VALUE_SIZE];
+    uint8_t length;
+} neu_value_array_int64_t;
+
+typedef struct {
+    uint64_t u64s[NEU_VALUE_SIZE];
+    uint8_t  length;
+} neu_value_array_uint64_t;
+
+typedef struct {
+    float   f32s[NEU_VALUE_SIZE];
+    uint8_t length;
+} neu_value_array_float_t;
+
+typedef struct {
+    double  f64s[NEU_VALUE_SIZE];
+    uint8_t length;
+} neu_value_array_double_t;
+
+typedef struct {
+    bool    bools[NEU_VALUE_SIZE];
+    uint8_t length;
+} neu_value_array_bool_t;
 
 typedef union {
-    bool              boolean;
-    int8_t            i8;
-    uint8_t           u8;
-    int16_t           i16;
-    uint16_t          u16;
-    int32_t           i32;
-    uint32_t          u32;
-    int64_t           i64;
-    uint64_t          u64;
-    float             f32;
-    double            d64;
-    char              str[NEU_VALUE_SIZE];
-    neu_value_bytes_t bytes;
-    neu_value_ptr_t   ptr;
+    bool                     boolean;
+    int8_t                   i8;
+    uint8_t                  u8;
+    int16_t                  i16;
+    uint16_t                 u16;
+    int32_t                  i32;
+    uint32_t                 u32;
+    int64_t                  i64;
+    uint64_t                 u64;
+    float                    f32;
+    double                   d64;
+    char                     str[NEU_VALUE_SIZE];
+    neu_value_bytes_t        bytes;
+    neu_value_ptr_t          ptr;
+    neu_value_array_int8_t   i8s;
+    neu_value_array_uint8_t  u8s;
+    neu_value_array_int16_t  i16s;
+    neu_value_array_uint16_t u16s;
+    neu_value_array_int32_t  i32s;
+    neu_value_array_uint32_t u32s;
+    neu_value_array_int64_t  i64s;
+    neu_value_array_uint64_t u64s;
+    neu_value_array_float_t  f32s;
+    neu_value_array_double_t f64s;
+    neu_value_array_bool_t   bools;
 } neu_value_u;
 
 static inline char *neu_value_str(neu_type_e type, neu_value_u value)

persistence/0100_2.10.0_tag_type.sql

@@ -0,0 +1,25 @@
+BEGIN TRANSACTION;
+
+ALTER TABLE tags RENAME TO temp_tags;
+
+-- add bias column
+CREATE TABLE
+  IF NOT EXISTS tags (
+    driver_name TEXT NOT NULL,
+    group_name TEXT NOT NULL,
+    name TEXT NULL check (length (name) <= 128),
+    address TEXT NULL check (length (address) <= 128),
+    attribute INTEGER NOT NULL check (attribute BETWEEN 0 AND 15),
+    precision INTEGER NOT NULL check (precision BETWEEN 0 AND 17),
+    decimal REAL NOT NULL,
+    bias REAL NOT NULL check (bias BETWEEN -1000 AND 1000),
+    type INTEGER NOT NULL check (type BETWEEN 0 AND 40),
+    description TEXT NULL check (length (description) <= 512),
+    value TEXT,
+    UNIQUE (driver_name, group_name, name),
+    FOREIGN KEY (driver_name, group_name) REFERENCES groups (driver_name, name) ON UPDATE CASCADE ON DELETE CASCADE
+  );
+
+INSERT INTO tags SELECT * FROM temp_tags;
+DROP TABLE temp_tags;
+COMMIT;

plugins/ekuiper/read_write.c

@@ -269,11 +269,26 @@ static int json_value_to_tag_value(union neu_json_value *req,
         value->type          = NEU_TYPE_BOOL;
         value->value.boolean = req->val_bool;
         break;
-    case NEU_JSON_BYTES:
-        value->type               = NEU_TYPE_BYTES;
-        value->value.bytes.length = req->val_bytes.length;
-        memcpy(value->value.bytes.bytes, req->val_bytes.bytes,
-               req->val_bytes.length);
+    case NEU_JSON_ARRAY_BOOL:
+        value->type               = NEU_TYPE_ARRAY_BOOL;
+        value->value.bools.length = req->val_array_bool.length;
+        for (int i = 0; i < req->val_array_bool.length; i++) {
+            value->value.bools.bools[i] = req->val_array_bool.bools[i];
+        }
+        break;
+    case NEU_JSON_ARRAY_INT64:
+        value->type              = NEU_TYPE_ARRAY_INT64;
+        value->value.i64s.length = req->val_array_int64.length;
+        for (int i = 0; i < req->val_array_int64.length; i++) {
+            value->value.i64s.i64s[i] = req->val_array_int64.i64s[i];
+        }
+        break;
+    case NEU_JSON_ARRAY_DOUBLE:
+        value->type              = NEU_TYPE_ARRAY_DOUBLE;
+        value->value.f64s.length = req->val_array_double.length;
+        for (int i = 0; i < req->val_array_double.length; i++) {
+            value->value.f64s.f64s[i] = req->val_array_double.f64s[i];
+        }
         break;
     default:
         return -1;

plugins/modbus/modbus_req.c

@@ -147,7 +147,7 @@ void handle_modbus_error(neu_plugin_t *plugin, struct modbus_group_data *gd,
                          const char *error_message)
 {
     modbus_value_handle(plugin, gd->cmd_sort->cmd[cmd_index].slave_id, 0, NULL,
-                        error_code);
+                        error_code, NULL);
     if (error_message) {
         plog_error(plugin, "%s, skip, %hhu!%hu", error_message,
                    gd->cmd_sort->cmd[cmd_index].slave_id,
@@ -372,7 +372,7 @@ int modbus_group_timer(neu_plugin_t *plugin, neu_plugin_group_t *group,
 }
 
 int modbus_value_handle(void *ctx, uint8_t slave_id, uint16_t n_byte,
-                        uint8_t *bytes, int error)
+                        uint8_t *bytes, int error, void *trace)
 {
     neu_plugin_t *            plugin = (neu_plugin_t *) ctx;
     struct modbus_group_data *gd =
@@ -498,8 +498,14 @@ int modbus_value_handle(void *ctx, uint8_t slave_id, uint16_t n_byte,
             }
         }
 
-        plugin->common.adapter_callbacks->driver.update(
-            plugin->common.adapter, gd->group, (*p_tag)->name, dvalue);
+        if (trace) {
+            plugin->common.adapter_callbacks->driver.update_with_trace(
+                plugin->common.adapter, gd->group, (*p_tag)->name, dvalue, NULL,
+                0, trace);
+        } else {
+            plugin->common.adapter_callbacks->driver.update(
+                plugin->common.adapter, gd->group, (*p_tag)->name, dvalue);
+        }
     }
     return 0;
 }
@@ -511,15 +517,13 @@ int modbus_value_handle_test(neu_plugin_t *plugin, void *req,
     (void) req;
     neu_json_value_u jvalue = { 0 };
     neu_json_type_e  jtype;
+    uint8_t          recv_bytes[256] = { 0 };
 
     switch (point->area) {
     case MODBUS_AREA_HOLD_REGISTER:
     case MODBUS_AREA_INPUT_REGISTER:
         if (n_byte >= point->n_register * 2) {
-            jvalue.val_bytes.bytes =
-                (uint8_t *) malloc(point->n_register * 2 + 1);
-            memcpy(jvalue.val_bytes.bytes, bytes, point->n_register * 2);
-            jvalue.val_bytes.length = point->n_register * 2;
+            memcpy(recv_bytes, bytes, point->n_register * 2);
         }
         break;
     case MODBUS_AREA_COIL:
@@ -533,23 +537,20 @@ int modbus_value_handle_test(neu_plugin_t *plugin, void *req,
     case NEU_TYPE_UINT16: {
         jtype = NEU_JSON_INT;
         uint16_t tmp_val16;
-        memcpy(&tmp_val16, jvalue.val_bytes.bytes, sizeof(uint16_t));
-        free(jvalue.val_bytes.bytes);
+        memcpy(&tmp_val16, recv_bytes, sizeof(uint16_t));
         jvalue.val_int = ntohs(tmp_val16);
         break;
     }
     case NEU_TYPE_INT16: {
         jtype = NEU_JSON_INT;
         int16_t tmp_val16;
-        memcpy(&tmp_val16, jvalue.val_bytes.bytes, sizeof(int16_t));
-        free(jvalue.val_bytes.bytes);
+        memcpy(&tmp_val16, recv_bytes, sizeof(int16_t));
         jvalue.val_int = (int16_t) ntohs(tmp_val16);
         break;
     }
     case NEU_TYPE_FLOAT: {
         uint32_t tmp_valf;
-        memcpy(&tmp_valf, jvalue.val_bytes.bytes, sizeof(uint32_t));
-        free(jvalue.val_bytes.bytes);
+        memcpy(&tmp_valf, recv_bytes, sizeof(uint32_t));
         jtype          = NEU_JSON_FLOAT;
         jvalue.val_int = ntohl(tmp_valf);
         break;
@@ -557,23 +558,20 @@ int modbus_value_handle_test(neu_plugin_t *plugin, void *req,
     case NEU_TYPE_INT32: {
         jtype = NEU_JSON_INT;
         int32_t tmp_val32;
-        memcpy(&tmp_val32, jvalue.val_bytes.bytes, sizeof(int32_t));
-        free(jvalue.val_bytes.bytes);
+        memcpy(&tmp_val32, recv_bytes, sizeof(int32_t));
         jvalue.val_int = (int32_t) ntohl(tmp_val32);
         break;
     }
     case NEU_TYPE_UINT32: {
         jtype = NEU_JSON_INT;
         uint32_t tmp_val32;
-        memcpy(&tmp_val32, jvalue.val_bytes.bytes, sizeof(uint32_t));
-        free(jvalue.val_bytes.bytes);
+        memcpy(&tmp_val32, recv_bytes, sizeof(uint32_t));
         jvalue.val_int = ntohl(tmp_val32);
         break;
     }
     case NEU_TYPE_DOUBLE: {
         uint64_t tmp_vald;
-        memcpy(&tmp_vald, jvalue.val_bytes.bytes, sizeof(uint64_t));
-        free(jvalue.val_bytes.bytes);
+        memcpy(&tmp_vald, recv_bytes, sizeof(uint64_t));
         jtype          = NEU_JSON_DOUBLE;
         jvalue.val_int = neu_ntohll(tmp_vald);
         break;
@@ -581,16 +579,14 @@ int modbus_value_handle_test(neu_plugin_t *plugin, void *req,
     case NEU_TYPE_INT64: {
         jtype = NEU_JSON_INT;
         int64_t tmp_val64;
-        memcpy(&tmp_val64, jvalue.val_bytes.bytes, sizeof(int64_t));
-        free(jvalue.val_bytes.bytes);
+        memcpy(&tmp_val64, recv_bytes, sizeof(int64_t));
         jvalue.val_int = (int64_t) neu_ntohll(tmp_val64);
         break;
     }
     case NEU_TYPE_UINT64: {
         jtype = NEU_JSON_INT;
         uint64_t tmp_val64;
-        memcpy(&tmp_val64, jvalue.val_bytes.bytes, sizeof(uint64_t));
-        free(jvalue.val_bytes.bytes);
+        memcpy(&tmp_val64, recv_bytes, sizeof(uint64_t));
         jvalue.val_int = neu_ntohll(tmp_val64);
         break;
     }
@@ -600,9 +596,8 @@ int modbus_value_handle_test(neu_plugin_t *plugin, void *req,
         case MODBUS_AREA_INPUT_REGISTER: {
             jtype             = NEU_JSON_BIT;
             neu_value16_u v16 = { 0 };
-            v16.value         = htons(*(uint16_t *) jvalue.val_bytes.bytes);
-            free(jvalue.val_bytes.bytes);
-            jvalue.val_bit = neu_value16_get_bit(v16, point->option.bit.bit);
+            v16.value         = htons(*(uint16_t *) recv_bytes);
+            jvalue.val_bit    = neu_value16_get_bit(v16, point->option.bit.bit);
             break;
         }
         case MODBUS_AREA_COIL:
@@ -613,10 +608,10 @@ int modbus_value_handle_test(neu_plugin_t *plugin, void *req,
         break;
     }
     case NEU_TYPE_STRING: {
-        jtype                      = NEU_JSON_STR;
-        size_t str_length          = point->n_register * 2;
-        jvalue.val_str             = (char *) jvalue.val_bytes.bytes;
-        jvalue.val_str[str_length] = '\0';
+        jtype             = NEU_JSON_STR;
+        size_t str_length = point->n_register * 2;
+        jvalue.val_str    = calloc(1, str_length + 1);
+        strncpy(jvalue.val_str, (char *) recv_bytes, str_length);
 
         switch (point->option.string.type) {
         case NEU_DATATAG_STRING_TYPE_H:

plugins/modbus/modbus_req.h

@@ -62,7 +62,7 @@ int modbus_group_timer(neu_plugin_t *plugin, neu_plugin_group_t *group,
                        uint16_t max_byte);
 int modbus_send_msg(void *ctx, uint16_t n_byte, uint8_t *bytes);
 int modbus_value_handle(void *ctx, uint8_t slave_id, uint16_t n_byte,
-                        uint8_t *bytes, int error);
+                        uint8_t *bytes, int error, void *trace);
 int modbus_write(neu_plugin_t *plugin, void *req, neu_datatag_t *tag,
                  neu_value_u value, bool response);
 int modbus_write_tag(neu_plugin_t *plugin, void *req, neu_datatag_t *tag,

plugins/modbus/modbus_stack.c

@@ -23,6 +23,8 @@
 #include "modbus_req.h"
 #include "modbus_stack.h"
 
+#include "otel/otel_manager.h"
+
 struct modbus_stack {
     void *                  ctx;
     modbus_stack_send       send_fn;
@@ -35,6 +37,8 @@ struct modbus_stack {
 
     uint8_t *buf;
     uint16_t buf_size;
+
+    int64_t sample_mod;
 };
 
 modbus_stack_t *modbus_stack_create(void *ctx, modbus_protocol_e protocol,
@@ -65,9 +69,10 @@ void modbus_stack_destroy(modbus_stack_t *stack)
 int modbus_stack_recv(modbus_stack_t *stack, uint8_t slave_id,
                       neu_protocol_unpack_buf_t *buf)
 {
-    struct modbus_header header = { 0 };
-    struct modbus_code   code   = { 0 };
-    int                  ret    = 0;
+    struct modbus_header header   = { 0 };
+    struct modbus_code   code     = { 0 };
+    int                  ret      = 0;
+    int64_t              ts_start = neu_time_ns();
 
     if (stack->protocol == MODBUS_PROTOCOL_TCP) {
         ret = modbus_header_unwrap(buf, &header);
@@ -99,6 +104,22 @@ int modbus_stack_recv(modbus_stack_t *stack, uint8_t slave_id,
     case MODBUS_READ_INPUT:
     case MODBUS_READ_HOLD_REG:
     case MODBUS_READ_INPUT_REG: {
+        neu_otel_trace_ctx trace = NULL;
+        neu_otel_scope_ctx scope = NULL;
+        if (neu_otel_data_is_started()) {
+            trace = neu_otel_find_trace((void *) (intptr_t) stack->read_seq);
+            if (trace) {
+                char new_span_id[36] = { 0 };
+                neu_otel_new_span_id(new_span_id);
+                scope =
+                    neu_otel_add_span2(trace, "driver cmd recv", new_span_id);
+                neu_otel_scope_add_span_attr_int(scope, "thread id",
+                                                 (int64_t)(pthread_self()));
+                neu_otel_scope_set_span_start_time(scope, ts_start);
+                neu_otel_scope_set_span_end_time(scope, neu_time_ns());
+            }
+        }
+
         struct modbus_data data  = { 0 };
         uint8_t *          bytes = NULL;
         ret                      = modbus_data_unwrap(buf, &data);
@@ -119,14 +140,14 @@ int modbus_stack_recv(modbus_stack_t *stack, uint8_t slave_id,
                 stack->value_fn(stack->ctx, code.slave_id,
                                 header.len - sizeof(struct modbus_code) -
                                     sizeof(struct modbus_data),
-                                bytes, 0);
+                                bytes, 0, (void *) (intptr_t) stack->read_seq);
             } else {
                 bytes = neu_protocol_unpack_buf(buf, data.n_byte);
                 if (bytes == NULL) {
                     return -1;
                 }
                 stack->value_fn(stack->ctx, code.slave_id, data.n_byte, bytes,
-                                0);
+                                0, (void *) (intptr_t) stack->read_seq);
             }
             break;
         case MODBUS_PROTOCOL_RTU:
@@ -134,7 +155,8 @@ int modbus_stack_recv(modbus_stack_t *stack, uint8_t slave_id,
             if (bytes == NULL) {
                 return -1;
             }
-            stack->value_fn(stack->ctx, code.slave_id, data.n_byte, bytes, 0);
+            stack->value_fn(stack->ctx, code.slave_id, data.n_byte, bytes, 0,
+                            (void *) (intptr_t) stack->read_seq);
             break;
         }
 
@@ -287,6 +309,7 @@ int modbus_stack_read(modbus_stack_t *stack, uint8_t slave_id,
     int                                     ret     = 0;
     *response_size                                  = 0;
     modbus_action_e m_action                        = MODBUS_ACTION_DEFAULT;
+    int64_t         ts_start                        = neu_time_ns();
 
     neu_protocol_pack_buf_init(&pbuf, buf, sizeof(buf));
 
@@ -331,11 +354,47 @@ int modbus_stack_read(modbus_stack_t *stack, uint8_t slave_id,
     ret = stack->send_fn(stack->ctx, neu_protocol_pack_buf_used_size(&pbuf),
                          neu_protocol_pack_buf_get(&pbuf));
     if (ret <= 0 && !is_test) {
-        stack->value_fn(stack->ctx, 0, 0, NULL, NEU_ERR_PLUGIN_DISCONNECTED);
+        stack->value_fn(stack->ctx, 0, 0, NULL, NEU_ERR_PLUGIN_DISCONNECTED,
+                        NULL);
         plog_warn((neu_plugin_t *) stack->ctx, "send read req fail, %hhu!%hu",
                   slave_id, start_address);
-    }
+    } else {
+        if (neu_otel_data_is_started()) {
+            double rate        = neu_otel_data_sample_rate();
+            int    sample_rate = 0;
+            if (rate > 0.0 && rate <= 1.0) {
+                sample_rate = (int) (1.0 / rate);
+            }
+            if (sample_rate != 0) {
+                stack->sample_mod += 1;
+                if (stack->sample_mod % sample_rate == 0) {
+                    char new_trace_id[64] = { 0 };
+                    neu_otel_new_trace_id(new_trace_id);
+                    const char *trace_state  = "span.mytype=data-collection";
+                    neu_otel_trace_ctx trace = NULL;
+                    neu_otel_scope_ctx scope = NULL;
+                    trace                    = neu_otel_create_trace(
+                        new_trace_id, (void *) (intptr_t) stack->read_seq, 0,
+                        trace_state);
+                    scope = neu_otel_add_span(trace);
+                    neu_otel_scope_set_span_name(scope, "driver cmd send");
+                    char new_span_id[36] = { 0 };
+                    neu_otel_new_span_id(new_span_id);
+                    neu_otel_scope_set_span_id(scope, new_span_id);
+                    neu_otel_scope_set_span_flags(scope, 0);
+                    neu_otel_scope_set_span_start_time(scope, ts_start);
 
+                    neu_otel_scope_add_span_attr_int(scope, "thread id",
+                                                     (int64_t) pthread_self());
+
+                    neu_otel_scope_add_span_attr_string(
+                        scope, "node",
+                        ((neu_plugin_t *) stack->ctx)->common.name);
+                    neu_otel_scope_set_span_end_time(scope, neu_time_ns());
+                }
+            }
+        }
+    }
     return ret;
 }
 

plugins/modbus/modbus_stack.h

@@ -30,7 +30,7 @@ typedef struct modbus_stack modbus_stack_t;
 
 typedef int (*modbus_stack_send)(void *ctx, uint16_t n_byte, uint8_t *bytes);
 typedef int (*modbus_stack_value)(void *ctx, uint8_t slave_id, uint16_t n_byte,
-                                  uint8_t *bytes, int error);
+                                  uint8_t *bytes, int error, void *trace);
 typedef int (*modbus_stack_write_resp)(void *ctx, void *req, int error);
 
 typedef enum modbus_protocol {

plugins/mqtt/mqtt.json

@@ -1,293 +1,293 @@
 {
-  "version": {
-    "name": "MQTT Version",
-    "name_zh": "MQTT 版本",
-    "type": "map",
-    "attribute": "optional",
-    "default": 4,
-    "valid": {
-      "map": [
-        {
-          "key": "3.1.1",
-          "value": 4
-        },
-        {
-          "key": "5.0",
-          "value": 5
-        }
-      ]
-    }
-  },
-  "client-id": {
-    "name": "Client ID",
-    "name_zh": "客户端 ID",
-    "type": "string",
-    "attribute": "required",
-    "default": "neuron_${random_str}",
-    "valid": {
-      "length": 255
-    }
-  },
-  "qos": {
-    "name": "QoS Level",
-    "name_zh": "QoS 等级",
-    "description": "MQTT QoS level for message delivery",
-    "description_zh": "MQTT 消息传输使用的服务质量等级",
-    "type": "map",
-    "attribute": "optional",
-    "default": 0,
-    "valid": {
-      "map": [
-        {
-          "key": "QoS 0",
-          "value": 0
-        },
-        {
-          "key": "QoS 1",
-          "value": 1
-        },
-        {
-          "key": "QoS 2",
-          "value": 2
-        }
-      ]
-    }
-  },
-  "format": {
-    "name": "Upload Format",
-    "name_zh": "上报数据格式",
-    "description": "JSON format of the data reported. In values-mode, data are split into `values` and `errors` sub objects. In tags-mode, tag data are put in a single array.",
-    "description_zh": "上报数据的 JSON 格式。在 values-format 格式下，数据被分为 `values` 和 `errors` 两个子对象。在 tags-format 格式下，数据被放在一个数组中。",
-    "attribute": "required",
-    "type": "map",
-    "default": 0,
-    "valid": {
-      "map": [
-        {
-          "key": "values-format",
-          "value": 0
-        },
-        {
-          "key": "tags-format",
-          "value": 1
-        }
-      ]
-    }
-  },
-  "write-req-topic": {
-    "name": "Write Request Topic",
-    "name_zh": "写请求主题",
-    "description": "MQTT topic to receive write request messages.",
-    "description_zh": "接收点位写入请求的 MQTT 主题。",
-    "attribute": "required",
-    "type": "string",
-    "default": "/neuron/${random_str}/write/req",
-    "valid": {
-      "length": 255
-    }
-  },
-  "write-resp-topic": {
-    "name": "Write Response Topic",
-    "name_zh": "写响应主题",
-    "description": "MQTT topic to send write response messages.",
-    "description_zh": "发送点位写入响应的 MQTT 主题。",
-    "attribute": "required",
-    "type": "string",
-    "default": "/neuron/${random_str}/write/resp",
-    "valid": {
-      "length": 255
-    }
-  },
-  "upload_drv_state": {
-    "name": "Driver Status Report",
-    "name_zh": "驱动状态上报",
-    "description": "Reports status of all the southbound nodes to the specified topic.",
-    "description_zh": "上报所有南向驱动状态到指定的 MQTT 主题。",
-    "attribute": "optional",
-    "type": "bool",
-    "default": false,
-    "valid": {}
-  },
-  "upload_drv_state_topic": {
-    "name": "Status Report Topic",
-    "name_zh": "状态上报主题",
-    "attribute": "required",
-    "type": "string",
-    "condition": {
-      "field": "upload_drv_state",
-      "value": true
-    },
-    "default": "/neuron/${random_str}/state/update",
-    "valid": {
-      "length": 255
-    }
-  },
-  "upload_drv_state_interval": {
-    "name": "Status Report Interval (Second)",
-    "name_zh": "状态上报间隔（秒）",
-    "attribute": "required",
-    "type": "int",
-    "condition": {
-      "field": "upload_drv_state",
-      "value": true
-    },
-    "default": 1,
-    "valid": {
-      "min": 1,
-      "max": 3600
-    }
-  },
-  "offline-cache": {
-    "name": "Offline Data Caching",
-    "name_zh": "离线缓存",
-    "description": "Offline caching switch. Cache MQTT messages when offline, and sync cached messages when back online.",
-    "description_zh": "离线缓存开关。连接断开时缓存 MQTT 消息，连接重建时同步缓存的 MQTT 消息到服务器。",
-    "attribute": "optional",
-    "type": "bool",
-    "default": false,
-    "valid": {}
-  },
-  "cache-mem-size": {
-    "name": "Cache Memory Size (MB)",
-    "name_zh": "缓存内存大小（MB）",
-    "description": "Max in-memory cache size in megabytes when MQTT connection exception occurs. Should be smaller than cache disk size.",
-    "description_zh": "当 MQTT 连接异常时，最大的内存缓存大小（单位：MB）。应该小于缓存磁盘大小。",
-    "type": "int",
-    "attribute": "required",
-    "condition": {
-      "field": "offline-cache",
-      "value": true
-    },
-    "valid": {
-      "min": 1,
-      "max": 1024
-    }
-  },
-  "cache-disk-size": {
-    "name": "Cache Disk Size (MB)",
-    "name_zh": "缓存磁盘大小（MB）",
-    "description": "Max in-disk cache size in megabytes when MQTT connection exception occurs. Should be larger than cache memory size. If nonzero, cache memory size should also be nonzero.",
-    "description_zh": "当 MQTT 连接异常时，最大的磁盘缓存大小（单位：MB）。应该大于缓存内存大小。如果不为 0，缓存内存大小也应该不为 0。",
-    "type": "int",
-    "attribute": "required",
-    "condition": {
-      "field": "offline-cache",
-      "value": true
-    },
-    "valid": {
-      "min": 1,
-      "max": 10240
-    }
-  },
-  "cache-sync-interval": {
-    "name": "Cache Sync Interval (MS)",
-    "name_zh": "缓存消息重传间隔（MS）",
-    "type": "int",
-    "attribute": "required",
-    "condition": {
-      "field": "offline-cache",
-      "value": true
-    },
-    "default": 100,
-    "valid": {
-      "min": 10,
-      "max": 120000
-    }
-  },
-  "host": {
-    "name": "Broker Host",
-    "name_zh": "服务器地址",
-    "attribute": "required",
-    "type": "string",
-    "default": "broker.emqx.io",
-    "valid": {
-      "length": 255
-    }
-  },
-  "port": {
-    "name": "Broker Port",
-    "name_zh": "服务器端口",
-    "attribute": "required",
-    "type": "int",
-    "default": 1883,
-    "valid": {
-      "min": 1024,
-      "max": 65535
-    }
-  },
-  "username": {
-    "name": "Username",
-    "name_zh": "用户名",
-    "attribute": "optional",
-    "type": "string",
-    "default": "",
-    "valid": {
-      "length": 255
-    }
-  },
-  "password": {
-    "name": "Password",
-    "name_zh": "密码",
-    "attribute": "optional",
-    "type": "string",
-    "default": "",
-    "valid": {
-      "length": 255
-    }
-  },
-  "ssl": {
-    "name": "SSL",
-    "name_zh": "SSL",
-    "description": "Enable SSL connection",
-    "description_zh": "是否启用 SSL 连接",
-    "attribute": "optional",
-    "type": "bool",
-    "default": false,
-    "valid": {}
-  },
-  "ca": {
-    "name": "CA",
-    "name_zh": "CA 证书",
-    "description": "CA certificate which signs the server certificate",
-    "description_zh": "签发服务器证书的 CA 证书",
-    "attribute": "optional",
-    "type": "file",
-    "condition": {
-      "field": "ssl",
-      "value": true
-    },
-    "valid": {
-      "length": 81960
-    }
-  },
-  "cert": {
-    "name": "Client Cert",
-    "name_zh": "客户端证书",
-    "description": "Client x509 certificate when using two way authentication",
-    "description_zh": "使用双向认证时，客户端的 x509 证书",
-    "attribute": "optional",
-    "type": "file",
-    "condition": {
-      "field": "ssl",
-      "value": true
-    },
-    "valid": {
-      "length": 81960
-    }
-  },
-  "key": {
-    "name": "Client Private Key",
-    "name_zh": "客户端私钥",
-    "description": "Client private key when using two way authentication",
-    "description_zh": "使用双向认证时，客户端的私钥",
-    "attribute": "optional",
-    "type": "file",
-    "condition": {
-      "field": "ssl",
-      "value": true
-    },
-    "valid": {
-      "length": 81960
-    }
-  }
-}
+	"version": {
+		"name": "MQTT Version",
+		"name_zh": "MQTT 版本",
+		"type": "map",
+		"attribute": "optional",
+		"default": 4,
+		"valid": {
+			"map": [
+				{
+					"key": "3.1.1",
+					"value": 4
+				},
+				{
+					"key": "5.0",
+					"value": 5
+				}
+			]
+		}
+	},
+	"client-id": {
+		"name": "Client ID",
+		"name_zh": "客户端 ID",
+		"type": "string",
+		"attribute": "required",
+		"default": "neuron_${random_str}",
+		"valid": {
+			"length": 255
+		}
+	},
+	"qos": {
+		"name": "QoS Level",
+		"name_zh": "QoS 等级",
+		"description": "MQTT QoS level for message delivery",
+		"description_zh": "MQTT 消息传输使用的服务质量等级",
+		"type": "map",
+		"attribute": "optional",
+		"default": 0,
+		"valid": {
+			"map": [
+				{
+					"key": "QoS 0",
+					"value": 0
+				},
+				{
+					"key": "QoS 1",
+					"value": 1
+				},
+				{
+					"key": "QoS 2",
+					"value": 2
+				}
+			]
+		}
+	},
+	"format": {
+		"name": "Upload Format",
+		"name_zh": "上报数据格式",
+		"description": "JSON format of the data reported. In values-mode, data are split into `values` and `errors` sub objects. In tags-mode, tag data are put in a single array.",
+		"description_zh": "上报数据的 JSON 格式。在 values-format 格式下，数据被分为 `values` 和 `errors` 两个子对象。在 tags-format 格式下，数据被放在一个数组中。",
+		"attribute": "required",
+		"type": "map",
+		"default": 0,
+		"valid": {
+			"map": [
+				{
+					"key": "values-format",
+					"value": 0
+				},
+				{
+					"key": "tags-format",
+					"value": 1
+				}
+			]
+		}
+	},
+	"write-req-topic": {
+		"name": "Write Request Topic",
+		"name_zh": "写请求主题",
+		"description": "MQTT topic to receive write request messages.",
+		"description_zh": "接收点位写入请求的 MQTT 主题。",
+		"attribute": "required",
+		"type": "string",
+		"default": "/neuron/${random_str}/write/req",
+		"valid": {
+			"length": 255
+		}
+	},
+	"write-resp-topic": {
+		"name": "Write Response Topic",
+		"name_zh": "写响应主题",
+		"description": "MQTT topic to send write response messages.",
+		"description_zh": "发送点位写入响应的 MQTT 主题。",
+		"attribute": "required",
+		"type": "string",
+		"default": "/neuron/${random_str}/write/resp",
+		"valid": {
+			"length": 255
+		}
+	},
+	"upload_drv_state": {
+		"name": "Driver Status Report",
+		"name_zh": "驱动状态上报",
+		"description": "Reports status of all the southbound nodes to the specified topic.",
+		"description_zh": "上报所有南向驱动状态到指定的 MQTT 主题。",
+		"attribute": "optional",
+		"type": "bool",
+		"default": false,
+		"valid": {}
+	},
+	"upload_drv_state_topic": {
+		"name": "Status Report Topic",
+		"name_zh": "状态上报主题",
+		"attribute": "required",
+		"type": "string",
+		"condition": {
+			"field": "upload_drv_state",
+			"value": true
+		},
+		"default": "/neuron/${random_str}/state/update",
+		"valid": {
+			"length": 255
+		}
+	},
+	"upload_drv_state_interval": {
+		"name": "Status Report Interval (Second)",
+		"name_zh": "状态上报间隔（秒）",
+		"attribute": "required",
+		"type": "int",
+		"condition": {
+			"field": "upload_drv_state",
+			"value": true
+		},
+		"default": 1,
+		"valid": {
+			"min": 1,
+			"max": 3600
+		}
+	},
+	"offline-cache": {
+		"name": "Offline Data Caching",
+		"name_zh": "离线缓存",
+		"description": "Offline caching switch. Cache MQTT messages when offline, and sync cached messages when back online.",
+		"description_zh": "离线缓存开关。连接断开时缓存 MQTT 消息，连接重建时同步缓存的 MQTT 消息到服务器。",
+		"attribute": "optional",
+		"type": "bool",
+		"default": false,
+		"valid": {}
+	},
+	"cache-mem-size": {
+		"name": "Cache Memory Size (MB)",
+		"name_zh": "缓存内存大小（MB）",
+		"description": "Max in-memory cache size in megabytes when MQTT connection exception occurs. Should be smaller than cache disk size.",
+		"description_zh": "当 MQTT 连接异常时，最大的内存缓存大小（单位：MB）。应该小于缓存磁盘大小。",
+		"type": "int",
+		"attribute": "required",
+		"condition": {
+			"field": "offline-cache",
+			"value": true
+		},
+		"valid": {
+			"min": 1,
+			"max": 1024
+		}
+	},
+	"cache-disk-size": {
+		"name": "Cache Disk Size (MB)",
+		"name_zh": "缓存磁盘大小（MB）",
+		"description": "Max in-disk cache size in megabytes when MQTT connection exception occurs. Should be larger than cache memory size. If nonzero, cache memory size should also be nonzero.",
+		"description_zh": "当 MQTT 连接异常时，最大的磁盘缓存大小（单位：MB）。应该大于缓存内存大小。如果不为 0，缓存内存大小也应该不为 0。",
+		"type": "int",
+		"attribute": "required",
+		"condition": {
+			"field": "offline-cache",
+			"value": true
+		},
+		"valid": {
+			"min": 1,
+			"max": 10240
+		}
+	},
+	"cache-sync-interval": {
+		"name": "Cache Sync Interval (MS)",
+		"name_zh": "缓存消息重传间隔（MS）",
+		"type": "int",
+		"attribute": "required",
+		"condition": {
+			"field": "offline-cache",
+			"value": true
+		},
+		"default": 100,
+		"valid": {
+			"min": 10,
+			"max": 120000
+		}
+	},
+	"host": {
+		"name": "Broker Host",
+		"name_zh": "服务器地址",
+		"attribute": "required",
+		"type": "string",
+		"default": "broker.emqx.io",
+		"valid": {
+			"length": 255
+		}
+	},
+	"port": {
+		"name": "Broker Port",
+		"name_zh": "服务器端口",
+		"attribute": "required",
+		"type": "int",
+		"default": 1883,
+		"valid": {
+			"min": 1,
+			"max": 65535
+		}
+	},
+	"username": {
+		"name": "Username",
+		"name_zh": "用户名",
+		"attribute": "optional",
+		"type": "string",
+		"default": "",
+		"valid": {
+			"length": 255
+		}
+	},
+	"password": {
+		"name": "Password",
+		"name_zh": "密码",
+		"attribute": "optional",
+		"type": "string",
+		"default": "",
+		"valid": {
+			"length": 255
+		}
+	},
+	"ssl": {
+		"name": "SSL",
+		"name_zh": "SSL",
+		"description": "Enable SSL connection",
+		"description_zh": "是否启用 SSL 连接",
+		"attribute": "optional",
+		"type": "bool",
+		"default": false,
+		"valid": {}
+	},
+	"ca": {
+		"name": "CA",
+		"name_zh": "CA 证书",
+		"description": "CA certificate which signs the server certificate",
+		"description_zh": "签发服务器证书的 CA 证书",
+		"attribute": "optional",
+		"type": "file",
+		"condition": {
+			"field": "ssl",
+			"value": true
+		},
+		"valid": {
+			"length": 81960
+		}
+	},
+	"cert": {
+		"name": "Client Cert",
+		"name_zh": "客户端证书",
+		"description": "Client x509 certificate when using two way authentication",
+		"description_zh": "使用双向认证时，客户端的 x509 证书",
+		"attribute": "optional",
+		"type": "file",
+		"condition": {
+			"field": "ssl",
+			"value": true
+		},
+		"valid": {
+			"length": 81960
+		}
+	},
+	"key": {
+		"name": "Client Private Key",
+		"name_zh": "客户端私钥",
+		"description": "Client private key when using two way authentication",
+		"description_zh": "使用双向认证时，客户端的私钥",
+		"attribute": "optional",
+		"type": "file",
+		"condition": {
+			"field": "ssl",
+			"value": true
+		},
+		"valid": {
+			"length": 81960
+		}
+	}
+}

plugins/mqtt/mqtt_handle.c

@@ -229,11 +229,26 @@ static int json_value_to_tag_value(union neu_json_value *req,
         value->type          = NEU_TYPE_BOOL;
         value->value.boolean = req->val_bool;
         break;
-    case NEU_JSON_BYTES:
-        value->type               = NEU_TYPE_BYTES;
-        value->value.bytes.length = req->val_bytes.length;
-        memcpy(value->value.bytes.bytes, req->val_bytes.bytes,
-               req->val_bytes.length);
+    case NEU_JSON_ARRAY_BOOL:
+        value->type               = NEU_TYPE_ARRAY_BOOL;
+        value->value.bools.length = req->val_array_bool.length;
+        for (int i = 0; i < req->val_array_bool.length; i++) {
+            value->value.bools.bools[i] = req->val_array_bool.bools[i];
+        }
+        break;
+    case NEU_JSON_ARRAY_DOUBLE:
+        value->type              = NEU_TYPE_ARRAY_DOUBLE;
+        value->value.f64s.length = req->val_array_double.length;
+        for (int i = 0; i < req->val_array_double.length; i++) {
+            value->value.f64s.f64s[i] = req->val_array_double.f64s[i];
+        }
+        break;
+    case NEU_JSON_ARRAY_INT64:
+        value->type              = NEU_TYPE_ARRAY_INT64;
+        value->value.i64s.length = req->val_array_int64.length;
+        for (int i = 0; i < req->val_array_int64.length; i++) {
+            value->value.i64s.i64s[i] = req->val_array_int64.i64s[i];
+        }
         break;
     default:
         return -1;

plugins/restful/datatag_handle.c

@@ -41,43 +41,73 @@ void handle_add_tags(nng_aio *aio)
             } else if (strlen(req->group) >= NEU_GROUP_NAME_LEN) {
                 CHECK_GROUP_NAME_LENGTH_ERR;
             } else {
-                int                ret    = 0;
-                neu_reqresp_head_t header = { 0 };
-                neu_req_add_tag_t  cmd    = { 0 };
-                header.otel_trace_type    = NEU_OTEL_TRACE_TYPE_REST_COMM;
-
-                header.ctx  = aio;
-                header.type = NEU_REQ_ADD_TAG;
-                strcpy(cmd.driver, req->node);
-                strcpy(cmd.group, req->group);
-                cmd.n_tag = req->n_tag;
-                cmd.tags  = calloc(req->n_tag, sizeof(neu_datatag_t));
+                neu_reqresp_head_t header   = { 0 };
+                neu_req_add_tag_t  cmd      = { 0 };
+                header.otel_trace_type      = NEU_OTEL_TRACE_TYPE_REST_COMM;
+                neu_resp_add_tag_t add_resp = { 0 };
 
                 for (int i = 0; i < req->n_tag; i++) {
-                    cmd.tags[i].attribute = req->tags[i].attribute;
-                    cmd.tags[i].type      = req->tags[i].type;
-                    cmd.tags[i].precision = req->tags[i].precision;
-                    cmd.tags[i].decimal   = req->tags[i].decimal;
-                    cmd.tags[i].bias      = req->tags[i].bias;
-                    cmd.tags[i].address   = strdup(req->tags[i].address);
-                    cmd.tags[i].name      = strdup(req->tags[i].name);
-                    if (req->tags[i].description != NULL) {
-                        cmd.tags[i].description =
-                            strdup(req->tags[i].description);
-                    } else {
-                        cmd.tags[i].description = strdup("");
-                    }
-                    if (NEU_ATTRIBUTE_STATIC & req->tags[i].attribute) {
-                        neu_tag_set_static_value_json(
-                            &cmd.tags[i], req->tags[i].t, &req->tags[i].value);
+                    if (req->tags[i].type == NEU_TYPE_STRING ||
+                        req->tags[i].type == NEU_TYPE_BOOL ||
+                        req->tags[i].type == NEU_TYPE_BIT ||
+                        req->tags[i].type == NEU_TYPE_TIME ||
+                        req->tags[i].type == NEU_TYPE_DATA_AND_TIME) {
+                        if (req->tags[i].precision > 0) {
+                            add_resp.index = i;
+                            add_resp.error = NEU_ERR_TAG_PRECISION_INVALID;
+                            break;
+                        }
+                        if (req->tags[i].decimal > 0) {
+                            add_resp.index = i;
+                            add_resp.error = NEU_ERR_TAG_DECIMAL_INVALID;
+                            break;
+                        }
+                        if (req->tags[i].bias > 0) {
+                            add_resp.index = i;
+                            add_resp.error = NEU_ERR_TAG_BIAS_INVALID;
+                            break;
+                        }
                     }
                 }
 
-                ret = neu_plugin_op(plugin, header, &cmd);
-                if (ret != 0) {
-                    NEU_JSON_RESPONSE_ERROR(NEU_ERR_IS_BUSY, {
-                        neu_http_response(aio, NEU_ERR_IS_BUSY, result_error);
-                    });
+                if (add_resp.error > 0) {
+                    handle_add_tags_resp(aio, &add_resp);
+                } else {
+                    header.ctx  = aio;
+                    header.type = NEU_REQ_ADD_TAG;
+                    strcpy(cmd.driver, req->node);
+                    strcpy(cmd.group, req->group);
+                    cmd.n_tag = req->n_tag;
+                    cmd.tags  = calloc(req->n_tag, sizeof(neu_datatag_t));
+
+                    for (int i = 0; i < req->n_tag; i++) {
+                        cmd.tags[i].attribute = req->tags[i].attribute;
+                        cmd.tags[i].type      = req->tags[i].type;
+                        cmd.tags[i].precision = req->tags[i].precision;
+                        cmd.tags[i].decimal   = req->tags[i].decimal;
+                        cmd.tags[i].bias      = req->tags[i].bias;
+                        cmd.tags[i].address   = strdup(req->tags[i].address);
+                        cmd.tags[i].name      = strdup(req->tags[i].name);
+                        if (req->tags[i].description != NULL) {
+                            cmd.tags[i].description =
+                                strdup(req->tags[i].description);
+                        } else {
+                            cmd.tags[i].description = strdup("");
+                        }
+                        if (NEU_ATTRIBUTE_STATIC & req->tags[i].attribute) {
+                            neu_tag_set_static_value_json(&cmd.tags[i],
+                                                          req->tags[i].t,
+                                                          &req->tags[i].value);
+                        }
+                    }
+
+                    int ret = neu_plugin_op(plugin, header, &cmd);
+                    if (ret != 0) {
+                        NEU_JSON_RESPONSE_ERROR(NEU_ERR_IS_BUSY, {
+                            neu_http_response(aio, NEU_ERR_IS_BUSY,
+                                              result_error);
+                        });
+                    }
                 }
             }
         })
@@ -108,9 +138,11 @@ void handle_add_gtags(nng_aio *aio)
             neu_reqresp_head_t header = { 0 };
             neu_req_add_gtag_t cmd    = { 0 };
             int                err_type;
-            header.ctx             = aio;
-            header.type            = NEU_REQ_ADD_GTAG;
-            header.otel_trace_type = NEU_OTEL_TRACE_TYPE_REST_COMM;
+            int                n_tags   = 0;
+            neu_resp_add_tag_t add_resp = { 0 };
+            header.ctx                  = aio;
+            header.type                 = NEU_REQ_ADD_GTAG;
+            header.otel_trace_type      = NEU_OTEL_TRACE_TYPE_REST_COMM;
 
             if (strlen(req->node) >= NEU_NODE_NAME_LEN) {
                 err_type = NEU_ERR_NODE_NAME_TOO_LONG;
@@ -126,58 +158,90 @@ void handle_add_gtags(nng_aio *aio)
                     err_type = NEU_ERR_GROUP_PARAMETER_INVALID;
                     goto error;
                 }
-            }
-
-            strcpy(cmd.driver, req->node);
-            cmd.n_group = req->n_group;
-            cmd.groups  = calloc(req->n_group, sizeof(neu_gdatatag_t));
-
-            for (int i = 0; i < req->n_group; i++) {
-                strcpy(cmd.groups[i].group, req->groups[i].group);
-                cmd.groups[i].n_tag    = req->groups[i].n_tag;
-                cmd.groups[i].interval = req->groups[i].interval;
-                cmd.groups[i].tags =
-                    calloc(cmd.groups[i].n_tag, sizeof(neu_datatag_t));
-
                 for (int j = 0; j < req->groups[i].n_tag; j++) {
-                    cmd.groups[i].tags[j].attribute =
-                        req->groups[i].tags[j].attribute;
-                    cmd.groups[i].tags[j].type = req->groups[i].tags[j].type;
-                    cmd.groups[i].tags[j].precision =
-                        req->groups[i].tags[j].precision;
-                    cmd.groups[i].tags[j].decimal =
-                        req->groups[i].tags[j].decimal;
-                    cmd.groups[i].tags[j].bias = req->groups[i].tags[j].bias;
-                    cmd.groups[i].tags[j].address =
-                        strdup(req->groups[i].tags[j].address);
-                    cmd.groups[i].tags[j].name =
-                        strdup(req->groups[i].tags[j].name);
-                    if (req->groups[i].tags[j].description != NULL) {
-                        cmd.groups[i].tags[j].description =
-                            strdup(req->groups[i].tags[j].description);
-                    } else {
-                        cmd.groups[i].tags[j].description = strdup("");
-                    }
-                    if (NEU_ATTRIBUTE_STATIC &
-                        req->groups[i].tags[j].attribute) {
-                        neu_tag_set_static_value_json(
-                            &cmd.groups[i].tags[j], req->groups[i].tags[j].t,
-                            &req->groups[i].tags[j].value);
+                    if (req->groups[i].tags[j].type == NEU_TYPE_STRING ||
+                        req->groups[i].tags[j].type == NEU_TYPE_BOOL ||
+                        req->groups[i].tags[j].type == NEU_TYPE_BIT ||
+                        req->groups[i].tags[j].type == NEU_TYPE_TIME ||
+                        req->groups[i].tags[j].type == NEU_TYPE_DATA_AND_TIME) {
+                        if (req->groups[i].tags[j].precision > 0) {
+                            add_resp.index = n_tags + j;
+                            add_resp.error = NEU_ERR_TAG_PRECISION_INVALID;
+                            break;
+                        }
+                        if (req->groups[i].tags[j].decimal > 0) {
+                            add_resp.index = n_tags + j;
+                            add_resp.error = NEU_ERR_TAG_DECIMAL_INVALID;
+                            break;
+                        }
+                        if (req->groups[i].tags[j].bias > 0) {
+                            add_resp.index = n_tags + j;
+                            add_resp.error = NEU_ERR_TAG_BIAS_INVALID;
+                            break;
+                        }
                     }
                 }
-            }
 
-            ret = neu_plugin_op(plugin, header, &cmd);
-            if (ret != 0) {
-                NEU_JSON_RESPONSE_ERROR(NEU_ERR_IS_BUSY, {
-                    neu_http_response(aio, NEU_ERR_IS_BUSY, result_error);
+                n_tags += req->groups[i].n_tag;
+            }
+            if (add_resp.error > 0) {
+                handle_add_tags_resp(aio, &add_resp);
+            } else {
+                strcpy(cmd.driver, req->node);
+                cmd.n_group = req->n_group;
+                cmd.groups  = calloc(req->n_group, sizeof(neu_gdatatag_t));
+
+                for (int i = 0; i < req->n_group; i++) {
+                    strcpy(cmd.groups[i].group, req->groups[i].group);
+                    cmd.groups[i].n_tag    = req->groups[i].n_tag;
+                    cmd.groups[i].interval = req->groups[i].interval;
+                    cmd.groups[i].tags =
+                        calloc(cmd.groups[i].n_tag, sizeof(neu_datatag_t));
+
+                    for (int j = 0; j < req->groups[i].n_tag; j++) {
+                        cmd.groups[i].tags[j].attribute =
+                            req->groups[i].tags[j].attribute;
+                        cmd.groups[i].tags[j].type =
+                            req->groups[i].tags[j].type;
+                        cmd.groups[i].tags[j].precision =
+                            req->groups[i].tags[j].precision;
+                        cmd.groups[i].tags[j].decimal =
+                            req->groups[i].tags[j].decimal;
+                        cmd.groups[i].tags[j].bias =
+                            req->groups[i].tags[j].bias;
+                        cmd.groups[i].tags[j].address =
+                            strdup(req->groups[i].tags[j].address);
+                        cmd.groups[i].tags[j].name =
+                            strdup(req->groups[i].tags[j].name);
+                        if (req->groups[i].tags[j].description != NULL) {
+                            cmd.groups[i].tags[j].description =
+                                strdup(req->groups[i].tags[j].description);
+                        } else {
+                            cmd.groups[i].tags[j].description = strdup("");
+                        }
+                        if (NEU_ATTRIBUTE_STATIC &
+                            req->groups[i].tags[j].attribute) {
+                            neu_tag_set_static_value_json(
+                                &cmd.groups[i].tags[j],
+                                req->groups[i].tags[j].t,
+                                &req->groups[i].tags[j].value);
+                        }
+                    }
+                }
+
+                ret = neu_plugin_op(plugin, header, &cmd);
+                if (ret != 0) {
+                    NEU_JSON_RESPONSE_ERROR(NEU_ERR_IS_BUSY, {
+                        neu_http_response(aio, NEU_ERR_IS_BUSY, result_error);
+                    });
+                }
+                goto success;
+            error:
+                NEU_JSON_RESPONSE_ERROR(err_type, {
+                    neu_http_response(aio, err_type, result_error);
                 });
+            success:;
             }
-            goto success;
-        error:
-            NEU_JSON_RESPONSE_ERROR(
-                err_type, { neu_http_response(aio, err_type, result_error); });
-        success:;
         })
 }
 

plugins/restful/plugin_handle.c

@@ -41,7 +41,7 @@ void handle_add_plugin(nng_aio *aio)
             header.ctx             = aio;
             header.type            = NEU_REQ_ADD_PLUGIN;
             header.otel_trace_type = NEU_OTEL_TRACE_TYPE_REST_COMM;
-            strcpy(cmd.library, req->library);
+            strncpy(cmd.library, req->library, NEU_PLUGIN_LIBRARY_LEN);
             cmd.schema_file = req->schema_file;
             cmd.so_file     = req->so_file;
             ret             = neu_plugin_op(plugin, header, &cmd);
@@ -66,7 +66,7 @@ void handle_update_plugin(nng_aio *aio)
             header.ctx             = aio;
             header.type            = NEU_REQ_UPDATE_PLUGIN;
             header.otel_trace_type = NEU_OTEL_TRACE_TYPE_REST_COMM;
-            strcpy(cmd.library, req->library);
+            strncpy(cmd.library, req->library, NEU_PLUGIN_LIBRARY_LEN);
             cmd.schema_file = req->schema_file;
             cmd.so_file     = req->so_file;
             ret             = neu_plugin_op(plugin, header, &cmd);

plugins/restful/rw_handle.c

@@ -283,8 +283,8 @@ void handle_write(nng_aio *aio)
                 return;
             }
 
-            if (req->t == NEU_JSON_BYTES &&
-                req->value.val_bytes.length > NEU_VALUE_SIZE) {
+            if (req->t == NEU_JSON_ARRAY_INT64 &&
+                req->value.val_array_int64.length > NEU_VALUE_SIZE) {
                 NEU_JSON_RESPONSE_ERROR(NEU_ERR_STRING_TOO_LONG, {
                     neu_http_response(aio, NEU_ERR_STRING_TOO_LONG,
                                       result_error);
@@ -329,23 +329,40 @@ void handle_write(nng_aio *aio)
             case NEU_JSON_STR:
                 cmd.value.type = NEU_TYPE_STRING;
                 strcpy(cmd.value.value.str, req->value.val_str);
-
-                break;
-            case NEU_JSON_BYTES:
-                cmd.value.type               = NEU_TYPE_BYTES;
-                cmd.value.value.bytes.length = req->value.val_bytes.length;
-                memcpy(cmd.value.value.bytes.bytes, req->value.val_bytes.bytes,
-                       req->value.val_bytes.length);
                 break;
             case NEU_JSON_DOUBLE:
                 cmd.value.type      = NEU_TYPE_DOUBLE;
                 cmd.value.value.d64 = req->value.val_double;
-
                 break;
             case NEU_JSON_BOOL:
                 cmd.value.type          = NEU_TYPE_BOOL;
                 cmd.value.value.boolean = req->value.val_bool;
                 break;
+            case NEU_JSON_ARRAY_INT64:
+                cmd.value.type              = NEU_TYPE_ARRAY_INT64;
+                cmd.value.value.i64s.length = req->value.val_array_int64.length;
+                for (int i = 0; i < req->value.val_array_int64.length; i++) {
+                    cmd.value.value.i64s.i64s[i] =
+                        req->value.val_array_int64.i64s[i];
+                }
+                break;
+            case NEU_JSON_ARRAY_DOUBLE:
+                cmd.value.type = NEU_TYPE_ARRAY_DOUBLE;
+                cmd.value.value.f64s.length =
+                    req->value.val_array_double.length;
+                for (int i = 0; i < req->value.val_array_double.length; i++) {
+                    cmd.value.value.f64s.f64s[i] =
+                        req->value.val_array_double.f64s[i];
+                }
+                break;
+            case NEU_JSON_ARRAY_BOOL:
+                cmd.value.type               = NEU_TYPE_ARRAY_BOOL;
+                cmd.value.value.bools.length = req->value.val_array_bool.length;
+                for (int i = 0; i < req->value.val_array_bool.length; i++) {
+                    cmd.value.value.bools.bools[i] =
+                        req->value.val_array_bool.bools[i];
+                }
+                break;
             default:
                 assert(false);
                 break;
@@ -513,13 +530,35 @@ void handle_write_tags(nng_aio *aio)
                     cmd.tags[i].value.value.boolean =
                         req->tags[i].value.val_bool;
                     break;
-                case NEU_JSON_BYTES:
-                    cmd.tags[i].value.type = NEU_TYPE_BYTES;
-                    cmd.tags[i].value.value.bytes.length =
-                        req->tags[i].value.val_bytes.length;
-                    memcpy(cmd.tags[i].value.value.bytes.bytes,
-                           req->tags[i].value.val_bytes.bytes,
-                           req->tags[i].value.val_bytes.length);
+                case NEU_JSON_ARRAY_INT64:
+                    cmd.tags[i].value.type = NEU_TYPE_ARRAY_INT64;
+                    cmd.tags[i].value.value.i64s.length =
+                        req->tags[i].value.val_array_int64.length;
+                    for (int k = 0;
+                         k < req->tags[i].value.val_array_int64.length; k++) {
+                        cmd.tags[i].value.value.i64s.i64s[k] =
+                            req->tags[i].value.val_array_int64.i64s[k];
+                    }
+                    break;
+                case NEU_JSON_ARRAY_DOUBLE:
+                    cmd.tags[i].value.type = NEU_TYPE_ARRAY_DOUBLE;
+                    cmd.tags[i].value.value.f64s.length =
+                        req->tags[i].value.val_array_double.length;
+                    for (int k = 0;
+                         k < req->tags[i].value.val_array_double.length; k++) {
+                        cmd.tags[i].value.value.f64s.f64s[k] =
+                            req->tags[i].value.val_array_double.f64s[k];
+                    }
+                    break;
+                case NEU_JSON_ARRAY_BOOL:
+                    cmd.tags[i].value.type = NEU_TYPE_ARRAY_BOOL;
+                    cmd.tags[i].value.value.bools.length =
+                        req->tags[i].value.val_array_bool.length;
+                    for (int k = 0;
+                         k < req->tags[i].value.val_array_bool.length; k++) {
+                        cmd.tags[i].value.value.bools.bools[k] =
+                            req->tags[i].value.val_array_bool.bools[k];
+                    }
                     break;
                 default:
                     assert(false);
@@ -599,13 +638,38 @@ static void trans(neu_json_write_gtags_req_t *req, neu_req_write_gtags_t *cmd)
                 cmd->groups[i].tags[k].value.value.boolean =
                     req->groups[i].tags[k].value.val_bool;
                 break;
-            case NEU_JSON_BYTES:
-                cmd->groups[i].tags[k].value.type = NEU_TYPE_BYTES;
-                cmd->groups[i].tags[k].value.value.bytes.length =
-                    req->groups[i].tags[k].value.val_bytes.length;
-                memcpy(cmd->groups[i].tags[k].value.value.bytes.bytes,
-                       req->groups[i].tags[k].value.val_bytes.bytes,
-                       req->groups[i].tags[k].value.val_bytes.length);
+            case NEU_JSON_ARRAY_INT64:
+                cmd->groups[i].tags[k].value.type = NEU_TYPE_ARRAY_INT64;
+                cmd->groups[i].tags[k].value.value.i64s.length =
+                    req->groups[i].tags[k].value.val_array_int64.length;
+                for (int j = 0;
+                     j < req->groups[i].tags[k].value.val_array_int64.length;
+                     j++) {
+                    cmd->groups[i].tags[k].value.value.i64s.i64s[j] =
+                        req->groups[i].tags[k].value.val_array_int64.i64s[j];
+                }
+                break;
+            case NEU_JSON_ARRAY_DOUBLE:
+                cmd->groups[i].tags[k].value.type = NEU_TYPE_ARRAY_DOUBLE;
+                cmd->groups[i].tags[k].value.value.f64s.length =
+                    req->groups[i].tags[k].value.val_array_double.length;
+                for (int j = 0;
+                     j < req->groups[i].tags[k].value.val_array_double.length;
+                     j++) {
+                    cmd->groups[i].tags[k].value.value.f64s.f64s[j] =
+                        req->groups[i].tags[k].value.val_array_double.f64s[j];
+                }
+                break;
+            case NEU_JSON_ARRAY_BOOL:
+                cmd->groups[i].tags[k].value.type = NEU_TYPE_ARRAY_BOOL;
+                cmd->groups[i].tags[k].value.value.bools.length =
+                    req->groups[i].tags[k].value.val_array_bool.length;
+                for (int j = 0;
+                     j < req->groups[i].tags[k].value.val_array_bool.length;
+                     j++) {
+                    cmd->groups[i].tags[k].value.value.bools.bools[j] =
+                        req->groups[i].tags[k].value.val_array_bool.bools[j];
+                }
                 break;
             default:
                 assert(false);

src/adapter/driver/cache.c

@@ -235,6 +235,7 @@ void neu_driver_cache_update_change(neu_driver_cache_t *cache,
             case NEU_TYPE_WORD:
             case NEU_TYPE_DWORD:
             case NEU_TYPE_LWORD:
+            case NEU_TYPE_ARRAY_CHAR:
                 if (memcmp(&elem->value_old.value, &value.value,
                            sizeof(value.value)) != 0) {
                     elem->changed = true;
@@ -252,6 +253,144 @@ void neu_driver_cache_update_change(neu_driver_cache_t *cache,
                     }
                 }
                 break;
+            case NEU_TYPE_ARRAY_BOOL:
+                if (elem->value_old.value.bools.length !=
+                    value.value.bools.length) {
+                    elem->changed = true;
+                } else {
+                    if (memcmp(elem->value_old.value.bools.bools,
+                               value.value.bools.bools,
+                               value.value.bools.length) != 0) {
+                        elem->changed = true;
+                    }
+                }
+                break;
+            case NEU_TYPE_ARRAY_INT8:
+                if (elem->value_old.value.i8s.length !=
+                    value.value.i8s.length) {
+                    elem->changed = true;
+                } else {
+                    if (memcmp(elem->value_old.value.i8s.i8s,
+                               value.value.i8s.i8s,
+                               value.value.i8s.length) != 0) {
+                        elem->changed = true;
+                    }
+                }
+                break;
+            case NEU_TYPE_ARRAY_UINT8:
+                if (elem->value_old.value.u8s.length !=
+                    value.value.u8s.length) {
+                    elem->changed = true;
+                } else {
+                    if (memcmp(elem->value_old.value.u8s.u8s,
+                               value.value.u8s.u8s,
+                               value.value.u8s.length) != 0) {
+                        elem->changed = true;
+                    }
+                }
+                break;
+            case NEU_TYPE_ARRAY_INT16:
+                if (elem->value_old.value.i16s.length !=
+                    value.value.i16s.length) {
+                    elem->changed = true;
+                } else {
+                    if (memcmp(elem->value_old.value.i16s.i16s,
+                               value.value.i16s.i16s,
+                               value.value.i16s.length * sizeof(int16_t)) !=
+                        0) {
+                        elem->changed = true;
+                    }
+                }
+                break;
+            case NEU_TYPE_ARRAY_UINT16:
+                if (elem->value_old.value.u16s.length !=
+                    value.value.u16s.length) {
+                    elem->changed = true;
+                } else {
+                    if (memcmp(elem->value_old.value.u16s.u16s,
+                               value.value.u16s.u16s,
+                               value.value.u16s.length * sizeof(uint16_t)) !=
+                        0) {
+                        elem->changed = true;
+                    }
+                }
+                break;
+            case NEU_TYPE_ARRAY_INT32:
+                if (elem->value_old.value.i32s.length !=
+                    value.value.i32s.length) {
+                    elem->changed = true;
+                } else {
+                    if (memcmp(elem->value_old.value.i32s.i32s,
+                               value.value.i32s.i32s,
+                               value.value.i32s.length * sizeof(int32_t)) !=
+                        0) {
+                        elem->changed = true;
+                    }
+                }
+                break;
+            case NEU_TYPE_ARRAY_UINT32:
+                if (elem->value_old.value.u32s.length !=
+                    value.value.u32s.length) {
+                    elem->changed = true;
+                } else {
+                    if (memcmp(elem->value_old.value.u32s.u32s,
+                               value.value.u32s.u32s,
+                               value.value.u32s.length * sizeof(uint32_t)) !=
+                        0) {
+                        elem->changed = true;
+                    }
+                }
+                break;
+            case NEU_TYPE_ARRAY_INT64:
+                if (elem->value_old.value.i64s.length !=
+                    value.value.i64s.length) {
+                    elem->changed = true;
+                } else {
+                    if (memcmp(elem->value_old.value.i64s.i64s,
+                               value.value.i64s.i64s,
+                               value.value.i64s.length * sizeof(int64_t)) !=
+                        0) {
+                        elem->changed = true;
+                    }
+                }
+                break;
+            case NEU_TYPE_ARRAY_UINT64:
+                if (elem->value_old.value.u64s.length !=
+                    value.value.u64s.length) {
+                    elem->changed = true;
+                } else {
+                    if (memcmp(elem->value_old.value.u64s.u64s,
+                               value.value.u64s.u64s,
+                               value.value.u64s.length * sizeof(uint64_t)) !=
+                        0) {
+                        elem->changed = true;
+                    }
+                }
+                break;
+            case NEU_TYPE_ARRAY_FLOAT:
+                if (elem->value_old.value.f32s.length !=
+                    value.value.f32s.length) {
+                    elem->changed = true;
+                } else {
+                    if (memcmp(elem->value_old.value.f32s.f32s,
+                               value.value.f32s.f32s,
+                               value.value.f32s.length * sizeof(float)) != 0) {
+                        elem->changed = true;
+                    }
+                }
+                break;
+            case NEU_TYPE_ARRAY_DOUBLE:
+                if (elem->value_old.value.f64s.length !=
+                    value.value.f64s.length) {
+                    elem->changed = true;
+                } else {
+                    if (memcmp(elem->value_old.value.f64s.f64s,
+                               value.value.f64s.f64s,
+                               value.value.f64s.length * sizeof(double)) != 0) {
+                        elem->changed = true;
+                    }
+                }
+                break;
             case NEU_TYPE_PTR: {
                 if (elem->value_old.value.ptr.length !=
                     value.value.ptr.length) {
@@ -310,6 +449,7 @@ void neu_driver_cache_update_change(neu_driver_cache_t *cache,
             case NEU_TYPE_WORD:
             case NEU_TYPE_DWORD:
             case NEU_TYPE_LWORD:
+            case NEU_TYPE_ARRAY_CHAR:
                 if (memcmp(&elem->value.value, &value.value,
                            sizeof(value.value)) != 0) {
                     elem->changed = true;
@@ -327,6 +467,126 @@ void neu_driver_cache_update_change(neu_driver_cache_t *cache,
                     }
                 }
                 break;
+            case NEU_TYPE_ARRAY_BOOL:
+                if (elem->value.value.bools.length !=
+                    value.value.bools.length) {
+                    elem->changed = true;
+                } else {
+                    if (memcmp(elem->value.value.bools.bools,
+                               value.value.bools.bools,
+                               value.value.bools.length) != 0) {
+                        elem->changed = true;
+                    }
+                }
+                break;
+            case NEU_TYPE_ARRAY_INT8:
+                if (elem->value.value.i8s.length != value.value.i8s.length) {
+                    elem->changed = true;
+                } else {
+                    if (memcmp(elem->value.value.i8s.i8s, value.value.i8s.i8s,
+                               value.value.i8s.length) != 0) {
+                        elem->changed = true;
+                    }
+                }
+                break;
+            case NEU_TYPE_ARRAY_UINT8:
+                if (elem->value.value.u8s.length != value.value.u8s.length) {
+                    elem->changed = true;
+                } else {
+                    if (memcmp(elem->value.value.u8s.u8s, value.value.u8s.u8s,
+                               value.value.u8s.length) != 0) {
+                        elem->changed = true;
+                    }
+                }
+                break;
+            case NEU_TYPE_ARRAY_INT16:
+                if (elem->value.value.i16s.length != value.value.i16s.length) {
+                    elem->changed = true;
+                } else {
+                    if (memcmp(
+                            elem->value.value.i16s.i16s, value.value.i16s.i16s,
+                            value.value.i16s.length * sizeof(int16_t)) != 0) {
+                        elem->changed = true;
+                    }
+                }
+                break;
+            case NEU_TYPE_ARRAY_UINT16:
+                if (elem->value.value.u16s.length != value.value.u16s.length) {
+                    elem->changed = true;
+                } else {
+                    if (memcmp(
+                            elem->value.value.u16s.u16s, value.value.u16s.u16s,
+                            value.value.u16s.length * sizeof(uint16_t)) != 0) {
+                        elem->changed = true;
+                    }
+                }
+                break;
+            case NEU_TYPE_ARRAY_INT32:
+                if (elem->value.value.i32s.length != value.value.i32s.length) {
+                    elem->changed = true;
+                } else {
+                    if (memcmp(
+                            elem->value.value.i32s.i32s, value.value.i32s.i32s,
+                            value.value.i32s.length * sizeof(int32_t)) != 0) {
+                        elem->changed = true;
+                    }
+                }
+                break;
+            case NEU_TYPE_ARRAY_UINT32:
+                if (elem->value.value.u32s.length != value.value.u32s.length) {
+                    elem->changed = true;
+                } else {
+                    if (memcmp(
+                            elem->value.value.u32s.u32s, value.value.u32s.u32s,
+                            value.value.u32s.length * sizeof(uint32_t)) != 0) {
+                        elem->changed = true;
+                    }
+                }
+                break;
+            case NEU_TYPE_ARRAY_INT64:
+                if (elem->value.value.i64s.length != value.value.i64s.length) {
+                    elem->changed = true;
+                } else {
+                    if (memcmp(
+                            elem->value.value.i64s.i64s, value.value.i64s.i64s,
+                            value.value.i64s.length * sizeof(int64_t)) != 0) {
+                        elem->changed = true;
+                    }
+                }
+                break;
+            case NEU_TYPE_ARRAY_UINT64:
+                if (elem->value.value.u64s.length != value.value.u64s.length) {
+                    elem->changed = true;
+                } else {
+                    if (memcmp(
+                            elem->value.value.u64s.u64s, value.value.u64s.u64s,
+                            value.value.u64s.length * sizeof(uint64_t)) != 0) {
+                        elem->changed = true;
+                    }
+                }
+                break;
+            case NEU_TYPE_ARRAY_FLOAT:
+                if (elem->value.value.f32s.length != value.value.f32s.length) {
+                    elem->changed = true;
+                } else {
+                    if (memcmp(elem->value.value.f32s.f32s,
+                               value.value.f32s.f32s,
+                               value.value.f32s.length * sizeof(float)) != 0) {
+                        elem->changed = true;
+                    }
+                }
+                break;
+            case NEU_TYPE_ARRAY_DOUBLE:
+                if (elem->value.value.f64s.length != value.value.f64s.length) {
+                    elem->changed = true;
+                } else {
+                    if (memcmp(elem->value.value.f64s.f64s,
+                               value.value.f64s.f64s,
+                               value.value.f64s.length * sizeof(double)) != 0) {
+                        elem->changed = true;
+                    }
+                }
+                break;
             case NEU_TYPE_PTR: {
                 if (elem->value.value.ptr.length != value.value.ptr.length) {
                     elem->changed = true;
@@ -459,6 +719,7 @@ int neu_driver_cache_meta_get(neu_driver_cache_t *cache, const char *group,
         case NEU_TYPE_STRING:
         case NEU_TYPE_TIME:
         case NEU_TYPE_DATA_AND_TIME:
+        case NEU_TYPE_ARRAY_CHAR:
             memcpy(value->value.value.str, elem->value.value.str,
                    sizeof(elem->value.value.str));
             break;
@@ -468,6 +729,62 @@ int neu_driver_cache_meta_get(neu_driver_cache_t *cache, const char *group,
                    elem->value.value.bytes.bytes,
                    elem->value.value.bytes.length);
             break;
+        case NEU_TYPE_ARRAY_BOOL:
+            value->value.value.bools.length = elem->value.value.bools.length;
+            memcpy(value->value.value.bools.bools,
+                   elem->value.value.bools.bools,
+                   elem->value.value.bools.length);
+            break;
+        case NEU_TYPE_ARRAY_INT8:
+            value->value.value.i8s.length = elem->value.value.i8s.length;
+            memcpy(value->value.value.i8s.i8s, elem->value.value.i8s.i8s,
+                   elem->value.value.i8s.length);
+            break;
+        case NEU_TYPE_ARRAY_UINT8:
+            value->value.value.u8s.length = elem->value.value.u8s.length;
+            memcpy(value->value.value.u8s.u8s, elem->value.value.u8s.u8s,
+                   elem->value.value.u8s.length);
+            break;
+        case NEU_TYPE_ARRAY_INT16:
+            value->value.value.i16s.length = elem->value.value.i16s.length;
+            memcpy(value->value.value.i16s.i16s, elem->value.value.i16s.i16s,
+                   elem->value.value.i16s.length * sizeof(int16_t));
+            break;
+        case NEU_TYPE_ARRAY_UINT16:
+            value->value.value.u16s.length = elem->value.value.u16s.length;
+            memcpy(value->value.value.u16s.u16s, elem->value.value.u16s.u16s,
+                   elem->value.value.u16s.length * sizeof(uint16_t));
+            break;
+        case NEU_TYPE_ARRAY_INT32:
+            value->value.value.i32s.length = elem->value.value.i32s.length;
+            memcpy(value->value.value.i32s.i32s, elem->value.value.i32s.i32s,
+                   elem->value.value.i32s.length * sizeof(int32_t));
+            break;
+        case NEU_TYPE_ARRAY_UINT32:
+            value->value.value.u32s.length = elem->value.value.u32s.length;
+            memcpy(value->value.value.u32s.u32s, elem->value.value.u32s.u32s,
+                   elem->value.value.u32s.length * sizeof(uint32_t));
+            break;
+        case NEU_TYPE_ARRAY_INT64:
+            value->value.value.i64s.length = elem->value.value.i64s.length;
+            memcpy(value->value.value.i64s.i64s, elem->value.value.i64s.i64s,
+                   elem->value.value.i64s.length * sizeof(int64_t));
+            break;
+        case NEU_TYPE_ARRAY_UINT64:
+            value->value.value.u64s.length = elem->value.value.u64s.length;
+            memcpy(value->value.value.u64s.u64s, elem->value.value.u64s.u64s,
+                   elem->value.value.u64s.length * sizeof(uint64_t));
+            break;
+        case NEU_TYPE_ARRAY_FLOAT:
+            value->value.value.f32s.length = elem->value.value.f32s.length;
+            memcpy(value->value.value.f32s.f32s, elem->value.value.f32s.f32s,
+                   elem->value.value.f32s.length * sizeof(float));
+            break;
+        case NEU_TYPE_ARRAY_DOUBLE:
+            value->value.value.f64s.length = elem->value.value.f64s.length;
+            memcpy(value->value.value.f64s.f64s, elem->value.value.f64s.f64s,
+                   elem->value.value.f64s.length * sizeof(double));
+            break;
         case NEU_TYPE_PTR:
             value->value.value.ptr.length = elem->value.value.ptr.length;
             value->value.value.ptr.type   = elem->value.value.ptr.type;
@@ -543,6 +860,7 @@ int neu_driver_cache_meta_get_changed(neu_driver_cache_t *cache,
         case NEU_TYPE_STRING:
         case NEU_TYPE_TIME:
         case NEU_TYPE_DATA_AND_TIME:
+        case NEU_TYPE_ARRAY_CHAR:
             memcpy(value->value.value.str, elem->value.value.str,
                    sizeof(elem->value.value.str));
             break;
@@ -552,6 +870,62 @@ int neu_driver_cache_meta_get_changed(neu_driver_cache_t *cache,
                    elem->value.value.bytes.bytes,
                    elem->value.value.bytes.length);
             break;
+        case NEU_TYPE_ARRAY_BOOL:
+            value->value.value.bools.length = elem->value.value.bools.length;
+            memcpy(value->value.value.bools.bools,
+                   elem->value.value.bools.bools,
+                   elem->value.value.bools.length);
+            break;
+        case NEU_TYPE_ARRAY_INT8:
+            value->value.value.i8s.length = elem->value.value.i8s.length;
+            memcpy(value->value.value.i8s.i8s, elem->value.value.i8s.i8s,
+                   elem->value.value.i8s.length);
+            break;
+        case NEU_TYPE_ARRAY_UINT8:
+            value->value.value.u8s.length = elem->value.value.u8s.length;
+            memcpy(value->value.value.u8s.u8s, elem->value.value.u8s.u8s,
+                   elem->value.value.u8s.length);
+            break;
+        case NEU_TYPE_ARRAY_INT16:
+            value->value.value.i16s.length = elem->value.value.i16s.length;
+            memcpy(value->value.value.i16s.i16s, elem->value.value.i16s.i16s,
+                   elem->value.value.i16s.length * sizeof(int16_t));
+            break;
+        case NEU_TYPE_ARRAY_UINT16:
+            value->value.value.u16s.length = elem->value.value.u16s.length;
+            memcpy(value->value.value.u16s.u16s, elem->value.value.u16s.u16s,
+                   elem->value.value.u16s.length * sizeof(uint16_t));
+            break;
+        case NEU_TYPE_ARRAY_INT32:
+            value->value.value.i32s.length = elem->value.value.i32s.length;
+            memcpy(value->value.value.i32s.i32s, elem->value.value.i32s.i32s,
+                   elem->value.value.i32s.length * sizeof(int32_t));
+            break;
+        case NEU_TYPE_ARRAY_UINT32:
+            value->value.value.u32s.length = elem->value.value.u32s.length;
+            memcpy(value->value.value.u32s.u32s, elem->value.value.u32s.u32s,
+                   elem->value.value.u32s.length * sizeof(uint32_t));
+            break;
+        case NEU_TYPE_ARRAY_INT64:
+            value->value.value.i64s.length = elem->value.value.i64s.length;
+            memcpy(value->value.value.i64s.i64s, elem->value.value.i64s.i64s,
+                   elem->value.value.i64s.length * sizeof(int64_t));
+            break;
+        case NEU_TYPE_ARRAY_UINT64:
+            value->value.value.u64s.length = elem->value.value.u64s.length;
+            memcpy(value->value.value.u64s.u64s, elem->value.value.u64s.u64s,
+                   elem->value.value.u64s.length * sizeof(uint64_t));
+            break;
+        case NEU_TYPE_ARRAY_FLOAT:
+            value->value.value.f32s.length = elem->value.value.f32s.length;
+            memcpy(value->value.value.f32s.f32s, elem->value.value.f32s.f32s,
+                   elem->value.value.f32s.length * sizeof(float));
+            break;
+        case NEU_TYPE_ARRAY_DOUBLE:
+            value->value.value.f64s.length = elem->value.value.f64s.length;
+            memcpy(value->value.value.f64s.f64s, elem->value.value.f64s.f64s,
+                   elem->value.value.f64s.length * sizeof(double));
+            break;
         case NEU_TYPE_PTR:
             value->value.value.ptr.length = elem->value.value.ptr.length;
             value->value.value.ptr.type   = elem->value.value.ptr.type;

src/adapter/driver/driver.c

@@ -306,8 +306,7 @@ static void update_im(neu_adapter_t *adapter, const char *group,
     }
     neu_datatag_t *first = utarray_front(tags);
 
-    if (first == NULL ||
-        !neu_tag_attribute_test(first, NEU_ATTRIBUTE_SUBSCRIBE)) {
+    if (first == NULL) {
         utarray_free(tags);
         nlog_debug("update immediately, driver: %s, "
                    "group: %s, tag: %s, type: %s, "
@@ -750,7 +749,9 @@ static void fix_value(neu_datatag_t *tag, neu_type_e value_type,
     case NEU_TYPE_STRING:
     case NEU_TYPE_TIME:
     case NEU_TYPE_DATA_AND_TIME:
-    case NEU_TYPE_BYTES:
+    case NEU_TYPE_ARRAY_INT64:
+    case NEU_TYPE_ARRAY_CHAR:
+    case NEU_TYPE_ARRAY_BOOL:
         break;
     case NEU_TYPE_BIT:
         value->type     = NEU_TYPE_BIT;
@@ -831,6 +832,129 @@ static void fix_value(neu_datatag_t *tag, neu_type_e value_type,
             break;
         }
         break;
+    case NEU_TYPE_BYTES:
+        if (value->type == NEU_TYPE_ARRAY_INT64) {
+            value->value.bytes.length = value->value.i64s.length;
+            for (int i = 0; i < value->value.i64s.length; i++) {
+                value->value.bytes.bytes[i] =
+                    (uint8_t) value->value.i64s.i64s[i];
+            }
+            for (int i = value->value.i64s.length; i < NEU_VALUE_SIZE; i++) {
+                value->value.bytes.bytes[i] = 0;
+            }
+        }
+        break;
+    case NEU_TYPE_ARRAY_INT8:
+        if (value->type == NEU_TYPE_ARRAY_INT64) {
+            value->value.i8s.length = value->value.i64s.length;
+            for (int i = 0; i < value->value.i64s.length; i++) {
+                value->value.i8s.i8s[i] = (int8_t) value->value.i64s.i64s[i];
+            }
+            for (int i = value->value.i64s.length; i < NEU_VALUE_SIZE; i++) {
+                value->value.i8s.i8s[i] = 0;
+            }
+        }
+        break;
+    case NEU_TYPE_ARRAY_UINT8:
+        if (value->type == NEU_TYPE_ARRAY_INT64) {
+            value->value.u8s.length = value->value.i64s.length;
+            for (int i = 0; i < value->value.i64s.length; i++) {
+                value->value.u8s.u8s[i] = (uint8_t) value->value.i64s.i64s[i];
+            }
+            for (int i = value->value.i64s.length; i < NEU_VALUE_SIZE; i++) {
+                value->value.u8s.u8s[i] = 0;
+            }
+        }
+        break;
+    case NEU_TYPE_ARRAY_INT16:
+        if (value->type == NEU_TYPE_ARRAY_INT64) {
+            value->value.i16s.length = value->value.i64s.length;
+            for (int i = 0; i < value->value.i64s.length; i++) {
+                value->value.i16s.i16s[i] = (int16_t) value->value.i64s.i64s[i];
+            }
+            for (int i = value->value.i64s.length; i < NEU_VALUE_SIZE; i++) {
+                value->value.i16s.i16s[i] = 0;
+            }
+        }
+        break;
+    case NEU_TYPE_ARRAY_UINT16:
+        if (value->type == NEU_TYPE_ARRAY_INT64) {
+            value->value.u16s.length = value->value.i64s.length;
+            for (int i = 0; i < value->value.i64s.length; i++) {
+                value->value.u16s.u16s[i] =
+                    (uint16_t) value->value.i64s.i64s[i];
+            }
+            for (int i = value->value.i64s.length; i < NEU_VALUE_SIZE; i++) {
+                value->value.u16s.u16s[i] = 0;
+            }
+        }
+        break;
+    case NEU_TYPE_ARRAY_INT32:
+        if (value->type == NEU_TYPE_ARRAY_INT64) {
+            value->value.i32s.length = value->value.i64s.length;
+            for (int i = 0; i < value->value.i64s.length; i++) {
+                value->value.i32s.i32s[i] = (int32_t) value->value.i64s.i64s[i];
+            }
+            for (int i = value->value.i64s.length; i < NEU_VALUE_SIZE; i++) {
+                value->value.i32s.i32s[i] = 0;
+            }
+        }
+        break;
+    case NEU_TYPE_ARRAY_UINT32:
+        if (value->type == NEU_TYPE_ARRAY_INT64) {
+            value->value.u32s.length = value->value.i64s.length;
+            for (int i = 0; i < value->value.i64s.length; i++) {
+                value->value.u32s.u32s[i] =
+                    (uint32_t) value->value.i64s.i64s[i];
+            }
+            for (int i = value->value.i64s.length; i < NEU_VALUE_SIZE; i++) {
+                value->value.u32s.u32s[i] = 0;
+            }
+        }
+        break;
+    case NEU_TYPE_ARRAY_UINT64:
+        if (value->type == NEU_TYPE_ARRAY_INT64) {
+            value->value.u64s.length = value->value.i64s.length;
+            for (int i = 0; i < value->value.i64s.length; i++) {
+                value->value.u64s.u64s[i] =
+                    (uint64_t) value->value.i64s.i64s[i];
+            }
+            for (int i = value->value.i64s.length; i < NEU_VALUE_SIZE; i++) {
+                value->value.u64s.u64s[i] = 0;
+            }
+        }
+        break;
+    case NEU_TYPE_ARRAY_FLOAT:
+        if (value->type == NEU_TYPE_ARRAY_INT64) {
+            value->value.f32s.length = value->value.i64s.length;
+            for (int i = 0; i < value->value.i64s.length; i++) {
+                value->value.f32s.f32s[i] = (float) value->value.i64s.i64s[i];
+            }
+            for (int i = value->value.i64s.length; i < NEU_VALUE_SIZE; i++) {
+                value->value.f32s.f32s[i] = 0;
+            }
+        }
+        if (value->type == NEU_TYPE_ARRAY_DOUBLE) {
+            value->value.f32s.length = value->value.f64s.length;
+            for (int i = 0; i < value->value.f64s.length; i++) {
+                value->value.f32s.f32s[i] = (float) value->value.f64s.f64s[i];
+            }
+            for (int i = value->value.f64s.length; i < NEU_VALUE_SIZE; i++) {
+                value->value.f32s.f32s[i] = 0;
+            }
+        }
+        break;
+    case NEU_TYPE_ARRAY_DOUBLE:
+        if (value->type == NEU_TYPE_ARRAY_INT64) {
+            value->value.f64s.length = value->value.i64s.length;
+            for (int i = 0; i < value->value.i64s.length; i++) {
+                value->value.f64s.f64s[i] = (double) value->value.i64s.i64s[i];
+            }
+            for (int i = value->value.i64s.length; i < NEU_VALUE_SIZE; i++) {
+                value->value.f64s.f64s[i] = 0;
+            }
+        }
+        break;
     default:
         assert(false);
         break;
@@ -927,7 +1051,8 @@ int check_value_decimal(neu_type_e write_type, double result, int64_t value_min,
         return NEU_ERR_PLUGIN_TAG_TYPE_MISMATCH;
     } else if (result < value_min || result > value_max) {
         return NEU_ERR_PLUGIN_TAG_VALUE_OUT_OF_RANGE;
-    } else if (almost_equal(ceil(result), result, EPSILON)) {
+    } else if (almost_equal(ceil(result), result, EPSILON) ||
+               almost_equal(floor(result), result, EPSILON)) {
         return NEU_ERR_SUCCESS;
     } else {
         return NEU_ERR_PLUGIN_TAG_TYPE_MISMATCH;
@@ -977,7 +1102,8 @@ int is_value_in_range(neu_type_e tag_type, int64_t value, double value_d,
         case NEU_TYPE_UINT64:
             if (write_type != NEU_TYPE_INT64 && write_type != NEU_TYPE_DOUBLE) {
                 return NEU_ERR_PLUGIN_TAG_TYPE_MISMATCH;
-            } else if (almost_equal(ceil(result), result, EPSILON)) {
+            } else if (almost_equal(ceil(result), result, EPSILON) ||
+                       almost_equal(floor(result), result, EPSILON)) {
                 return NEU_ERR_SUCCESS;
             } else {
                 return NEU_ERR_PLUGIN_TAG_TYPE_MISMATCH;
@@ -1001,7 +1127,7 @@ int is_value_in_range(neu_type_e tag_type, int64_t value, double value_d,
         case NEU_TYPE_STRING:
         case NEU_TYPE_BOOL:
         case NEU_TYPE_BIT:
-            return NEU_ERR_PARAM_IS_WRONG;
+            return NEU_ERR_TAG_DECIMAL_INVALID;
         default:
             return NEU_ERR_SUCCESS;
         }
@@ -1119,6 +1245,7 @@ int neu_adapter_driver_write_tags(neu_adapter_driver_t *driver,
                         (double) cmd->tags[i].value.value.i64;
                 }
             }
+
             if (tag->decimal != 0) {
                 cal_decimal(tag->type, cmd->tags[i].value.type,
                             &cmd->tags[i].value.value, tag->decimal);
@@ -1235,6 +1362,7 @@ int neu_adapter_driver_write_gtags(neu_adapter_driver_t *driver,
                             (double) cmd->groups[i].tags[k].value.value.i64;
                     }
                 }
+
                 if (tag->decimal != 0) {
                     cal_decimal(tag->type, cmd->groups[i].tags[k].value.type,
                                 &cmd->groups[i].tags[k].value.value,

src/connection/connection.c

@@ -99,7 +99,7 @@ neu_conn_t *neu_conn_new(neu_conn_param_t *param, void *data,
     conn->disconnected     = disconnected;
     conn->connected        = connected;
 
-    conn->buf_size = 2048;
+    conn->buf_size = 8192;
     conn->buf      = calloc(conn->buf_size, 1);
     conn->offset   = 0;
     conn->stop     = false;

src/parser/neu_json_rw.c

@@ -383,8 +383,47 @@ void neu_json_decode_write_req_free(neu_json_write_req_t *req)
     if (req->t == NEU_JSON_STR) {
         free(req->value.val_str);
     }
-    if (req->t == NEU_JSON_BYTES && req->value.val_bytes.length > 0) {
-        free(req->value.val_bytes.bytes);
+    if (req->t == NEU_JSON_ARRAY_INT8 && req->value.val_array_int8.length > 0) {
+        free(req->value.val_array_int8.i8s);
+    }
+    if (req->t == NEU_JSON_ARRAY_UINT8 &&
+        req->value.val_array_uint8.length > 0) {
+        free(req->value.val_array_uint8.u8s);
+    }
+    if (req->t == NEU_JSON_ARRAY_INT16 &&
+        req->value.val_array_int16.length > 0) {
+        free(req->value.val_array_int16.i16s);
+    }
+    if (req->t == NEU_JSON_ARRAY_UINT16 &&
+        req->value.val_array_uint16.length > 0) {
+        free(req->value.val_array_uint16.u16s);
+    }
+    if (req->t == NEU_JSON_ARRAY_INT32 &&
+        req->value.val_array_int32.length > 0) {
+        free(req->value.val_array_int32.i32s);
+    }
+    if (req->t == NEU_JSON_ARRAY_UINT32 &&
+        req->value.val_array_uint32.length > 0) {
+        free(req->value.val_array_uint32.u32s);
+    }
+    if (req->t == NEU_JSON_ARRAY_INT64 &&
+        req->value.val_array_int64.length > 0) {
+        free(req->value.val_array_int64.i64s);
+    }
+    if (req->t == NEU_JSON_ARRAY_UINT64 &&
+        req->value.val_array_uint64.length > 0) {
+        free(req->value.val_array_uint64.u64s);
+    }
+    if (req->t == NEU_JSON_ARRAY_FLOAT &&
+        req->value.val_array_float.length > 0) {
+        free(req->value.val_array_float.f32s);
+    }
+    if (req->t == NEU_JSON_ARRAY_DOUBLE &&
+        req->value.val_array_double.length > 0) {
+        free(req->value.val_array_double.f64s);
+    }
+    if (req->t == NEU_JSON_ARRAY_BOOL && req->value.val_array_bool.length > 0) {
+        free(req->value.val_array_bool.bools);
     }
 
     free(req);
@@ -502,9 +541,49 @@ void neu_json_decode_write_tags_req_free(neu_json_write_tags_req_t *req)
         if (req->tags[i].t == NEU_JSON_STR) {
             free(req->tags[i].value.val_str);
         }
-        if (req->tags[i].t == NEU_JSON_BYTES &&
-            req->tags[i].value.val_bytes.length > 0) {
-            free(req->tags[i].value.val_bytes.bytes);
+        if (req->tags[i].t == NEU_JSON_ARRAY_INT8 &&
+            req->tags[i].value.val_array_int8.length > 0) {
+            free(req->tags[i].value.val_array_int8.i8s);
+        }
+        if (req->tags[i].t == NEU_JSON_ARRAY_UINT8 &&
+            req->tags[i].value.val_array_uint8.length > 0) {
+            free(req->tags[i].value.val_array_uint8.u8s);
+        }
+        if (req->tags[i].t == NEU_JSON_ARRAY_INT16 &&
+            req->tags[i].value.val_array_int16.length > 0) {
+            free(req->tags[i].value.val_array_int16.i16s);
+        }
+        if (req->tags[i].t == NEU_JSON_ARRAY_UINT16 &&
+            req->tags[i].value.val_array_uint16.length > 0) {
+            free(req->tags[i].value.val_array_uint16.u16s);
+        }
+        if (req->tags[i].t == NEU_JSON_ARRAY_INT32 &&
+            req->tags[i].value.val_array_int32.length > 0) {
+            free(req->tags[i].value.val_array_int32.i32s);
+        }
+        if (req->tags[i].t == NEU_JSON_ARRAY_UINT32 &&
+            req->tags[i].value.val_array_uint32.length > 0) {
+            free(req->tags[i].value.val_array_uint32.u32s);
+        }
+        if (req->tags[i].t == NEU_JSON_ARRAY_INT64 &&
+            req->tags[i].value.val_array_int64.length > 0) {
+            free(req->tags[i].value.val_array_int64.i64s);
+        }
+        if (req->tags[i].t == NEU_JSON_ARRAY_UINT64 &&
+            req->tags[i].value.val_array_uint64.length > 0) {
+            free(req->tags[i].value.val_array_uint64.u64s);
+        }
+        if (req->tags[i].t == NEU_JSON_ARRAY_FLOAT &&
+            req->tags[i].value.val_array_float.length > 0) {
+            free(req->tags[i].value.val_array_float.f32s);
+        }
+        if (req->tags[i].t == NEU_JSON_ARRAY_DOUBLE &&
+            req->tags[i].value.val_array_double.length > 0) {
+            free(req->tags[i].value.val_array_double.f64s);
+        }
+        if (req->tags[i].t == NEU_JSON_ARRAY_BOOL &&
+            req->tags[i].value.val_array_bool.length > 0) {
+            free(req->tags[i].value.val_array_bool.bools);
         }
     }
     free(req->tags);
@@ -1170,9 +1249,49 @@ void neu_json_decode_write_gtags_req_free(neu_json_write_gtags_req_t *req)
             if (req->groups[i].tags[k].t == NEU_JSON_STR) {
                 free(req->groups[i].tags[k].value.val_str);
             }
-            if (req->groups[i].tags[k].t == NEU_JSON_BYTES &&
-                req->groups[i].tags[k].value.val_bytes.length > 0) {
-                free(req->groups[i].tags[k].value.val_bytes.bytes);
+            if (req->groups[i].tags[k].t == NEU_JSON_ARRAY_INT8 &&
+                req->groups[i].tags[k].value.val_array_int8.length > 0) {
+                free(req->groups[i].tags[k].value.val_array_int8.i8s);
+            }
+            if (req->groups[i].tags[k].t == NEU_JSON_ARRAY_UINT8 &&
+                req->groups[i].tags[k].value.val_array_uint8.length > 0) {
+                free(req->groups[i].tags[k].value.val_array_uint8.u8s);
+            }
+            if (req->groups[i].tags[k].t == NEU_JSON_ARRAY_INT16 &&
+                req->groups[i].tags[k].value.val_array_int16.length > 0) {
+                free(req->groups[i].tags[k].value.val_array_int16.i16s);
+            }
+            if (req->groups[i].tags[k].t == NEU_JSON_ARRAY_UINT16 &&
+                req->groups[i].tags[k].value.val_array_uint16.length > 0) {
+                free(req->groups[i].tags[k].value.val_array_uint16.u16s);
+            }
+            if (req->groups[i].tags[k].t == NEU_JSON_ARRAY_INT32 &&
+                req->groups[i].tags[k].value.val_array_int32.length > 0) {
+                free(req->groups[i].tags[k].value.val_array_int32.i32s);
+            }
+            if (req->groups[i].tags[k].t == NEU_JSON_ARRAY_UINT32 &&
+                req->groups[i].tags[k].value.val_array_uint32.length > 0) {
+                free(req->groups[i].tags[k].value.val_array_uint32.u32s);
+            }
+            if (req->groups[i].tags[k].t == NEU_JSON_ARRAY_INT64 &&
+                req->groups[i].tags[k].value.val_array_int64.length > 0) {
+                free(req->groups[i].tags[k].value.val_array_int64.i64s);
+            }
+            if (req->groups[i].tags[k].t == NEU_JSON_ARRAY_UINT64 &&
+                req->groups[i].tags[k].value.val_array_uint64.length > 0) {
+                free(req->groups[i].tags[k].value.val_array_uint64.u64s);
+            }
+            if (req->groups[i].tags[k].t == NEU_JSON_ARRAY_FLOAT &&
+                req->groups[i].tags[k].value.val_array_float.length > 0) {
+                free(req->groups[i].tags[k].value.val_array_float.f32s);
+            }
+            if (req->groups[i].tags[k].t == NEU_JSON_ARRAY_DOUBLE &&
+                req->groups[i].tags[k].value.val_array_double.length > 0) {
+                free(req->groups[i].tags[k].value.val_array_double.f64s);
+            }
+            if (req->groups[i].tags[k].t == NEU_JSON_ARRAY_BOOL &&
+                req->groups[i].tags[k].value.val_array_bool.length > 0) {
+                free(req->groups[i].tags[k].value.val_array_bool.bools);
             }
         }
         if (req->groups[i].n_tag > 0) {

src/utils/http.c

@@ -319,6 +319,7 @@ int neu_http_response(nng_aio *aio, neu_err_code_e code, char *content)
     case NEU_ERR_TAG_ADDRESS_FORMAT_INVALID:
     case NEU_ERR_TAG_DESCRIPTION_TOO_LONG:
     case NEU_ERR_TAG_PRECISION_INVALID:
+    case NEU_ERR_TAG_DECIMAL_INVALID:
     case NEU_ERR_TAG_NAME_TOO_LONG:
     case NEU_ERR_TAG_ADDRESS_TOO_LONG:
     case NEU_ERR_PLUGIN_TAG_TYPE_MISMATCH:

src/utils/json.c

@@ -128,15 +128,125 @@ static json_t *encode_object(json_t *object, neu_json_elem_t ele)
     case NEU_JSON_BOOL:
         json_object_set_new(ob, ele.name, json_boolean(ele.v.val_bool));
         break;
-    case NEU_JSON_BYTES: {
-        void *bytes = json_array();
+    case NEU_JSON_ARRAY_BOOL: {
+        void *array = json_array();
 
-        for (int i = 0; i < ele.v.val_bytes.length; i++) {
-            json_array_append_new(bytes,
-                                  json_integer(ele.v.val_bytes.bytes[i]));
+        for (int i = 0; i < ele.v.val_array_bool.length; i++) {
+            json_array_append_new(array,
+                                  json_boolean(ele.v.val_array_bool.bools[i]));
         }
 
-        json_object_set_new(ob, ele.name, bytes);
+        json_object_set_new(ob, ele.name, array);
+        break;
+    }
+    case NEU_JSON_ARRAY_INT8: {
+        void *array = json_array();
+
+        for (int i = 0; i < ele.v.val_array_int8.length; i++) {
+            json_array_append_new(array,
+                                  json_integer(ele.v.val_array_int8.i8s[i]));
+        }
+
+        json_object_set_new(ob, ele.name, array);
+        break;
+    }
+    case NEU_JSON_ARRAY_UINT8: {
+        void *array = json_array();
+
+        for (int i = 0; i < ele.v.val_array_uint8.length; i++) {
+            json_array_append_new(array,
+                                  json_integer(ele.v.val_array_uint8.u8s[i]));
+        }
+
+        json_object_set_new(ob, ele.name, array);
+        break;
+    }
+    case NEU_JSON_ARRAY_INT16: {
+        void *array = json_array();
+
+        for (int i = 0; i < ele.v.val_array_int16.length; i++) {
+            json_array_append_new(array,
+                                  json_integer(ele.v.val_array_int16.i16s[i]));
+        }
+
+        json_object_set_new(ob, ele.name, array);
+        break;
+    }
+    case NEU_JSON_ARRAY_UINT16: {
+        void *array = json_array();
+
+        for (int i = 0; i < ele.v.val_array_uint16.length; i++) {
+            json_array_append_new(array,
+                                  json_integer(ele.v.val_array_uint16.u16s[i]));
+        }
+
+        json_object_set_new(ob, ele.name, array);
+        break;
+    }
+    case NEU_JSON_ARRAY_INT32: {
+        void *array = json_array();
+
+        for (int i = 0; i < ele.v.val_array_int32.length; i++) {
+            json_array_append_new(array,
+                                  json_integer(ele.v.val_array_int32.i32s[i]));
+        }
+
+        json_object_set_new(ob, ele.name, array);
+        break;
+    }
+    case NEU_JSON_ARRAY_UINT32: {
+        void *array = json_array();
+
+        for (int i = 0; i < ele.v.val_array_uint32.length; i++) {
+            json_array_append_new(array,
+                                  json_integer(ele.v.val_array_uint32.u32s[i]));
+        }
+
+        json_object_set_new(ob, ele.name, array);
+        break;
+    }
+    case NEU_JSON_ARRAY_INT64: {
+        void *array = json_array();
+
+        for (int i = 0; i < ele.v.val_array_int64.length; i++) {
+            json_array_append_new(array,
+                                  json_integer(ele.v.val_array_int64.i64s[i]));
+        }
+
+        json_object_set_new(ob, ele.name, array);
+        break;
+    }
+    case NEU_JSON_ARRAY_UINT64: {
+        void *array = json_array();
+
+        for (int i = 0; i < ele.v.val_array_uint64.length; i++) {
+            json_array_append_new(array,
+                                  json_integer(ele.v.val_array_uint64.u64s[i]));
+        }
+
+        json_object_set_new(ob, ele.name, array);
+        break;
+    }
+    case NEU_JSON_ARRAY_FLOAT: {
+        void *array = json_array();
+
+        for (int i = 0; i < ele.v.val_array_float.length; i++) {
+            json_array_append_new(array,
+                                  json_real(ele.v.val_array_float.f32s[i]));
+        }
+
+        json_object_set_new(ob, ele.name, array);
+        break;
+    }
+    case NEU_JSON_ARRAY_DOUBLE: {
+        void *array = json_array();
+
+        for (int i = 0; i < ele.v.val_array_double.length; i++) {
+            json_array_append_new(array,
+                                  json_real(ele.v.val_array_double.f64s[i]));
+        }
+
+        json_object_set_new(ob, ele.name, array);
         break;
     }
     case NEU_JSON_OBJECT:
@@ -177,7 +287,20 @@ static int decode_object(json_t *root, neu_json_elem_t *ele)
         } else if (json_is_integer(ob)) {
             ele->t = NEU_JSON_INT;
         } else if (json_is_array(ob)) {
-            ele->t = NEU_JSON_BYTES;
+            json_t *value = NULL;
+            int     index = 0;
+            ele->t        = NEU_JSON_ARRAY_INT64;
+            json_array_foreach(ob, index, value)
+            {
+                if (json_is_real(value)) {
+                    ele->t = NEU_JSON_ARRAY_DOUBLE;
+                    break;
+                }
+                if (json_is_boolean(value)) {
+                    ele->t = NEU_JSON_ARRAY_BOOL;
+                    break;
+                }
+            }
         }
     }
 
@@ -217,19 +340,62 @@ static int decode_object(json_t *root, neu_json_elem_t *ele)
     case NEU_JSON_BOOL:
         ele->v.val_bool = json_boolean_value(ob);
         break;
-    case NEU_JSON_BYTES: {
+    case NEU_JSON_ARRAY_BOOL: {
         json_t *value = NULL;
 
-        ele->v.val_bytes.length = json_array_size(ob);
-        if (ele->v.val_bytes.length > 0) {
+        ele->v.val_array_bool.length = json_array_size(ob);
+        if (ele->v.val_array_bool.length > 0) {
             int index = 0;
 
-            ele->v.val_bytes.bytes =
-                calloc(ele->v.val_bytes.length, sizeof(uint8_t));
+            ele->v.val_array_bool.bools =
+                calloc(ele->v.val_array_bool.length, sizeof(bool));
             json_array_foreach(ob, index, value)
             {
-                ele->v.val_bytes.bytes[index] =
-                    (uint8_t) json_integer_value(value);
+                ele->v.val_array_bool.bools[index] = json_boolean_value(value);
+            }
+        }
+        break;
+    }
+    case NEU_JSON_ARRAY_INT64: {
+        json_t *value = NULL;
+
+        ele->v.val_array_int64.length = json_array_size(ob);
+        if (ele->v.val_array_int64.length > 0) {
+            int index = 0;
+
+            ele->v.val_array_int64.i64s =
+                calloc(ele->v.val_array_int64.length, sizeof(int64_t));
+            json_array_foreach(ob, index, value)
+            {
+                if (json_is_real(value)) {
+                    ele->v.val_array_int64.i64s[index] =
+                        (int64_t) json_real_value(value);
+                } else {
+                    ele->v.val_array_int64.i64s[index] =
+                        json_integer_value(value);
+                }
+            }
+        }
+        break;
+    }
+    case NEU_JSON_ARRAY_DOUBLE: {
+        json_t *value = NULL;
+
+        ele->v.val_array_double.length = json_array_size(ob);
+        if (ele->v.val_array_double.length > 0) {
+            int index = 0;
+
+            ele->v.val_array_double.f64s =
+                calloc(ele->v.val_array_double.length, sizeof(double));
+            json_array_foreach(ob, index, value)
+            {
+                if (json_is_integer(value)) {
+                    ele->v.val_array_double.f64s[index] =
+                        (double) json_integer_value(value);
+                } else {
+                    ele->v.val_array_double.f64s[index] =
+                        json_real_value(value);
+                }
             }
         }
         break;

tests/ft/app/test_ekuiper.py

@@ -159,6 +159,7 @@ class Mocker:
 
     def recv(self):
         msg = self.sock.recv()
+        msg = msg[26:]
         return json.loads(msg.decode())
 
     def send(self, data):

tests/ft/neuron/config.py

@@ -45,6 +45,19 @@ NEU_TYPE_LWORD = 18
 NEU_TYPE_PTR = 19
 NEU_TYPE_TIME = 20
 NEU_TYPE_DATA_AND_TIME = 21
+NEU_TYPE_ARRAY_CHAR    = 22
+NEU_TYPE_ARRAY_INT8    = 23
+NEU_TYPE_ARRAY_UINT8   = 24
+NEU_TYPE_ARRAY_INT16   = 25
+NEU_TYPE_ARRAY_UINT16  = 26
+NEU_TYPE_ARRAY_INT32   = 27
+NEU_TYPE_ARRAY_UINT32  = 28
+NEU_TYPE_ARRAY_INT64   = 29
+NEU_TYPE_ARRAY_UINT64  = 30
+NEU_TYPE_ARRAY_FLOAT   = 31
+NEU_TYPE_ARRAY_DOUBLE  = 32
+NEU_TYPE_ARRAY_BOOL    = 33
+NEU_TYPE_CUSTOM        = 40
 
 NEU_BAUD_115200 = 0
 NEU_BAUD_57600 = 1

tests/ft/neuron/error.py

@@ -53,6 +53,7 @@ NEU_ERR_TAG_ADDRESS_TOO_LONG = 2207
 NEU_ERR_TAG_DESCRIPTION_TOO_LONG = 2208
 NEU_ERR_TAG_PRECISION_INVALID = 2209
 NEU_ERR_TAG_EXIST = 2210
+NEU_ERR_TAG_DECIMAL_INVALID = 2211
 NEU_ERR_TAG_BIAS_INVALID = 2212
 
 NEU_ERR_LIBRARY_NOT_FOUND = 2301

tests/ft/tag/test_tag.py

@@ -916,3 +916,34 @@ class TestTag:
                 api.del_tags(
                     node="modbus-tcp", group="group1", tags=[tag["name"]]
                 )
+
+    @description(given="node and group", when="add string tag with decimal", then="add fail")
+    def test_add_string_tag_with_decimal(self):
+        string_decimal = [{"name": "string_decimal", "address": "1!400001.10",
+                    "attribute": NEU_TAG_ATTRIBUTE_RW, "type": NEU_TYPE_STRING, "decimal": 0.1}]
+        response = api.add_tags(node="modbus-tcp", group="group1", tags=string_decimal)
+        assert 400 == response.status_code
+        assert NEU_ERR_TAG_DECIMAL_INVALID == response.json()['error']
+
+    @description(given="node and group", when="add string gtags with decimal", then="add fail")
+    def test_add_string_tag_with_decimal(self):
+        response = api.add_gtags(
+            node='modbus-tcp', 
+            groups=[
+                {"group": "group_ok","interval": 3000,
+                     "tags": [{
+                            "name": "tag_string_ok",
+                            "address": "1!400001.10",
+                            "attribute": 3,
+                            "type": NEU_TYPE_STRING}]},
+                {"group": "group123","interval": 3000,
+                     "tags": [{
+                            "name": "tag_string_decimal",
+                            "address": "1!400001.10",
+                            "attribute": 3,
+                            "type": NEU_TYPE_STRING,
+                            "decimal": 0.01}]}
+                ])
+        assert 400 == response.status_code
+        assert NEU_ERR_TAG_DECIMAL_INVALID == response.json()['error']
+        assert 1 == response.json()['index']

version

@@ -1 +1 @@
-2.10.0
+2.10.1