From 8b3b94aa68ad5c0bedbeef250206c403d90eaf52 Mon Sep 17 00:00:00 2001 From: ypc <15051963820@163.com> Date: Tue, 19 May 2026 16:26:20 +0800 Subject: [PATCH] =?UTF-8?q?<=E4=BF=AE=E6=94=B9>=201=E3=80=81=E5=AE=8C?= =?UTF-8?q?=E6=88=90=E4=BA=86=E5=8F=82=E6=95=B0=E6=96=87=E4=BB=B6=E7=9A=84?= =?UTF-8?q?=E7=94=9F=E6=88=90=E5=8A=9F=E8=83=BD=202=E3=80=81=E8=B0=83?= =?UTF-8?q?=E6=95=B4=E4=BA=86=E9=83=A8=E5=88=86=E9=85=8D=E7=BD=AE=E6=96=87?= =?UTF-8?q?=E4=BB=B6?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- release/inc/mySystem.h | 2 +- src/protocol/libmms_m/src/mms_m_parse_cfg.cpp | 8 +- src/system/RTU/src/self_ptl_cfg.cpp | 15 +- src/system/libdatacenter/inc/dc_signal.h | 17 - src/system/libdatacenter/src/dc_param.cpp | 175 +- src/system/libdatacenter/src/dc_siganl.cpp | 338 ++-- src/system/libself_ptl/src/method.cpp | 2 + src/system/libself_ptl/src/self_ptl.cpp | 49 +- test/file/MMS/prj.xml | 4 +- test/file/PARAM/param.xml | 1581 ++++++++++++++++- 10 files changed, 1798 insertions(+), 393 deletions(-) diff --git a/release/inc/mySystem.h b/release/inc/mySystem.h index 7db4a13..40d96d9 100644 --- a/release/inc/mySystem.h +++ b/release/inc/mySystem.h @@ -253,7 +253,7 @@ typedef struct { stru_self_ptl_cfg_base base; uint8_t type; - uint8_t dc_type; + // uint8_t dc_type; uint8_t num; std::string unit; std::string min; diff --git a/src/protocol/libmms_m/src/mms_m_parse_cfg.cpp b/src/protocol/libmms_m/src/mms_m_parse_cfg.cpp index 3d4d48c..483a160 100644 --- a/src/protocol/libmms_m/src/mms_m_parse_cfg.cpp +++ b/src/protocol/libmms_m/src/mms_m_parse_cfg.cpp @@ -27,12 +27,12 @@ static const char *KEY_LDEV = "LDev"; static const char *KEY_LNODE = "LNode"; static const char *KEY_DONAME = "DoName"; static const char *KEY_FC = "fc"; -static const char *KEY_MIN_VAL = "minVal"; -static const char *KEY_MAX_VAL = "maxVal"; -static const char *KEY_STEP_VAL = "stepVal"; +static const char *KEY_MIN_VAL = "min"; +static const char *KEY_MAX_VAL = "max"; +static const char *KEY_STEP_VAL = "step"; static const char *KEY_UNIT = "unit"; -static const char *KEY_VAL = "val"; +static const char *KEY_VAL = "value"; static const char *KEY_DEFAULT_VAL = "default"; diff --git a/src/system/RTU/src/self_ptl_cfg.cpp b/src/system/RTU/src/self_ptl_cfg.cpp index d79d149..d273330 100644 --- a/src/system/RTU/src/self_ptl_cfg.cpp +++ b/src/system/RTU/src/self_ptl_cfg.cpp @@ -182,7 +182,7 @@ int parse_ao(tinyxml2::XMLElement *root) continue; } const char *type = signal_ele->Attribute(attr_type); - const char *dc_type = signal_ele->Attribute(attr_dc_type); + // const char *dc_type = signal_ele->Attribute(attr_dc_type); const char *unit = signal_ele->Attribute(attr_unit); const char *min = signal_ele->Attribute(attr_min); const char *max = signal_ele->Attribute(attr_max); @@ -194,7 +194,7 @@ int parse_ao(tinyxml2::XMLElement *root) cfg_ao.base.desc = desc == nullptr ? "" : desc; cfg_ao.base.inf = inf; cfg_ao.type = dc_get_data_type_id_by_str(type == nullptr ? "" : type); - cfg_ao.dc_type = dc_get_data_type_id_by_str(dc_type == nullptr ? "" : dc_type); + // cfg_ao.dc_type = dc_get_data_type_id_by_str(dc_type == nullptr ? "" : dc_type); cfg_ao.unit = unit == nullptr ? "" : unit; cfg_ao.min = min == nullptr ? "" : min; cfg_ao.max = max == nullptr ? "" : max; @@ -205,17 +205,10 @@ int parse_ao(tinyxml2::XMLElement *root) cfg_ao.default_value.push_back(default_value == nullptr ? "" : default_value); g_self_ptl_cfg.ao_vec.push_back(cfg_ao); - - if(inf == 0 && cfg_ao.type == DATA_TYPE_C64) - { - MY_LOG_I("saddr %s, desc %s", cfg_ao.base.saddr.c_str(), cfg_ao.base.desc.c_str()); - } signal_ele = signal_ele->NextSiblingElement(ele_Signal); } - MY_LOG_I("ao signals: %d", (int)g_self_ptl_cfg.ao_vec.size()); - return 0; } @@ -274,7 +267,7 @@ int parse_param(tinyxml2::XMLElement *root) continue; } const char *type = signal_ele->Attribute(attr_type); - const char *dc_type = signal_ele->Attribute(attr_dc_type); + // const char *dc_type = signal_ele->Attribute(attr_dc_type); const char *unit = signal_ele->Attribute(attr_unit); const char *min = signal_ele->Attribute(attr_min); const char *max = signal_ele->Attribute(attr_max); @@ -285,7 +278,7 @@ int parse_param(tinyxml2::XMLElement *root) cfg_param.base.desc = desc != nullptr ? desc : ""; cfg_param.base.inf = inf; cfg_param.type = dc_get_data_type_id_by_str(type != nullptr ? type : ""); - cfg_param.dc_type = dc_get_data_type_id_by_str(dc_type != nullptr ? dc_type : ""); + // cfg_param.dc_type = dc_get_data_type_id_by_str(dc_type != nullptr ? dc_type : ""); cfg_param.num = num != nullptr ? atoi(num) : 0; cfg_param.unit = unit != nullptr ? unit : ""; cfg_param.min = min != nullptr ? min : ""; diff --git a/src/system/libdatacenter/inc/dc_signal.h b/src/system/libdatacenter/inc/dc_signal.h index 0752aa1..45b0f8d 100644 --- a/src/system/libdatacenter/inc/dc_signal.h +++ b/src/system/libdatacenter/inc/dc_signal.h @@ -28,23 +28,6 @@ typedef struct stru_signal }stru_signal; -// 参数分组信息（用于XML序列化） -typedef struct -{ - std::string saddr; - std::string desc; - uint8_t data_type; - int num; - float min, max, step; - std::string unit; - - std::vector val; - std::vector default_val; -} dc_param_group_info; - -void dc_param_group_add(const dc_param_group_info &group); -std::vector dc_param_group_get_all(); -void dc_param_group_clear(); void dc_set_signal_val_from_str(void *p_data, uint8_t data_type, const std::string &str); bool dc_get_param_cfg_change(); diff --git a/src/system/libdatacenter/src/dc_param.cpp b/src/system/libdatacenter/src/dc_param.cpp index 164f202..740139f 100644 --- a/src/system/libdatacenter/src/dc_param.cpp +++ b/src/system/libdatacenter/src/dc_param.cpp @@ -12,8 +12,6 @@ void dc_param_cfg_parse() return; } - dc_param_group_clear(); - XMLElement *root = doc.RootElement(); if (nullptr == root) { @@ -49,19 +47,6 @@ void dc_param_cfg_parse() float step = sig->FloatAttribute("step", 0.0f); const char *unit = sig->Attribute("unit"); - dc_param_group_info group; - group.saddr = std::string(saddr); - group.desc = std::string(desc); - group.data_type = data_type; - group.min = min; - group.max = max; - group.step = step; - group.unit = unit ? std::string(unit) : std::string(); - group.num = -1; - - std::vector vec_p_data; - std::vector vec_p_default_data; - // Ao 段：从 Signal 属性读取单值 const char *val = sig->Attribute("value"); const char *default_val = sig->Attribute("default"); @@ -73,7 +58,6 @@ void dc_param_cfg_parse() dc_set_signal_val_from_str(p_data, data_type, std::string(val)); else if (default_val && strlen(default_val) > 0) dc_set_signal_val_from_str(p_data, data_type, std::string(default_val)); - vec_p_data.push_back(p_data); } void *p_default_data = dc_create_data_ptr_by_type(data_type); @@ -81,23 +65,20 @@ void dc_param_cfg_parse() { if (default_val && strlen(default_val) > 0) dc_set_signal_val_from_str(p_default_data, data_type, std::string(default_val)); - vec_p_default_data.push_back(p_default_data); } - if (!vec_p_data.empty()) + if (p_data && p_default_data) { stru_signal_param param; - param.min = group.min; - param.max = group.max; - param.step = group.step; - param.unit = group.unit; + param.min = min; + param.max = max; + param.step = step; + param.unit = unit ? std::string(unit) : std::string(); - dc_signal_param(group.saddr, group.desc, group.data_type, param, + dc_signal_ao(saddr, desc, data_type, param, SIGNAL_CTRL_TYPE::SBO_NORMAL, - vec_p_data, vec_p_default_data, nullptr); + p_data, p_default_data, nullptr); } - - dc_param_group_add(group); } } @@ -129,22 +110,12 @@ void dc_param_cfg_parse() float step = sig->FloatAttribute("step", 0.0f); const char *unit = sig->Attribute("unit"); - dc_param_group_info group; - group.saddr = std::string(saddr); - group.desc = std::string(desc); - group.data_type = data_type; - group.min = min; - group.max = max; - group.step = step; - group.unit = unit ? std::string(unit) : std::string(); - std::vector vec_p_data; std::vector vec_p_default_data; int num = sig->IntAttribute("num", -1); if (num >= 1) { - int item_count = 0; for (XMLElement *item = sig->FirstChildElement("Item"); item != nullptr; item = item->NextSiblingElement("Item")) { @@ -168,144 +139,28 @@ void dc_param_cfg_parse() dc_set_signal_val_from_str(p_default_data, data_type, std::string(default_val)); vec_p_default_data.push_back(p_default_data); } - - item_count++; } - group.num = item_count; + } else { - group.num = -1; + continue; } if (!vec_p_data.empty()) { stru_signal_param param; - param.min = group.min; - param.max = group.max; - param.step = group.step; - param.unit = group.unit; + param.min = min; + param.max = max; + param.step = step; + param.unit = unit ? std::string(unit) : std::string(); - dc_signal_param(group.saddr, group.desc, group.data_type, param, + dc_signal_param(saddr, desc, data_type, param, SIGNAL_CTRL_TYPE::SBO_NORMAL, vec_p_data, vec_p_default_data, nullptr); } - - dc_param_group_add(group); } } - // 兼容旧格式：Signal 直接作为 root 子元素（无 Ao/Param 分组） - if (!ao_elem && !param_elem) - { - for (XMLElement *sig = root->FirstChildElement("Signal"); sig != nullptr; - sig = sig->NextSiblingElement("Signal")) - { - const char *saddr = sig->Attribute("saddr"); - const char *desc = sig->Attribute("desc"); - const char *type_str = sig->Attribute("type"); - if (nullptr == saddr || nullptr == desc || nullptr == type_str) - { - MY_LOG_E("Signal missing required attributes, skipping"); - continue; - } - - uint8_t data_type = dc_get_data_type_id_by_str(type_str); - if (0 == data_type) - { - MY_LOG_E("unknown data type %s for saddr %s", type_str, saddr); - continue; - } - - float min = sig->FloatAttribute("min", 0.0f); - float max = sig->FloatAttribute("max", 0.0f); - float step = sig->FloatAttribute("step", 0.0f); - const char *unit = sig->Attribute("unit"); - - dc_param_group_info group; - group.saddr = std::string(saddr); - group.desc = std::string(desc); - group.data_type = data_type; - group.min = min; - group.max = max; - group.step = step; - group.unit = unit ? std::string(unit) : std::string(); - - std::vector vec_p_data; - std::vector vec_p_default_data; - - int num = sig->IntAttribute("num", -1); - if (num >= 1) - { - int item_count = 0; - for (XMLElement *item = sig->FirstChildElement("Item"); item != nullptr; - item = item->NextSiblingElement("Item")) - { - const char *val = item->Attribute("value"); - const char *default_val = item->Attribute("default"); - - void *p_data = dc_create_data_ptr_by_type(data_type); - if (p_data) - { - if (val && strlen(val) > 0) - dc_set_signal_val_from_str(p_data, data_type, std::string(val)); - else if (default_val && strlen(default_val) > 0) - dc_set_signal_val_from_str(p_data, data_type, std::string(default_val)); - vec_p_data.push_back(p_data); - } - - void *p_default_data = dc_create_data_ptr_by_type(data_type); - if (p_default_data) - { - if (default_val && strlen(default_val) > 0) - dc_set_signal_val_from_str(p_default_data, data_type, std::string(default_val)); - vec_p_default_data.push_back(p_default_data); - } - - item_count++; - } - group.num = item_count; - } - else - { - group.num = -1; - - const char *val = sig->Attribute("value"); - const char *default_val = sig->Attribute("default"); - - void *p_data = dc_create_data_ptr_by_type(data_type); - if (p_data) - { - if (val && strlen(val) > 0) - dc_set_signal_val_from_str(p_data, data_type, std::string(val)); - else if (default_val && strlen(default_val) > 0) - dc_set_signal_val_from_str(p_data, data_type, std::string(default_val)); - vec_p_data.push_back(p_data); - } - - void *p_default_data = dc_create_data_ptr_by_type(data_type); - if (p_default_data) - { - if (default_val && strlen(default_val) > 0) - dc_set_signal_val_from_str(p_default_data, data_type, std::string(default_val)); - vec_p_default_data.push_back(p_default_data); - } - } - - if (!vec_p_data.empty()) - { - stru_signal_param param; - param.min = group.min; - param.max = group.max; - param.step = group.step; - param.unit = group.unit; - - dc_signal_param(group.saddr, group.desc, group.data_type, param, - SIGNAL_CTRL_TYPE::SBO_NORMAL, - vec_p_data, vec_p_default_data, nullptr); - } - - dc_param_group_add(group); - } - } + } diff --git a/src/system/libdatacenter/src/dc_siganl.cpp b/src/system/libdatacenter/src/dc_siganl.cpp index 4be3055..4045f6c 100644 --- a/src/system/libdatacenter/src/dc_siganl.cpp +++ b/src/system/libdatacenter/src/dc_siganl.cpp @@ -64,8 +64,6 @@ static stru_datacenter g_datacenter; LOCAL bool g_param_cfg_change = false; LOCAL std::mutex g_param_cfg_change_mutex; -LOCAL std::vector g_param_groups; -LOCAL std::mutex g_param_groups_mutex; LOCAL int dc_data_compare(uint8_t data_type, void *p_data, void *p_data2); @@ -264,84 +262,84 @@ void dc_signal_out_change_check() } } -LOCAL void dc_signal_ctrl_data_create(stru_signal_ctrl &ctrl) -{ - switch(ctrl.data_type) - { - case DATA_TYPE_B: - case DATA_TYPE_U8: - ctrl.p_data = new uint8_t; - *(uint8_t *)ctrl.p_data = 0; - break; - case DATA_TYPE_S8: - ctrl.p_data = new int8_t; - *(int8_t *)ctrl.p_data = 0; - break; - case DATA_TYPE_S16: - ctrl.p_data = new int16_t; - *(int16_t *)ctrl.p_data = 0; - break; - case DATA_TYPE_U16: - ctrl.p_data = new uint16_t; - *(uint16_t *)ctrl.p_data = 0; - break; - case DATA_TYPE_S32: - ctrl.p_data = new int32_t; - *(int32_t *)ctrl.p_data = 0; - break; - case DATA_TYPE_U32: - ctrl.p_data = new uint32_t; - *(uint32_t *)ctrl.p_data = 0; - break; - case DATA_TYPE_L64: - ctrl.p_data = new int64_t; - *(int64_t *)ctrl.p_data = 0; - break; - case DATA_TYPE_UL64: - ctrl.p_data = new uint64_t; - *(uint64_t *)ctrl.p_data = 0; - break; - case DATA_TYPE_F32: - ctrl.p_data = new float; - *(float *)ctrl.p_data = 0; - break; - case DATA_TYPE_D64: - ctrl.p_data = new double; - *(double *)ctrl.p_data = 0; - break; - case DATA_TYPE_IP: - ctrl.p_data = new char[4]; - memset(ctrl.p_data, 0, 4); - break; - case DATA_TYPE_MAC: - ctrl.p_data = new char[8]; - memset(ctrl.p_data, 0, 8); - break; - case DATA_TYPE_C1: - ctrl.p_data = new char; - *(char *)ctrl.p_data = 0; - break; - case DATA_TYPE_C8: - ctrl.p_data = new char[8]; - memset(ctrl.p_data, 0, 8); - break; - case DATA_TYPE_C32: - ctrl.p_data = new char[32]; - memset(ctrl.p_data, 0, 32); - break; - case DATA_TYPE_C64: - ctrl.p_data = new char[64]; - memset(ctrl.p_data, 0, 64); - break; - case DATA_TYPE_C128: - ctrl.p_data = new char[128]; - memset(ctrl.p_data, 0, 128); - break; - default: - LOG_E("unsupported data type %d", ctrl.data_type); - break; - } -} +// LOCAL void dc_signal_ctrl_data_create(stru_signal_ctrl &ctrl) +// { +// switch(ctrl.data_type) +// { +// case DATA_TYPE_B: +// case DATA_TYPE_U8: +// ctrl.p_data = new uint8_t; +// *(uint8_t *)ctrl.p_data = 0; +// break; +// case DATA_TYPE_S8: +// ctrl.p_data = new int8_t; +// *(int8_t *)ctrl.p_data = 0; +// break; +// case DATA_TYPE_S16: +// ctrl.p_data = new int16_t; +// *(int16_t *)ctrl.p_data = 0; +// break; +// case DATA_TYPE_U16: +// ctrl.p_data = new uint16_t; +// *(uint16_t *)ctrl.p_data = 0; +// break; +// case DATA_TYPE_S32: +// ctrl.p_data = new int32_t; +// *(int32_t *)ctrl.p_data = 0; +// break; +// case DATA_TYPE_U32: +// ctrl.p_data = new uint32_t; +// *(uint32_t *)ctrl.p_data = 0; +// break; +// case DATA_TYPE_L64: +// ctrl.p_data = new int64_t; +// *(int64_t *)ctrl.p_data = 0; +// break; +// case DATA_TYPE_UL64: +// ctrl.p_data = new uint64_t; +// *(uint64_t *)ctrl.p_data = 0; +// break; +// case DATA_TYPE_F32: +// ctrl.p_data = new float; +// *(float *)ctrl.p_data = 0; +// break; +// case DATA_TYPE_D64: +// ctrl.p_data = new double; +// *(double *)ctrl.p_data = 0; +// break; +// case DATA_TYPE_IP: +// ctrl.p_data = new char[4]; +// memset(ctrl.p_data, 0, 4); +// break; +// case DATA_TYPE_MAC: +// ctrl.p_data = new char[8]; +// memset(ctrl.p_data, 0, 8); +// break; +// case DATA_TYPE_C1: +// ctrl.p_data = new char; +// *(char *)ctrl.p_data = 0; +// break; +// case DATA_TYPE_C8: +// ctrl.p_data = new char[8]; +// memset(ctrl.p_data, 0, 8); +// break; +// case DATA_TYPE_C32: +// ctrl.p_data = new char[32]; +// memset(ctrl.p_data, 0, 32); +// break; +// case DATA_TYPE_C64: +// ctrl.p_data = new char[64]; +// memset(ctrl.p_data, 0, 64); +// break; +// case DATA_TYPE_C128: +// ctrl.p_data = new char[128]; +// memset(ctrl.p_data, 0, 128); +// break; +// default: +// LOG_E("unsupported data type %d", ctrl.data_type); +// break; +// } +// } LOCAL int dc_data_compare(uint8_t data_type, void *p_data, void *p_data2) { @@ -351,6 +349,11 @@ LOCAL int dc_data_compare(uint8_t data_type, void *p_data, void *p_data2) return -1; } + float f1 = 0.0f; + float f2 = 0.0f; + double d1 = 0.0; + double d2 = 0.0; + switch(data_type) { case DATA_TYPE_B: @@ -371,12 +374,12 @@ LOCAL int dc_data_compare(uint8_t data_type, void *p_data, void *p_data2) case DATA_TYPE_UL64: return (*(uint64_t *)p_data == *(uint64_t *)p_data2) ? 0 : -1; case DATA_TYPE_F32: - float f1 = *(float *)p_data; - float f2 = *(float *)p_data2; + f1 = *(float *)p_data; + f2 = *(float *)p_data2; return f1 == f2 ? 0 : -1; case DATA_TYPE_D64: - double d1 = *(double *)p_data; - double d2 = *(double *)p_data2; + d1 = *(double *)p_data; + d2 = *(double *)p_data2; return d1 == d2 ? 0 : -1; case DATA_TYPE_C1: return (*(char *)p_data == *(char *)p_data2) ? 0 : -1; @@ -386,6 +389,7 @@ LOCAL int dc_data_compare(uint8_t data_type, void *p_data, void *p_data2) case DATA_TYPE_C32: case DATA_TYPE_C64: case DATA_TYPE_C128: + case DATA_TYPE_STR: return (0 == strcmp((char *)p_data, (char *)p_data2)) ? 0 : -1; default: LOG_E("unsupported data type %d", data_type); @@ -429,10 +433,10 @@ LOCAL bool dc_signal_ao_add_check(stru_signal *p_signal, const std::string &desc change = true; } - if(0 != dc_data_compare(p_signal->data_type, p_data, p_signal->vec_p_data[0])) - { - change = true; - } + // if(0 != dc_data_compare(p_signal->data_type, p_data, p_signal->vec_p_data[0])) + // { + // change = true; + // } if(0 != dc_data_compare(p_signal->data_type, p_default_data, p_signal->vec_p_default_data[0])) { @@ -470,13 +474,13 @@ LOCAL bool dc_signal_param_add_check(stru_signal *p_signal, const std::string &d change = true; } - for(size_t i = 0; i < vec_p_default_data.size(); i++) - { - if(0 != dc_data_compare(p_signal->data_type, vec_p_default_data[i], p_signal->vec_p_default_data[i])) - { - change = true; - } - } + // for(size_t i = 0; i < vec_p_default_data.size(); i++) + // { + // if(0 != dc_data_compare(p_signal->data_type, vec_p_default_data[i], p_signal->vec_p_default_data[i])) + // { + // change = true; + // } + // } for(size_t i = 0; i < vec_p_data.size(); i++) { @@ -597,7 +601,8 @@ LOCAL int dc_check_ctrl_val_valid(const stru_signal_ctrl &ctrl, const void *p_da LOG_E("direct ctrl value %c not match selected value %c", *(char*)p_data, *(char*)ctrl.p_data); return -1; } - }else if(ctrl.data_type == DATA_TYPE_C8 || ctrl.data_type == DATA_TYPE_C32 || ctrl.data_type == DATA_TYPE_C64 || ctrl.data_type == DATA_TYPE_C128) + } + else if(ctrl.data_type == DATA_TYPE_C8 || ctrl.data_type == DATA_TYPE_C32 || ctrl.data_type == DATA_TYPE_C64 || ctrl.data_type == DATA_TYPE_C128 || ctrl.data_type == DATA_TYPE_STR) { if(0 != strcmp((char *)ctrl.p_data, (char *)p_data)) { @@ -863,7 +868,8 @@ LOCAL int dc_check_val_valid(const stru_signal *p_signal, uint8_t setting_zone, p_signal->data_type == DATA_TYPE_C8 || p_signal->data_type == DATA_TYPE_C32 || p_signal->data_type == DATA_TYPE_C64 || - p_signal->data_type == DATA_TYPE_C128) + p_signal->data_type == DATA_TYPE_C128 || + p_signal->data_type == DATA_TYPE_STR) { if(0 == strcmp((char *)current_p_data, (char *)p_data)) { @@ -1148,7 +1154,7 @@ int dc_signal_ao(const std::string &saddr, const std::string &desc, uint8_t data XXH128_hash_t hash = XXH3_128bits(saddr.c_str(), saddr.length()); stru_signal *p_signal = dc_find_signal(hash, g_datacenter.signal_ao); - if(p_signal != nullptr) + if(p_signal != nullptr && !p_signal->vec_p_data.empty() && !p_signal->vec_p_default_data.empty() && nullptr != p_signal->vec_p_data[0] && nullptr != p_signal->vec_p_default_data[0]) { if(true == dc_signal_ao_add_check(p_signal, desc, data_type, param, ctrl_type, p_data, p_default_data)) { @@ -1269,6 +1275,8 @@ int dc_signal_ao_set_val(const std::string &saddr, SIGNAL_CTRL_STEP step, stru_s } } + dc_set_param_cfg_change(true); + return 0; } else @@ -1304,6 +1312,7 @@ int dc_signal_ao_set_val_without_check(const std::string &saddr, uint8_t data_ty } dc_set_signal_val(p_signal->vec_p_data[0], data_type, p_data); + dc_set_param_cfg_change(true); return 0; } else @@ -1348,7 +1357,17 @@ int dc_signal_param(const std::string &saddr, const std::string &desc, uint8_t d { // delete p_signal->vec_p_data[i]; dc_delete_signal_data(p_signal->vec_p_data[i], data_type); - p_signal->vec_p_data[i] = vec_p_data[i]; + dc_delete_signal_data(p_signal->vec_p_default_data[i], data_type); + // p_signal->vec_p_data[i] = vec_p_data[i]; + } + + p_signal->vec_p_data.clear(); + p_signal->vec_p_default_data.clear(); + + for(size_t i = 0; i < vec_p_data.size(); i++) + { + p_signal->vec_p_data.push_back(vec_p_data[i]); + p_signal->vec_p_default_data.push_back(vec_p_default_data[i]); } p_signal->change_cb_list.push_back(cb); @@ -1373,6 +1392,7 @@ int dc_signal_param(const std::string &saddr, const std::string &desc, uint8_t d for(size_t i = 0; i < vec_p_data.size(); i++) { p_signal->vec_p_data.push_back(vec_p_data[i]); + p_signal->vec_p_default_data.push_back(vec_p_default_data[i]); } if(cb) @@ -1462,6 +1482,8 @@ int dc_signal_param_set_val(const std::string &saddr, SIGNAL_CTRL_STEP step, str } } + dc_set_param_cfg_change(true); + return 0; } else @@ -1497,6 +1519,7 @@ int dc_signal_param_set_val_without_check(const std::string &saddr, uint8_t data } dc_set_signal_val(p_signal->vec_p_data[setting_zone], data_type, p_data); + dc_set_param_cfg_change(true); return 0; } @@ -1668,7 +1691,8 @@ LOCAL std::map g_data_type_str = { {DATA_TYPE_C32, "char32"}, {DATA_TYPE_C64, "char64"}, {DATA_TYPE_C128, "char128"}, - {DATA_TYPE_C1, "char1"} + {DATA_TYPE_C1, "char1"}, + {DATA_TYPE_STR, "str"} }; LOCAL std::map g_data_type_len = { @@ -1862,6 +1886,7 @@ LOCAL int dc_set_signal_val(void *p_data, uint8_t data_type, void *set_data) case DATA_TYPE_C32: case DATA_TYPE_C64: case DATA_TYPE_C128: + case DATA_TYPE_STR: strncpy((char *)p_data, (char *)set_data, dc_get_data_type_len(data_type)); break; case DATA_TYPE_C1: @@ -1940,6 +1965,7 @@ void dc_set_signal_val_from_str(void *p_data, uint8_t data_type, const std::stri case DATA_TYPE_C32: case DATA_TYPE_C64: case DATA_TYPE_C128: + case DATA_TYPE_STR: strncpy((char *)p_data, str.c_str(), dc_get_data_type_len(data_type)); break; case DATA_TYPE_C1: @@ -2117,24 +2143,6 @@ void dc_delete_signal_data(void *p_data, uint8_t data_type) -void dc_param_group_add(const dc_param_group_info &group) -{ - std::lock_guard lock(g_param_groups_mutex); - g_param_groups.push_back(group); -} - -void dc_param_group_clear() -{ - std::lock_guard lock(g_param_groups_mutex); - g_param_groups.clear(); -} - -std::vector dc_param_group_get_all() -{ - std::lock_guard lock(g_param_groups_mutex); - return g_param_groups; -} - void dc_param_cfg_check() { if (false == dc_get_param_cfg_change()) return; @@ -2144,73 +2152,59 @@ void dc_param_cfg_check() XMLDocument doc; doc.InsertEndChild(doc.NewDeclaration()); - XMLElement *root = doc.NewElement("param"); + XMLElement *root = doc.NewElement("Root"); doc.InsertEndChild(root); - XMLElement *ao_elem = doc.NewElement("Ao"); - XMLElement *param_elem = doc.NewElement("Param"); - - auto groups = dc_param_group_get_all(); int ao_no = 0, param_no = 0; - for (auto &group : groups) + XMLElement *ao_elem = doc.NewElement("Ao"); + + for(auto it = g_datacenter.signal_ao.map_signals.begin(); it != g_datacenter.signal_ao.map_signals.end(); it++) { + stru_signal *p_ao = &it->second; + XMLElement *sig_elem = doc.NewElement("Signal"); + sig_elem->SetAttribute("saddr", p_ao->saddr.c_str()); + sig_elem->SetAttribute("desc", p_ao->desc.c_str()); + sig_elem->SetAttribute("type", dc_get_data_type_str_by_id(p_ao->data_type).c_str()); + sig_elem->SetAttribute("min", p_ao->param.min); + sig_elem->SetAttribute("max", p_ao->param.max); + sig_elem->SetAttribute("step", p_ao->param.step); + sig_elem->SetAttribute("unit", p_ao->param.unit.c_str()); + sig_elem->SetAttribute("value", dc_get_signal_val(p_ao->vec_p_data[0], p_ao->data_type).c_str()); + sig_elem->SetAttribute("default", dc_get_signal_val(p_ao->vec_p_default_data[0], p_ao->data_type).c_str()); - std::string desc; - uint8_t data_type; - stru_signal_param param; - uint8_t ctrl_type; - std::vector vec_p_data; - std::vector vec_p_default_data; + ao_elem->InsertEndChild(sig_elem); + } - if (0 != dc_get_param_signal_info(group.saddr, desc, data_type, param, ctrl_type, vec_p_data, vec_p_default_data)) - continue; + XMLElement *param_elem = doc.NewElement("Param"); - if (group.num >= 1) + for(auto it = g_datacenter.signal_param.map_signals.begin(); it != g_datacenter.signal_param.map_signals.end(); it++) + { + stru_signal *p_param = &it->second; + + XMLElement *sig_elem = doc.NewElement("Signal"); + sig_elem->SetAttribute("saddr", p_param->saddr.c_str()); + sig_elem->SetAttribute("desc", p_param->desc.c_str()); + sig_elem->SetAttribute("type", dc_get_data_type_str_by_id(p_param->data_type).c_str()); + sig_elem->SetAttribute("min", p_param->param.min); + sig_elem->SetAttribute("max", p_param->param.max); + sig_elem->SetAttribute("step", p_param->param.step); + sig_elem->SetAttribute("unit", p_param->param.unit.c_str()); + sig_elem->SetAttribute("num", p_param->vec_p_data.size()); + + + for(int i = 0; i < p_param->vec_p_data.size(); i++) { - // Param 段：多值参数 - sig_elem->SetAttribute("no", param_no++); - sig_elem->SetAttribute("saddr", group.saddr.c_str()); - sig_elem->SetAttribute("desc", group.desc.c_str()); - sig_elem->SetAttribute("type", dc_get_data_type_str_by_id(group.data_type).c_str()); - sig_elem->SetAttribute("min", group.min); - sig_elem->SetAttribute("max", group.max); - sig_elem->SetAttribute("step", group.step); - sig_elem->SetAttribute("unit", group.unit.c_str()); - sig_elem->SetAttribute("num", group.num); + XMLElement *item_elem = doc.NewElement("Item"); + item_elem->SetAttribute("index", i+1); + item_elem->SetAttribute("val", dc_get_signal_val(p_param->vec_p_data[i], p_param->data_type).c_str()); + item_elem->SetAttribute("default", dc_get_signal_val(p_param->vec_p_default_data[i], p_param->data_type).c_str()); - for (int i = 0; i < group.num && i < (int)vec_p_data.size(); i++) - { - XMLElement *item = doc.NewElement("Item"); - item->SetAttribute("no", i); - item->SetAttribute("value", dc_get_signal_val(vec_p_data[i], data_type).c_str()); - item->SetAttribute("default", i < (int)vec_p_default_data.size() ? - dc_get_signal_val(vec_p_default_data[i], data_type).c_str() : ""); - sig_elem->InsertEndChild(item); - } - - param_elem->InsertEndChild(sig_elem); + sig_elem->InsertEndChild(item_elem); } - else - { - // Ao 段：单值参数 - sig_elem->SetAttribute("no", ao_no++); - sig_elem->SetAttribute("saddr", group.saddr.c_str()); - sig_elem->SetAttribute("desc", group.desc.c_str()); - sig_elem->SetAttribute("type", dc_get_data_type_str_by_id(group.data_type).c_str()); - sig_elem->SetAttribute("min", group.min); - sig_elem->SetAttribute("max", group.max); - sig_elem->SetAttribute("step", group.step); - sig_elem->SetAttribute("unit", group.unit.c_str()); - if (!vec_p_data.empty()) - sig_elem->SetAttribute("value", dc_get_signal_val(vec_p_data[0], data_type).c_str()); - if (!vec_p_default_data.empty()) - sig_elem->SetAttribute("default", dc_get_signal_val(vec_p_default_data[0], data_type).c_str()); - - ao_elem->InsertEndChild(sig_elem); - } + param_elem->InsertEndChild(sig_elem); } root->InsertEndChild(ao_elem); diff --git a/src/system/libself_ptl/src/method.cpp b/src/system/libself_ptl/src/method.cpp index 3885870..215349f 100644 --- a/src/system/libself_ptl/src/method.cpp +++ b/src/system/libself_ptl/src/method.cpp @@ -152,6 +152,8 @@ void ao_pop_out(stru_icp67 *p_icp67, uint16_t addr, uint8_t type, uint8_t len, u uint16_t pos = g_local_ao_get.offset + g_local_ao_get.rx_cnt; stru_self_ptl_cfg_param_data *p_ao_data = &p_app_cfg_data->ao_vec[pos]; + + if(p_ao_data->p_param->base.inf == addr && p_ao_data->p_param->type == type && dc_get_data_type_len(type) == len) { // dc_signal_param_set_val(p_ao_data->p_param->base.saddr, SIGNAL_CTRL_STEP::SELECT, type, p_data); diff --git a/src/system/libself_ptl/src/self_ptl.cpp b/src/system/libself_ptl/src/self_ptl.cpp index 94d50bf..6556859 100644 --- a/src/system/libself_ptl/src/self_ptl.cpp +++ b/src/system/libself_ptl/src/self_ptl.cpp @@ -470,7 +470,7 @@ LOCAL int self_ptl_cfg_init() stru_self_ptl_cfg *p_cfg = self_ptl_cfg_get(); if(nullptr == p_cfg) { - LOG_E("self_ptl_cfg_init self_ptl_cfg_get failed"); + MY_LOG_E("self_ptl_cfg_init self_ptl_cfg_get failed"); return -1; } @@ -504,7 +504,7 @@ LOCAL int self_ptl_cfg_init() stru_signal_ctrl *p_ctrl = new stru_signal_ctrl; if(nullptr == p_ctrl) { - LOG_E("self_ptl_cfg_init new stru_signal_ctrl failed"); + MY_LOG_E("self_ptl_cfg_init new stru_signal_ctrl failed"); return -1; } @@ -514,7 +514,7 @@ LOCAL int self_ptl_cfg_init() p_ctrl->p_data = dc_create_data_ptr_by_type(DATA_TYPE_U8); if(nullptr == p_ctrl->p_data) { - LOG_E("self_ptl_cfg_init dc_create_data_ptr_by_type failed, type:%d", DATA_TYPE_U8); + MY_LOG_E("self_ptl_cfg_init dc_create_data_ptr_by_type failed, type:%d", DATA_TYPE_U8); return -1; } @@ -538,34 +538,35 @@ LOCAL int self_ptl_cfg_init() stru_signal_ctrl *p_ctrl = new stru_signal_ctrl; if(nullptr == p_ctrl) { - LOG_E("self_ptl_cfg_init dc_create_data_ptr_by_type failed, type:%d", p_ao->type); + MY_LOG_E("self_ptl_cfg_init dc_create_data_ptr_by_type failed, type:%d", p_ao->type); return -1; } p_ctrl->type = SIGNAL_CTRL_TYPE::SBO_NORMAL; p_ctrl->step = SIGNAL_CTRL_STEP::READY; - p_ctrl->data_type = p_ao->dc_type; - p_ctrl->p_data = dc_create_data_ptr_by_type(p_ao->dc_type); + p_ctrl->data_type = p_ao->type; + p_ctrl->p_data = dc_create_data_ptr_by_type(p_ao->type); if(nullptr == p_ctrl->p_data) { - LOG_E("self_ptl_cfg_init dc_create_data_ptr_by_type failed, type:%d", p_ao->dc_type); + MY_LOG_E("self_ptl_cfg_init dc_create_data_ptr_by_type failed, type:%d, saddr %s, desc %s", + p_ao->type, p_ao->base.saddr.c_str(), p_ao->base.desc.c_str()); return -1; } p_cfg_data->ao_vec.push_back({p_ao, p_ctrl}); - void *p_data = dc_create_data_ptr_by_type(p_ao->dc_type); + void *p_data = dc_create_data_ptr_by_type(p_ao->type); if(nullptr == p_data) { - LOG_E("self_ptl_cfg_init dc_create_data_ptr_by_type failed, type:%d", p_ao->dc_type); + MY_LOG_E("self_ptl_cfg_init dc_create_data_ptr_by_type failed, type:%d", p_ao->type); return -1; } p_cfg_data->ao_vec.back().vec_p_data.push_back(p_data); - void *p_default_data = dc_create_data_ptr_by_type(p_ao->dc_type); + void *p_default_data = dc_create_data_ptr_by_type(p_ao->type); if(nullptr == p_default_data) { - LOG_E("self_ptl_cfg_init dc_create_data_ptr_by_type failed, type:%d", p_ao->dc_type); + MY_LOG_E("self_ptl_cfg_init dc_create_data_ptr_by_type failed, type:%d", p_ao->type); return -1; } p_cfg_data->ao_vec.back().vec_p_default_data.push_back(p_default_data); @@ -579,17 +580,17 @@ LOCAL int self_ptl_cfg_init() stru_signal_ctrl *p_ctrl = new stru_signal_ctrl; if(nullptr == p_ctrl) { - LOG_E("self_ptl_cfg_init dc_create_data_ptr_by_type failed, type:%d", p_param->dc_type); + MY_LOG_E("self_ptl_cfg_init dc_create_data_ptr_by_type failed, type:%d", p_param->type); return -1; } p_ctrl->type = SIGNAL_CTRL_TYPE::SBO_NORMAL; p_ctrl->step = SIGNAL_CTRL_STEP::READY; - p_ctrl->data_type = p_param->dc_type; - p_ctrl->p_data = dc_create_data_ptr_by_type(p_param->dc_type); + p_ctrl->data_type = p_param->type; + p_ctrl->p_data = dc_create_data_ptr_by_type(p_param->type); if(nullptr == p_ctrl->p_data) { - LOG_E("self_ptl_cfg_init dc_create_data_ptr_by_type failed, type:%d", p_param->dc_type); + MY_LOG_E("self_ptl_cfg_init dc_create_data_ptr_by_type failed, type:%d", p_param->type); return -1; } @@ -597,18 +598,18 @@ LOCAL int self_ptl_cfg_init() for(uint8_t i = 0; i < p_param->num; i++) { - void *p_val_data = dc_create_data_ptr_by_type(p_param->dc_type); + void *p_val_data = dc_create_data_ptr_by_type(p_param->type); if(nullptr == p_val_data) { - LOG_E("self_ptl_cfg_init dc_create_data_ptr_by_type failed, type:%d", p_param->dc_type); + MY_LOG_E("self_ptl_cfg_init dc_create_data_ptr_by_type failed, type:%d", p_param->type); return -1; } p_cfg_data->param_vec.back().vec_p_data.push_back(p_val_data); - void *p_default_val_data = dc_create_data_ptr_by_type(p_param->dc_type); + void *p_default_val_data = dc_create_data_ptr_by_type(p_param->type); if(nullptr == p_default_val_data) { - LOG_E("self_ptl_cfg_init dc_create_data_ptr_by_type failed, type:%d", p_param->dc_type); + MY_LOG_E("self_ptl_cfg_init dc_create_data_ptr_by_type failed, type:%d", p_param->type); return -1; } p_cfg_data->param_vec.back().vec_p_default_data.push_back(p_default_val_data); @@ -896,7 +897,7 @@ int self_ptl_do_signal_out(stru_app *p_app) param.step = safeStringToFloat(p_ao->p_param->step); param.unit = p_ao->p_param->unit; - ret |= dc_signal_ao(p_ao->p_param->base.saddr, p_ao->p_param->base.desc, p_ao->p_param->dc_type, param, SIGNAL_CTRL_TYPE::SBO_NORMAL, p_ao->vec_p_data[0], p_ao->vec_p_default_data[0], self_ptl_signal_change_callback); + ret |= dc_signal_ao(p_ao->p_param->base.saddr, p_ao->p_param->base.desc, p_ao->p_param->type, param, SIGNAL_CTRL_TYPE::SBO_NORMAL, p_ao->vec_p_data[0], p_ao->vec_p_default_data[0], self_ptl_signal_change_callback); } } @@ -918,7 +919,7 @@ int self_ptl_do_signal_out(stru_app *p_app) // ret(saddr, p(saddr, p->name, p->type, p->p_data); - ret |= dc_signal_param(p_param->p_param->base.saddr, p_param->p_param->base.desc, p_param->p_param->dc_type, param, SIGNAL_CTRL_TYPE::SBO_NORMAL, p_param->vec_p_data, p_param->vec_p_default_data, self_ptl_signal_change_callback); + ret |= dc_signal_param(p_param->p_param->base.saddr, p_param->p_param->base.desc, p_param->p_param->type, param, SIGNAL_CTRL_TYPE::SBO_NORMAL, p_param->vec_p_data, p_param->vec_p_default_data, self_ptl_signal_change_callback); } } @@ -938,7 +939,11 @@ int app_self_ptl_init1(void *arg) { stru_app *p_app = (stru_app *)arg; - self_ptl_cfg_init(); + if(0 != self_ptl_cfg_init()) + { + MY_LOG_E("self ptl cfg_init failed"); + return -1; + } self_ptl_init(); diff --git a/test/file/MMS/prj.xml b/test/file/MMS/prj.xml index 86e6a95..e167903 100644 --- a/test/file/MMS/prj.xml +++ b/test/file/MMS/prj.xml @@ -25,8 +25,8 @@ - - + + diff --git a/test/file/PARAM/param.xml b/test/file/PARAM/param.xml index 5999332..866da7f 100644 --- a/test/file/PARAM/param.xml +++ b/test/file/PARAM/param.xml @@ -1,5 +1,1578 @@ - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +