ypc
/
RTU
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

<修改> 

1、调整数据中心获取信号内容的接口；
2、调整webserver中的处理函数，抽象成信号类型的方法；
3、调整web前端网页显示
This commit is contained in:
ypc 2026-05-28 13:23:01 +08:00
parent 3d59800656
commit ac5182ea14
10 changed files with 637 additions and 615 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
.gitignore vendored
View File

@ -22,8 +22,8 @@ tmp/
# vscode 缓存
.vscode/
release/x86/exe/FTU_cfg_parse
release/x86/exe/RTU
release/x86/
release/arm/
src/system/uart_trans/
src/system/FTU_cfg_parse/
libiec61850-1.5.3/

10
release/inc/mySystem.h
View File

@ -384,18 +384,18 @@ int dc_signal_yk_link_with_callback(const std::string &saddr, void **p_data, sig
int dc_signal_yk_set_status(const std::string &saddr, SIGNAL_CTRL_STEP step, stru_signal_ctrl &ctrl, void *p_data);
// 数据中心获取out信号信息接口
int dc_get_out_signal_info(const std::string &saddr, std::string &desc, uint8_t &data_type, std::vector<void *> &vec_p_data);
int dc_get_out_signal_info(const std::string &saddr, std::string &desc, uint8_t &data_type, void **p_data);
// 数据中心获取in信号信息接口
int dc_get_in_signal_info(const std::string &saddr, std::string &desc, uint8_t &data_type, std::vector<void *> &vec_p_data);
int dc_get_in_signal_info(const std::string &saddr, std::string &desc, uint8_t &data_type, void **p_data);
int dc_get_ao_signal_info(const std::string &saddr, std::string &desc, uint8_t &data_type, stru_signal_param &param, uint8_t &ctrl_type, std::vector<void *> &vec_p_data, std::vector<void *> &vec_p_default_data);
int dc_get_ao_signal_info(const std::string &saddr, std::string &desc, uint8_t &data_type, stru_signal_param *p_param, uint8_t &ctrl_type, void **p_data, void **p_default_data);
// 数据中心获取参数信号信息接口
int dc_get_param_signal_info(const std::string &saddr, std::string &desc, uint8_t &data_type, stru_signal_param &param, uint8_t &ctrl_type, std::vector<void *> &vec_p_data, std::vector<void *> &vec_p_default_data);
int dc_get_param_signal_info(const std::string &saddr, std::string &desc, uint8_t &data_type, stru_signal_param *p_param, uint8_t &ctrl_type, std::vector<void *> *p_vec_p_data, std::vector<void *> *p_vec_p_default_data);
// 数据中心获取遥控信号信息接口
int dc_get_yk_signal_info(const std::string &saddr, std::string &desc, uint8_t &data_type, uint8_t &ctrl_type, std::vector<void *> &vec_p_data);
int dc_get_yk_signal_info(const std::string &saddr, std::string &desc, uint8_t &data_type, uint8_t &ctrl_type, void **p_data);
// 数据中心获取信号值字符串接口
std::string dc_get_signal_val(void *p_data, uint8_t data_type);

5
src/protocol/libmms_m/src/mms_m.cpp
View File

@ -1603,7 +1603,6 @@ static void *mms_m_run_thread(void *arg)
stru_mms_m_obj *obj = (stru_mms_m_obj *)arg;
LOG_I("obj %p", obj);
mms_m_timer_init(*obj);
stru_event_queue &queue = obj->run.event_queue;
@ -1807,8 +1806,6 @@ int mms_m_out_init(const char *cfg_path, int debug_print_flag, uint32_t connecti
return -1;
}
LOG_I("p_obj %p", p_obj);
memset(p_obj, 0, sizeof(stru_mms_m_obj));
p_obj->cfg_path = cfg_path;
p_obj->debug_print_flag = debug_print_flag;
@ -1848,8 +1845,6 @@ int mms_m_out_init(const char *cfg_path, int debug_print_flag, uint32_t connecti
return -1;
}
LOG_I("p_obj %p", p_obj);
if(0 != pthread_create(&p_obj->run.pthread_task, NULL, mms_m_run_thread, p_obj))
{
LOG_E("Failed to create IED thread, config file %s\n", cfg_path);

3
src/protocol/libmms_s/src/mms_s_model.cpp
View File

@ -1324,8 +1324,11 @@ int model_init(stru_icd &icd)
continue;
}
if(mms_s_dbg_get())
{
LOG_I("sAddr %s, node type %d, name %s", it_saddr->c_str(), p_node->modelType, get_DA_path(p_node).c_str());
}
}
model_search_control_DataObjects(icd); // 搜索所有控制 DO（含 ctlModel 的 DO），存入 vec_control_do

171
src/system/libdatacenter/src/dc_siganl.cpp
View File

@ -93,7 +93,7 @@ void dc_set_param_cfg_change(bool change)
int dc_get_out_signal_info(const std::string &saddr, std::string &desc, uint8_t &data_type, std::vector<void *> &vec_p_data)
int dc_get_out_signal_info(const std::string &saddr, std::string &desc, uint8_t &data_type, void **p_data)
{
stru_signal *p_signal = dc_find_out_signal(saddr);
if(p_signal == nullptr)
@ -117,12 +117,15 @@ int dc_get_out_signal_info(const std::string &saddr, std::string &desc, uint8_t
return -1;
}
vec_p_data.push_back(p_signal->vec_p_data[0]);
if(p_data != nullptr)
{
(*p_data) = p_signal->vec_p_data[0];
}
return 0;
}
int dc_get_in_signal_info(const std::string &saddr, std::string &desc, uint8_t &data_type, std::vector<void *> &vec_p_data)
int dc_get_in_signal_info(const std::string &saddr, std::string &desc, uint8_t &data_type, void **p_data)
{
stru_signal *p_signal = dc_find_in_signal(saddr);
if(p_signal == nullptr)
@ -136,7 +139,10 @@ int dc_get_in_signal_info(const std::string &saddr, std::string &desc, uint8_t &
if(!p_signal->vec_p_data.empty() && nullptr != p_signal->vec_p_data[0])
{
vec_p_data.push_back(p_signal->vec_p_data[0]);
if(p_data != nullptr)
{
(*p_data) = p_signal->vec_p_data[0];
}
return 0;
}
@ -145,7 +151,7 @@ int dc_get_in_signal_info(const std::string &saddr, std::string &desc, uint8_t &
return -1;
}
int dc_get_ao_signal_info(const std::string &saddr, std::string &desc, uint8_t &data_type, stru_signal_param &param, uint8_t &ctrl_type, std::vector<void *> &vec_p_data, std::vector<void *> &vec_p_default_data)
int dc_get_ao_signal_info(const std::string &saddr, std::string &desc, uint8_t &data_type, stru_signal_param *p_param, uint8_t &ctrl_type, void **p_data, void **p_default_data)
{
stru_signal *p_signal = dc_find_signal(XXH3_128bits(saddr.c_str(), saddr.length()), g_datacenter.signal_ao);
if(p_signal == nullptr)
@ -156,15 +162,21 @@ int dc_get_ao_signal_info(const std::string &saddr, std::string &desc, uint8_t &
desc = p_signal->desc;
data_type = p_signal->data_type;
param.min = p_signal->param.min;
param.max = p_signal->param.max;
param.step = p_signal->param.step;
param.unit = p_signal->param.unit;
if(p_param != nullptr)
{
p_param->min = p_signal->param.min;
p_param->max = p_signal->param.max;
p_param->step = p_signal->param.step;
p_param->unit = p_signal->param.unit;
}
ctrl_type = p_signal->ctrl_type;
if(!p_signal->vec_p_data.empty() && nullptr != p_signal->vec_p_data[0])
{
vec_p_data.push_back(p_signal->vec_p_data[0]);
if(p_data != nullptr)
{
(*p_data) = p_signal->vec_p_data[0];
}
}
else
{
@ -174,7 +186,10 @@ int dc_get_ao_signal_info(const std::string &saddr, std::string &desc, uint8_t &
if(!p_signal->vec_p_default_data.empty() && nullptr != p_signal->vec_p_default_data[0])
{
vec_p_default_data.push_back(p_signal->vec_p_default_data[0]);
if(p_default_data != nullptr)
{
(*p_default_data) = p_signal->vec_p_default_data[0];
}
}
else
{
@ -185,7 +200,7 @@ int dc_get_ao_signal_info(const std::string &saddr, std::string &desc, uint8_t &
return 0;
}
int dc_get_param_signal_info(const std::string &saddr, std::string &desc, uint8_t &data_type, stru_signal_param &param, uint8_t &ctrl_type, std::vector<void *> &vec_p_data, std::vector<void *> &vec_p_default_data)
int dc_get_param_signal_info(const std::string &saddr, std::string &desc, uint8_t &data_type, stru_signal_param *p_param, uint8_t &ctrl_type, std::vector<void *> *p_vec_p_data, std::vector<void *> *p_vec_p_default_data)
{
stru_signal *p_signal = dc_find_signal(XXH3_128bits(saddr.c_str(), saddr.length()), g_datacenter.signal_param);
if(p_signal == nullptr)
@ -195,10 +210,13 @@ int dc_get_param_signal_info(const std::string &saddr, std::string &desc, uint8_
}
desc = p_signal->desc;
data_type = p_signal->data_type;
param.min = p_signal->param.min;
param.max = p_signal->param.max;
param.step = p_signal->param.step;
param.unit = p_signal->param.unit;
if(p_param != nullptr)
{
p_param->min = p_signal->param.min;
p_param->max = p_signal->param.max;
p_param->step = p_signal->param.step;
p_param->unit = p_signal->param.unit;
}
ctrl_type = p_signal->ctrl_type;
for(size_t i = 0; i < p_signal->vec_p_data.size(); i++)
@ -208,8 +226,10 @@ int dc_get_param_signal_info(const std::string &saddr, std::string &desc, uint8_
MY_LOG_E("saddr %s vec_p_data[%ld] is nullptr", saddr.c_str(), i);
return -1;
}
vec_p_data.push_back(p_signal->vec_p_data[i]);
if(p_vec_p_data != nullptr)
{
p_vec_p_data->push_back(p_signal->vec_p_data[i]);
}
}
for(size_t i = 0; i < p_signal->vec_p_default_data.size(); i++)
@ -220,13 +240,16 @@ int dc_get_param_signal_info(const std::string &saddr, std::string &desc, uint8_
return -1;
}
vec_p_default_data.push_back(p_signal->vec_p_default_data[i]);
if(p_vec_p_default_data != nullptr)
{
p_vec_p_default_data->push_back(p_signal->vec_p_default_data[i]);
}
}
return 0;
}
int dc_get_yk_signal_info(const std::string &saddr, std::string &desc, uint8_t &data_type, uint8_t &ctrl_type, std::vector<void *> &vec_p_data)
int dc_get_yk_signal_info(const std::string &saddr, std::string &desc, uint8_t &data_type, uint8_t &ctrl_type, void **p_data)
{
stru_signal *p_signal = dc_find_signal(XXH3_128bits(saddr.c_str(), saddr.length()), g_datacenter.signal_yk);
if(p_signal == nullptr)
@ -237,7 +260,10 @@ int dc_get_yk_signal_info(const std::string &saddr, std::string &desc, uint8_t &
desc = p_signal->desc;
data_type = p_signal->data_type;
ctrl_type = p_signal->ctrl_type;
vec_p_data.push_back(p_signal->vec_p_data[0]);
if(p_data != nullptr)
{
*p_data = p_signal->vec_p_data[0];
}
return 0;
}
@ -263,85 +289,6 @@ 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 int dc_data_compare(uint8_t data_type, void *p_data, void *p_data2)
{
if(p_data == nullptr || p_data2 == nullptr)
@ -434,11 +381,6 @@ 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_default_data, p_signal->vec_p_default_data[0]))
{
change = true;
@ -1109,8 +1051,6 @@ int dc_signal_in(const std::string &saddr, const std::string &desc, const std::s
signal.link_saddrs.push_back(link_saddr);
MY_LOG_I("saddr %s, p_data %p, link_saddr %s", saddr.c_str(), (*p_data), link_saddr.c_str());
return dc_signal_add_to_map(signal, g_datacenter.signal_in);
}
@ -1163,7 +1103,6 @@ int dc_signal_in_with_callback(const std::string &saddr, const std::string &desc
return dc_signal_add_to_map(signal, g_datacenter.signal_in);
}
int dc_signal_ao(const std::string &saddr, const std::string &desc, uint8_t data_type, const stru_signal_param &param, uint8_t ctrl_type, void *p_data, void *p_default_data, signal_change_cb cb)
{
if(p_data == nullptr || p_default_data == nullptr)
@ -1356,6 +1295,15 @@ int dc_signal_param(const std::string &saddr, const std::string &desc, uint8_t d
return -1;
}
for(size_t i = 0; i < vec_p_data.size(); i++)
{
if(vec_p_data[i] == nullptr || vec_p_default_data[i] == nullptr)
{
MY_LOG_E("vec_p_data[%ld] or vec_p_default_data[%ld] is nullptr", i, i);
return -1;
}
}
XXH128_hash_t hash = XXH3_128bits(saddr.c_str(), saddr.length());
stru_signal *p_signal = dc_find_signal(hash, g_datacenter.signal_param);
if(p_signal != nullptr)
@ -1779,6 +1727,7 @@ std::string dc_get_signal_val(void *p_data, uint8_t data_type)
{
if(NULL == p_data)
{
MY_LOG_E("p_data is nullptr");
return "";
}
@ -1922,7 +1871,11 @@ LOCAL int dc_set_signal_val(void *p_data, uint8_t data_type, void *set_data)
void dc_set_signal_val_from_str(void *p_data, uint8_t data_type, const std::string &str)
{
if (str.empty() || p_data == nullptr) return;
if (str.empty() || p_data == nullptr)
{
MY_LOG_E("str is empty or p_data is nullptr");
return;
}
switch (data_type)
{

2
src/system/libiec61850m/src/iec61850m.cpp
View File

@ -505,7 +505,7 @@ int app_iec61850m_init2(void *arg)
dc_signal_in("iec61850m.iec_run_cnt_in", "iec61850m.iec_run_cnt_in", "iec.run_cnt", (void **)&p_iec_run_cnt);
MY_LOG_I("p_iec_run_cnt %p", p_iec_run_cnt);
return 0;
}

26
src/system/libiec61850s/src/iec61850s.cpp
View File

@ -189,20 +189,15 @@ int app_iec61850s_init2(void *arg)
{
for(std::vector<stru_mms_s_setting>::iterator it = vec_setting.begin(); it != vec_setting.end(); ++it)
{
if(0 != dc_signal_ao_link_with_callback(it->base.saddr, (void **)&it->data, NULL))
{
MY_LOG_E("dc_signal_ao_link_with_callback failed");
return -1;
}
std::string desc = "";
uint8_t data_type = 0;
stru_signal_param param = {};
uint8_t ctrl_type = 0;
std::vector<void *> vec_p_data = {};
std::vector<void *> vec_p_default_data = {};
dc_get_ao_signal_info(it->base.saddr, desc, data_type, param, ctrl_type, vec_p_data, vec_p_default_data);
if(0 != dc_get_ao_signal_info(it->base.saddr, desc, data_type, nullptr, ctrl_type, (void **)&it->data, nullptr))
{
MY_LOG_E("dc_get_ao_signal_info failed");
return -1;
}
strcpy(it->base.desc, desc.c_str());
it->base.type = data_type;
@ -211,21 +206,12 @@ int app_iec61850s_init2(void *arg)
for(std::vector<stru_mms_s_param>::iterator it = vec_param.begin(); it != vec_param.end(); ++it)
{
// std::vector<void *> vec_p_data = {};
// if(0 != dc_signal_param_link_with_callback(it->base.saddr, vec_p_data, NULL))
// {
// MY_LOG_E("dc_signal_param_link_with_callback failed");
// return -1;
// }
std::string desc = "";
uint8_t data_type = 0;
stru_signal_param param = {};
uint8_t ctrl_type = 0;
std::vector<void *> vec_p_data = {};
std::vector<void *> vec_p_default_data = {};
if(0 != dc_get_param_signal_info(it->base.saddr, desc, data_type, param, ctrl_type, vec_p_data, vec_p_default_data))
if(0 != dc_get_param_signal_info(it->base.saddr, desc, data_type, nullptr, ctrl_type, &vec_p_data, nullptr))
{
MY_LOG_E("dc_get_param_signal_info failed");
return -1;

2
src/system/libself_ptl/src/self_ptl.cpp
View File

@ -960,7 +960,7 @@ int app_self_ptl_init2(void *arg)
{
dc_signal_in("self_ptl.iec_run_cnt_in", "self_ptl.iec_run_cnt_in", "iec.run_cnt", (void **)&p_iec_run_cnt_in);
MY_LOG_I("p_iec_run_cnt_in %p", p_iec_run_cnt_in);
return 0;
}

403
src/system/libweb_server/src/ws_method.cpp
View File

@ -24,7 +24,53 @@ LOCAL std::vector<stru_ws_signal> g_ws_param_signals;
int signal_is_exist(const std::string& saddr, const std::vector<stru_ws_signal>& signals)
LOCAL void add_out_signal(const std::string& saddr);
LOCAL void add_in_signal(const std::string& saddr);
LOCAL void add_yk_signal(const std::string& saddr);
LOCAL void add_ao_signal(const std::string& saddr);
LOCAL void add_param_signal(const std::string& saddr);
LOCAL void del_out_signal(const std::string& saddr);
LOCAL void del_in_signal(const std::string& saddr);
LOCAL void del_yk_signal(const std::string& saddr);
LOCAL void del_ao_signal(const std::string& saddr);
LOCAL void del_param_signal(const std::string& saddr);
LOCAL void set_out_signal_data(const std::string& saddr, const uint8_t setting_zone, const std::string& val);
LOCAL void set_in_signal_data(const std::string& saddr, const uint8_t setting_zone, const std::string& val);
LOCAL void set_yk_signal_data(const std::string& saddr, const uint8_t setting_zone, const std::string& val);
LOCAL void set_ao_signal_data(const std::string& saddr, const uint8_t setting_zone, const std::string& val);
LOCAL void set_param_signal_data(const std::string& saddr, const uint8_t setting_zone, const std::string& val);
LOCAL int make_out_signal_json(cJSON *root);
LOCAL int make_in_signal_json(cJSON *root);
LOCAL int make_yk_signal_json(cJSON *root);
LOCAL int make_ao_signal_json(cJSON *root);
LOCAL int make_param_signal_json(cJSON *root);
typedef struct
{
void (*add_signal)(const std::string& saddr);
void (*del_signal)(const std::string& saddr);
void (*set_signal_data)(const std::string& saddr, const uint8_t setting_zone, const std::string& val);
int (*make_signal_json)(cJSON *root);
}stru_ws_signal_method;
LOCAL std::map<std::string, stru_ws_signal_method> g_ws_signal_methods_map =
{
{"out", {add_out_signal, del_out_signal, set_out_signal_data, make_out_signal_json}},
{"in", {add_in_signal, del_in_signal, set_in_signal_data, make_in_signal_json}},
{"yk", {add_yk_signal, del_yk_signal, set_yk_signal_data, make_yk_signal_json}},
{"ao", {add_ao_signal, del_ao_signal, set_ao_signal_data, make_ao_signal_json}},
{"param", {add_param_signal, del_param_signal, set_param_signal_data, make_param_signal_json}},
};
LOCAL int signal_is_exist(const std::string& saddr, const std::vector<stru_ws_signal>& signals)
{
for(uint32_t i = 0; i < signals.size(); i++)
{
@ -36,15 +82,11 @@ int signal_is_exist(const std::string& saddr, const std::vector<stru_ws_signal>&
return -1;
}
void add_signal(const std::string& saddr, const std::string& signal_type)
LOCAL void add_out_signal(const std::string& saddr)
{
std::vector<stru_ws_signal> *p_signals = nullptr;
std::vector<stru_ws_signal> *p_signals = &g_ws_out_signals;
stru_ws_signal *p = nullptr;
if(signal_type == "out")
{
p_signals = &g_ws_out_signals;
if(0 == signal_is_exist(saddr, g_ws_out_signals))
{
LOG_E("add_signals: signal is already exist, saddr = %s", saddr.c_str());
@ -54,8 +96,9 @@ void add_signal(const std::string& saddr, const std::string& signal_type)
p_signals->reserve(p_signals->size() + 1);
p_signals->push_back({saddr, "", 0, 0});
p = &p_signals->back();
void *p_data = nullptr;
if(0 != dc_get_out_signal_info(saddr, p->desc, p->data_type, p->vec_p_data))
if(0 != dc_get_out_signal_info(saddr, p->desc, p->data_type, &p_data))
{
LOG_E("add_signals: dc_get_out_signal_info failed, saddr = %s", saddr.c_str());
@ -64,10 +107,13 @@ void add_signal(const std::string& saddr, const std::string& signal_type)
p_signals->pop_back();
return;
}
p->vec_p_data.push_back(p_data);
}
else if(signal_type == "in")
LOCAL void add_in_signal(const std::string& saddr)
{
p_signals = &g_ws_in_signals;
std::vector<stru_ws_signal> *p_signals = &g_ws_in_signals;
stru_ws_signal *p = nullptr;
if(0 == signal_is_exist(saddr, g_ws_in_signals))
{
@ -77,8 +123,8 @@ void add_signal(const std::string& saddr, const std::string& signal_type)
p_signals->push_back({saddr, "", 0, 0});
p = &p_signals->back();
if(0 != dc_get_in_signal_info(saddr, p->desc, p->data_type, p->vec_p_data))
void *p_data = nullptr;
if(0 != dc_get_in_signal_info(saddr, p->desc, p->data_type, &p_data))
{
LOG_E("add_signals: dc_get_in_signal_info failed, saddr = %s", saddr.c_str());
@ -87,11 +133,13 @@ void add_signal(const std::string& saddr, const std::string& signal_type)
p_signals->pop_back();
return;
}
p->vec_p_data.push_back(p_data);
}
else if(signal_type == "yk")
LOCAL void add_yk_signal(const std::string& saddr)
{
p_signals = &g_ws_yk_signals;
std::vector<stru_ws_signal> *p_signals = &g_ws_yk_signals;
stru_ws_signal *p = nullptr;
if(0 == signal_is_exist(saddr, g_ws_yk_signals))
{
@ -102,8 +150,8 @@ void add_signal(const std::string& saddr, const std::string& signal_type)
p_signals->push_back({saddr, "", 0, 0});
p_signals->back().p_ctrl = new stru_signal_ctrl;
p = &p_signals->back();
if(0 != dc_get_yk_signal_info(saddr, p->desc, p->data_type, p->ctrl_type, p->vec_p_data))
void *p_data = nullptr;
if(0 != dc_get_yk_signal_info(saddr, p->desc, p->data_type, p->ctrl_type, &p_data))
{
LOG_E("add_signals: dc_get_yk_signal_info failed, saddr = %s", saddr.c_str());
@ -113,6 +161,7 @@ void add_signal(const std::string& saddr, const std::string& signal_type)
p_signals->pop_back();
return;
}
p->vec_p_data.push_back(p_data);
p->p_ctrl->type = p->ctrl_type;
p->p_ctrl->step = SIGNAL_CTRL_STEP::READY;
@ -129,9 +178,11 @@ void add_signal(const std::string& saddr, const std::string& signal_type)
return;
}
}
else if(signal_type == "ao")
LOCAL void add_ao_signal(const std::string& saddr)
{
p_signals = &g_ws_ao_signals;
std::vector<stru_ws_signal> *p_signals = &g_ws_ao_signals;
stru_ws_signal *p = nullptr;
if(0 == signal_is_exist(saddr, g_ws_ao_signals))
{
@ -144,7 +195,10 @@ void add_signal(const std::string& saddr, const std::string& signal_type)
p_signals->back().p_param = new stru_signal_param;
p = &p_signals->back();
if(0 != dc_get_ao_signal_info(saddr, p->desc, p->data_type, *p->p_param, p->ctrl_type, p->vec_p_data, p->vec_p_default_data))
void *p_data = nullptr;
void *p_default_data = nullptr;
if(0 != dc_get_ao_signal_info(saddr, p->desc, p->data_type, p->p_param, p->ctrl_type, &p_data, &p_default_data))
{
LOG_E("add_signals: dc_get_ao_signal_info failed, saddr = %s", saddr.c_str());
@ -155,6 +209,8 @@ void add_signal(const std::string& saddr, const std::string& signal_type)
p_signals->pop_back();
return;
}
p->vec_p_data.push_back(p_data);
p->vec_p_default_data.push_back(p_default_data);
p->p_ctrl->type = p->ctrl_type;
p->p_ctrl->step = SIGNAL_CTRL_STEP::READY;
@ -172,9 +228,11 @@ void add_signal(const std::string& saddr, const std::string& signal_type)
return;
}
}
else if(signal_type == "param")
LOCAL void add_param_signal(const std::string& saddr)
{
p_signals = &g_ws_param_signals;
std::vector<stru_ws_signal> *p_signals = &g_ws_param_signals;
stru_ws_signal *p = nullptr;
if(0 == signal_is_exist(saddr, g_ws_param_signals))
{
@ -186,7 +244,7 @@ void add_signal(const std::string& saddr, const std::string& signal_type)
p_signals->back().p_param = new stru_signal_param;
p = &p_signals->back();
if(0 != dc_get_param_signal_info(saddr, p->desc, p->data_type, *p->p_param, p->ctrl_type, p->vec_p_data, p->vec_p_default_data))
if(0 != dc_get_param_signal_info(saddr, p->desc, p->data_type, p->p_param, p->ctrl_type, &p->vec_p_data, &p->vec_p_default_data))
{
LOG_E("add_signals: dc_get_param_signal_info failed, saddr = %s", saddr.c_str());
@ -214,46 +272,13 @@ void add_signal(const std::string& saddr, const std::string& signal_type)
return;
}
}
else
{
LOG_E("add_signals: invalid signal_type = %s", signal_type.c_str());
return;
}
}
void del_signal(const std::string& saddr, const std::string& signal_type)
{
std::vector<stru_ws_signal> *p_signals = nullptr;
if(signal_type == "out")
LOCAL void del_signal(std::vector<stru_ws_signal> &signals, const std::string& saddr)
{
p_signals = &g_ws_out_signals;
}
else if(signal_type == "in")
for(uint32_t i = 0; i < signals.size(); i++)
{
p_signals = &g_ws_in_signals;
}
else if(signal_type == "yk")
{
p_signals = &g_ws_yk_signals;
}
else if(signal_type == "ao")
{
p_signals = &g_ws_ao_signals;
}
else if(signal_type == "param")
{
p_signals = &g_ws_param_signals;
}
else
{
LOG_E("del_signal: invalid signal_type = %s", signal_type.c_str());
return;
}
for(uint32_t i = 0; i < p_signals->size(); i++)
{
stru_ws_signal *p_signal = &p_signals->at(i);
stru_ws_signal *p_signal = &signals.at(i);
if(p_signal->saddr == saddr)
{
if(p_signal->p_ctrl)
@ -268,7 +293,7 @@ void del_signal(const std::string& saddr, const std::string& signal_type)
p_signal->vec_p_data.clear();
p_signal->vec_p_default_data.clear();
p_signals->erase(p_signals->begin() + i);
signals.erase(signals.begin() + i);
return;
}
}
@ -276,85 +301,97 @@ void del_signal(const std::string& saddr, const std::string& signal_type)
LOG_E("del_signal: not found saddr = %s", saddr.c_str());
}
void set_signal_data(const std::string& saddr, const std::string& signal_type, const uint8_t setting_zone, const std::string& signal_data)
LOCAL void del_out_signal(const std::string& saddr)
{
std::vector<stru_ws_signal> *p_signals = nullptr;
if(signal_data.empty())
{
LOG_E("set_signal_data: signal_data is empty, saddr = %s", saddr.c_str());
return;
del_signal(g_ws_out_signals, saddr);
}
LOCAL void del_in_signal(const std::string& saddr)
{
del_signal(g_ws_in_signals, saddr);
}
LOCAL void del_yk_signal(const std::string& saddr)
{
del_signal(g_ws_yk_signals, saddr);
}
LOCAL void del_ao_signal(const std::string& saddr)
{
del_signal(g_ws_ao_signals, saddr);
}
LOCAL void del_param_signal(const std::string& saddr)
{
del_signal(g_ws_param_signals, saddr);
}
LOCAL void set_out_signal_data(const std::string& saddr, const uint8_t setting_zone, const std::string& val)
{
uint8_t data[128] = {0};
memset(data, 0, sizeof(data));
uint8_t data_type = dc_get_data_type_id_by_str(signal_type);
if(data_type == 0)
{
LOG_E("set_signal_data: invalid signal_type = %s", signal_type.c_str());
return;
}
dc_set_signal_val_from_str(data, data_type, signal_data);
if(signal_type == "out")
for(uint32_t i = 0; i < g_ws_out_signals.size(); i++)
{
p_signals = &g_ws_out_signals;
for(uint32_t i = 0; i < p_signals->size(); i++)
{
stru_ws_signal *p_signal = &p_signals->at(i);
stru_ws_signal *p_signal = &g_ws_out_signals.at(i);
if(p_signal->saddr == saddr)
{
dc_set_signal_val_from_str(data, p_signal->data_type, val);
if(0 != dc_set_out_signal_val(saddr, (void *)data))
{
LOG_E("set_signal_data: dc_set_signal_val failed, saddr = %s, signal_data = %s", saddr.c_str(), signal_data.c_str());
LOG_E("set_signal_data: dc_set_signal_val failed, saddr = %s, val = %s", saddr.c_str(), val.c_str());
return;
}
}
}
}
else if(signal_type == "in")
{
LOG_E("signal_type is in, not support set_signal_data, saddr = %s");
return;
}
else if(signal_type == "yk")
{
p_signals = &g_ws_yk_signals;
for(uint32_t i = 0; i < p_signals->size(); i++)
LOCAL void set_in_signal_data(const std::string& saddr, const uint8_t setting_zone, const std::string& val)
{
stru_ws_signal *p_signal = &p_signals->at(i);
LOG_E("signal_type is in, not support set_signal_data, saddr = %s", saddr.c_str());
}
LOCAL void set_yk_signal_data(const std::string& saddr, const uint8_t setting_zone, const std::string& val)
{
uint8_t data[128] = {0};
for(uint32_t i = 0; i < g_ws_yk_signals.size(); i++)
{
stru_ws_signal *p_signal = &g_ws_yk_signals.at(i);
if(p_signal->saddr == saddr)
{
dc_set_signal_val_from_str(data, p_signal->data_type, val);
if(p_signal->ctrl_type == SIGNAL_CTRL_TYPE::DIRECT_NORMAL)
{
if(0 != dc_signal_yk_set_status(saddr, SIGNAL_CTRL_STEP::DIRECT, *p_signal->p_ctrl, (void *)data))
{
LOG_E("set_signal_data: dc_signal_yk_set_status direct failed, saddr = %s, signal_data = %s", saddr.c_str(), signal_data.c_str());
LOG_E("set_signal_data: dc_signal_yk_set_status direct failed, saddr = %s, val = %s", saddr.c_str(), val.c_str());
return;
}
LOG_I("saddr %s, direct, value %d success !!!", saddr.c_str(), signal_data.c_str());
LOG_I("saddr %s, direct, value %s success !!!", saddr.c_str(), val.c_str());
return;
}
else if(p_signal->ctrl_type == SIGNAL_CTRL_TYPE::SBO_NORMAL)
{
if(0 != dc_signal_yk_set_status(saddr, SIGNAL_CTRL_STEP::SELECT, *p_signal->p_ctrl, (void *)data))
{
LOG_E("set_signal_data: dc_signal_yk_set_status select failed, saddr = %s, signal_data = %s", saddr.c_str(), signal_data.c_str());
LOG_E("set_signal_data: dc_signal_yk_set_status select failed, saddr = %s, val = %s", saddr.c_str(), val.c_str());
return;
}
task_sleep_ms(1000);
MY_LOG_I("saddr %s, select value %s success !!!", saddr.c_str(), signal_data.c_str());
MY_LOG_I("saddr %s, select value %s success !!!", saddr.c_str(), val.c_str());
if(0 != dc_signal_yk_set_status(saddr, SIGNAL_CTRL_STEP::DIRECT, *p_signal->p_ctrl, (void *)data))
{
LOG_E("set_signal_data: dc_signal_yk_set_status direct failed, saddr = %s, signal_data = %s", saddr.c_str(), signal_data.c_str());
LOG_E("set_signal_data: dc_signal_yk_set_status direct failed, saddr = %s, val = %s", saddr.c_str(), val.c_str());
return;
}
MY_LOG_I("saddr %s, direct value %s success !!!", saddr.c_str(), signal_data.c_str());
MY_LOG_I("saddr %s, direct value %s success !!!", saddr.c_str(), val.c_str());
return;
}
else
@ -364,25 +401,29 @@ void set_signal_data(const std::string& saddr, const std::string& signal_type, c
}
}
}
}
else if(signal_type == "ao")
{
p_signals = &g_ws_ao_signals;
for(uint32_t i = 0; i < p_signals->size(); i++)
}
LOCAL void set_ao_signal_data(const std::string& saddr, const uint8_t setting_zone, const std::string& val)
{
stru_ws_signal *p_signal = &p_signals->at(i);
uint8_t data[128] = {0};
for(uint32_t i = 0; i < g_ws_ao_signals.size(); i++)
{
stru_ws_signal *p_signal = &g_ws_ao_signals.at(i);
if(p_signal->saddr == saddr)
{
dc_set_signal_val_from_str(data, p_signal->data_type, val);
if(p_signal->ctrl_type == SIGNAL_CTRL_TYPE::DIRECT_NORMAL)
{
if(0 != dc_signal_ao_set_val(saddr, SIGNAL_CTRL_STEP::DIRECT, *p_signal->p_ctrl, (void *)data))
{
LOG_E("set_signal_data: dc_signal_ao_set_val direct failed, saddr = %s, signal_data = %s", saddr.c_str(), signal_data.c_str());
LOG_E("set_signal_data: dc_signal_ao_set_val direct failed, saddr = %s, val = %s", saddr.c_str(), val.c_str());
return;
}
LOG_I("saddr %s, direct, value %s success !!!", saddr.c_str(), signal_data.c_str());
LOG_I("saddr %s, direct, value %s success !!!", saddr.c_str(), val.c_str());
return;
}
else if(p_signal->ctrl_type == SIGNAL_CTRL_TYPE::SBO_NORMAL)
@ -390,19 +431,19 @@ void set_signal_data(const std::string& saddr, const std::string& signal_type, c
if(0 != dc_signal_ao_set_val(saddr, SIGNAL_CTRL_STEP::SELECT, *p_signal->p_ctrl, (void *)data))
{
LOG_E("set_signal_data: dc_signal_ao_set_val select failed, saddr = %s, signal_data = %s", saddr.c_str(), signal_data.c_str());
LOG_E("set_signal_data: dc_signal_ao_set_val select failed, saddr = %s, val = %s", saddr.c_str(), val.c_str());
return;
}
LOG_I("saddr %s, select, value %s success !!!", saddr.c_str(), signal_data.c_str());
LOG_I("saddr %s, select, value %s success !!!", saddr.c_str(), val.c_str());
if(0 != dc_signal_ao_set_val(saddr, SIGNAL_CTRL_STEP::DIRECT, *p_signal->p_ctrl, (void *)data))
{
LOG_E("set_signal_data: dc_signal_ao_set_val direct failed, saddr = %s, signal_data = %s", saddr.c_str(), signal_data.c_str());
LOG_E("set_signal_data: dc_signal_ao_set_val direct failed, saddr = %s, val = %s", saddr.c_str(), val.c_str());
return;
}
LOG_I("saddr %s, direct, value %s success !!!", saddr.c_str(), signal_data.c_str());
LOG_I("saddr %s, direct, value %s success !!!", saddr.c_str(), val.c_str());
return;
}
else
@ -413,43 +454,46 @@ void set_signal_data(const std::string& saddr, const std::string& signal_type, c
}
}
}
else if(signal_type == "param")
{
p_signals = &g_ws_param_signals;
for(uint32_t i = 0; i < p_signals->size(); i++)
LOCAL void set_param_signal_data(const std::string& saddr, const uint8_t setting_zone, const std::string& val)
{
stru_ws_signal *p_signal = &p_signals->at(i);
uint8_t data[128] = {0};
for(uint32_t i = 0; i < g_ws_param_signals.size(); i++)
{
stru_ws_signal *p_signal = &g_ws_param_signals.at(i);
if(p_signal->saddr == saddr)
{
dc_set_signal_val_from_str(data, p_signal->data_type, val);
if(p_signal->ctrl_type == SIGNAL_CTRL_TYPE::DIRECT_NORMAL)
{
if(0 != dc_signal_param_set_val(saddr, SIGNAL_CTRL_STEP::DIRECT, *p_signal->p_ctrl, setting_zone, (void *)data))
{
LOG_E("set_signal_data: dc_signal_param_set_val direct failed, saddr = %s, signal_data = %s", saddr.c_str(), signal_data.c_str());
LOG_E("set_signal_data: dc_signal_param_set_val direct failed, saddr = %s, val = %s", saddr.c_str(), val.c_str());
return;
}
LOG_I("saddr %s, direct, value %s success !!!", saddr.c_str(), signal_data.c_str());
LOG_I("saddr %s, direct, value %s success !!!", saddr.c_str(), val.c_str());
return;
}
else if(p_signal->ctrl_type == SIGNAL_CTRL_TYPE::SBO_NORMAL)
{
if(0 != dc_signal_param_set_val(saddr, SIGNAL_CTRL_STEP::SELECT, *p_signal->p_ctrl, setting_zone, (void *)data))
{
LOG_E("set_signal_data: dc_signal_param_set_val select failed, saddr = %s, signal_data = %s", saddr.c_str(), signal_data.c_str());
LOG_E("set_signal_data: dc_signal_param_set_val select failed, saddr = %s, val = %s", saddr.c_str(), val.c_str());
return;
}
LOG_I("saddr %s, select, value %s success !!!", saddr.c_str(), signal_data.c_str());
LOG_I("saddr %s, select, value %s success !!!", saddr.c_str(), val.c_str());
if(0 != dc_signal_param_set_val(saddr, SIGNAL_CTRL_STEP::DIRECT, *p_signal->p_ctrl, setting_zone, (void *)data))
{
LOG_E("set_signal_data: dc_signal_param_set_val direct failed, saddr = %s, signal_data = %s", saddr.c_str(), signal_data.c_str());
LOG_E("set_signal_data: dc_signal_param_set_val direct failed, saddr = %s, val = %s", saddr.c_str(), val.c_str());
return;
}
LOG_I("saddr %s, direct, value %s success", saddr.c_str(), signal_data.c_str());
LOG_I("saddr %s, direct, value %s success !!!", saddr.c_str(), val.c_str());
return;
}
else
@ -460,16 +504,8 @@ void set_signal_data(const std::string& saddr, const std::string& signal_type, c
}
}
}
else
{
LOG_E("set_signal_data: invalid signal_type = %s", signal_type.c_str());
return;
}
LOG_E("set_signal_data: not found saddr = %s", saddr.c_str());
}
void ws_recv(const char* p_rx, uint16_t rx_len)
{
@ -546,38 +582,32 @@ void ws_recv(const char* p_rx, uint16_t rx_len)
return;
}
if(g_ws_signal_methods_map.find(signal_type_str) == g_ws_signal_methods_map.end())
{
LOG_E("ws_recv: signal_type %s is not supported, p_rx = %s", signal_type_str.c_str(), p_rx);
return;
}
stru_ws_signal_method method = g_ws_signal_methods_map[signal_type_str];
if(0 == curd_str.compare("add"))
{
add_signal(saddr_str, signal_type_str);
method.add_signal(saddr_str);
}
else if(0 == curd_str.compare("del"))
{
del_signal(saddr_str, signal_type_str);
method.del_signal(saddr_str);
}
else if(0 == curd_str.compare("set"))
{
set_signal_data(saddr_str, signal_type_str, atoi(setting_zone_str.c_str()), signal_data_str);
method.set_signal_data(saddr_str, atoi(setting_zone_str.c_str()), signal_data_str);
}
}
void ws_task()
LOCAL int make_out_signal_json(cJSON *root)
{
if(g_ws_out_signals.empty() && g_ws_in_signals.empty() && g_ws_yk_signals.empty() && g_ws_ao_signals.empty() && g_ws_param_signals.empty())
{
return;
}
const char ctrl_type_str[][16] = {"0", "1", "2"};
cJSON *root = cJSON_CreateObject();
if(nullptr == root)
{
LOG_E("ws_task: cJSON_CreateObject failed");
return;
}
cJSON *out_arr = cJSON_CreateArray();
cJSON_AddItemToObject(root, "out", out_arr);
@ -588,8 +618,7 @@ void ws_task()
if(nullptr == item)
{
LOG_E("ws_task: cJSON_CreateObject failed");
cJSON_Delete(root);
return;
return -1;
}
cJSON_AddItemToObject(item, "saddr", cJSON_CreateString(p_signal->saddr.c_str()));
@ -601,6 +630,11 @@ void ws_task()
cJSON_AddItemToArray(out_arr, item);
}
return 0;
}
LOCAL int make_in_signal_json(cJSON *root)
{
cJSON *in_arr = cJSON_CreateArray();
cJSON_AddItemToObject(root, "in", in_arr);
@ -611,8 +645,7 @@ void ws_task()
if(nullptr == item)
{
LOG_E("ws_task: cJSON_CreateObject failed");
cJSON_Delete(root);
return;
return -1;
}
cJSON_AddItemToObject(item, "saddr", cJSON_CreateString(p_signal->saddr.c_str()));
@ -623,6 +656,11 @@ void ws_task()
cJSON_AddItemToArray(in_arr, item);
}
return 0;
}
LOCAL int make_yk_signal_json(cJSON *root)
{
cJSON *yk_arr = cJSON_CreateArray();
cJSON_AddItemToObject(root, "yk", yk_arr);
for(uint32_t i = 0; i < g_ws_yk_signals.size(); i++)
@ -632,8 +670,7 @@ void ws_task()
if(nullptr == item)
{
LOG_E("ws_task: cJSON_CreateObject failed");
cJSON_Delete(root);
return;
return -1;
}
cJSON_AddItemToObject(item, "saddr", cJSON_CreateString(p_signal->saddr.c_str()));
@ -645,6 +682,11 @@ void ws_task()
cJSON_AddItemToArray(yk_arr, item);
}
return 0;
}
LOCAL int make_ao_signal_json(cJSON *root)
{
cJSON *ao_arr = cJSON_CreateArray();
cJSON_AddItemToObject(root, "ao", ao_arr);
@ -655,8 +697,7 @@ void ws_task()
if(nullptr == item)
{
LOG_E("ws_task: cJSON_CreateObject failed");
cJSON_Delete(root);
return;
return -1;
}
cJSON_AddItemToObject(item, "saddr", cJSON_CreateString(p_signal->saddr.c_str()));
@ -679,7 +720,11 @@ void ws_task()
cJSON_AddItemToArray(ao_arr, item);
}
return 0;
}
LOCAL int make_param_signal_json(cJSON *root)
{
cJSON *param_arr = cJSON_CreateArray();
cJSON_AddItemToObject(root, "param", param_arr);
@ -690,8 +735,7 @@ void ws_task()
if(nullptr == item)
{
LOG_E("ws_task: cJSON_CreateObject failed");
cJSON_Delete(root);
return;
return -1;
}
cJSON_AddItemToObject(item, "saddr", cJSON_CreateString(p_signal->saddr.c_str()));
@ -706,29 +750,65 @@ void ws_task()
cJSON_AddItemToObject(item, "unit", cJSON_CreateString(p_signal->p_param->unit.c_str()));
}
cJSON *setting_zone_arr = cJSON_CreateArray();
cJSON_AddItemToObject(item, "setting_zone_list", setting_zone_arr);
for(uint32_t j = 0; j < p_signal->vec_p_data.size(); j++)
{
cJSON *setting_zone_item = cJSON_CreateObject();
if(nullptr == setting_zone_item)
{
LOG_E("ws_task: cJSON_CreateObject failed");
cJSON_Delete(root);
return;
return -1;
}
std::string setting_zone_str = std::to_string(j);
cJSON_AddItemToObject(setting_zone_item, "setting_zone", cJSON_CreateString(setting_zone_str.c_str()));
std::string id = std::to_string(j);
cJSON_AddItemToObject(setting_zone_item, "id", cJSON_CreateString(id.c_str()));
std::string val = dc_get_signal_val(p_signal->vec_p_data[j], p_signal->data_type);
cJSON_AddItemToObject(setting_zone_item, "val", cJSON_CreateString(val.c_str()));
std::string default_val = dc_get_signal_val(p_signal->vec_p_default_data[j], p_signal->data_type);
cJSON_AddItemToObject(setting_zone_item, "default_val", cJSON_CreateString(default_val.c_str()));
cJSON_AddItemToArray(item, setting_zone_item);
cJSON_AddItemToArray(setting_zone_arr, setting_zone_item);
}
cJSON_AddItemToArray(param_arr, item);
}
return 0;
}
void ws_task()
{
if(g_ws_out_signals.empty() && g_ws_in_signals.empty() && g_ws_yk_signals.empty() && g_ws_ao_signals.empty() && g_ws_param_signals.empty())
{
return;
}
std::vector<std::string> signal_type_list = {"out", "in", "yk", "ao", "param"};
cJSON *root = cJSON_CreateObject();
if(nullptr == root)
{
LOG_E("ws_task: cJSON_CreateObject failed");
return;
}
for(uint32_t i = 0; i < signal_type_list.size(); i++)
{
if(g_ws_signal_methods_map.find(signal_type_list[i]) != g_ws_signal_methods_map.end())
{
if(0 != g_ws_signal_methods_map[signal_type_list[i]].make_signal_json(root))
{
cJSON_Delete(root);
LOG_E("ws_task: make_signal_json %s failed", signal_type_list[i].c_str());
return;
}
}
}
char *p_tx = cJSON_Print(root);
if(nullptr == p_tx)
{
@ -741,5 +821,4 @@ void ws_task()
cJSON_Delete(root);
free(p_tx);
}

102
test/web_root/index.html
View File

@ -23,12 +23,11 @@
.log-send { color: #4CAF50; }
.log-error { color: #f44336; }
/* 表格容器：固定高度 + 滚动条，最多显示8行 */
.table-container { margin-bottom: 20px; }
.table-title { font-size: 16px; font-weight: bold; margin-bottom: 8px; color: #2c3e50; }
.table-wrapper {
max-height: 320px; /* 刚好显示8行 */
overflow-y: auto; /* 超出自动滚动 */
max-height: 320px;
overflow-y: auto;
border: 1px solid #eee;
border-radius: 4px;
}
@ -45,7 +44,7 @@
.signalTable td { padding: 10px; border-bottom: 1px solid #eee; }
.signalTable tr:hover { background: #f5f5f5; }
.form-row { display: flex; gap: 10px; margin-bottom: 10px; flex-wrap: wrap; }
.form-row { display: flex; gap: 10px; margin-bottom: 10px; flex-wrap: wrap; align-items: flex-end; }
.form-group { display: flex; flex-direction: column; }
</style>
</head>
@ -77,6 +76,10 @@
<option value="del">del</option>
</select>
</div>
<div class="form-group">
<label>setting_zone</label>
<input id="setting_zone" value="0" placeholder="0">
</div>
<div class="form-group">
<label>signal_data</label>
<input id="signal_data" placeholder="(can empty)">
@ -92,7 +95,6 @@
<button onclick="connectWS()" class="secondary">Connect</button>
</div>
<!-- 4个独立信号表格 + 滚动容器 -->
<div class="card">
<div class="table-container">
<div class="table-title">OUT 信号</div>
@ -135,10 +137,10 @@
</div>
<div class="table-container">
<div class="table-title">PARAM 信号</div>
<div class="table-title">PARAM 信号（当前定值区：<span id="currentZone">0</span>）</div>
<div class="table-wrapper">
<table class="signalTable">
<thead><tr><th>#</th><th>saddr</th><th>desc</th><th>数据类型</th><th>val</th><th>ctrl_type</th><th>min</th><th>max</th><th>step</th><th>unit</th><th>default</th></tr></thead>
<thead><tr><th>#</th><th>saddr</th><th>desc</th><th>数据类型</th><th>val</th><th>ctrl_type</th><th>min</th><th>max</th><th>step</th><th>unit</th><th>default_val</th></tr></thead>
<tbody id="paramBody"></tbody>
</table>
</div>
@ -160,15 +162,10 @@
param: document.getElementById('paramBody')
};
// 控制类型数字转文字映射
const ctrlTypeMap = {
0: "只读",
1: "直控",
2: "选控"
};
const ctrlTypeMap = { 0: "只读", 1: "直控", 2: "选控" };
const log = document.getElementById('log');
const status = document.getElementById('status');
const currentZoneSpan = document.getElementById('currentZone');
function addLog(msg, type = 'info') {
const t = new Date().toLocaleTimeString();
@ -194,32 +191,47 @@
};
}
// 每次收到数据，直接清空对应表格，重新渲染
function parseData(root) {
const setting_zone = document.getElementById('setting_zone').value.trim();
currentZoneSpan.textContent = setting_zone;
const types = ['out', 'in', 'yk', 'ao', 'param'];
types.forEach(type => {
const arr = root[type];
const body = tableBodies[type];
// 每次先清空表格
body.innerHTML = '';
if (Array.isArray(arr)) {
if (!Array.isArray(arr)) return;
arr.forEach((item, index) => {
if (item.saddr) {
addRow(type, item, index + 1);
if (!item.saddr) return;
if (type === 'param') {
const zoneList = item.setting_zone_list || [];
const match = zoneList.find(z => z.id === setting_zone);
if (!match) return;
const tr = body.insertRow();
tr.innerHTML = `
<td>${index+1}</td>
<td>${item.saddr}</td>
<td>${item.desc || '-'}</td>
<td>${item.type || '-'}</td>
<td>${match.val || '-'}</td>
<td>${ctrlTypeMap[item.ctrl_type] || item.ctrl_type}</td>
<td>${item.min || '-'}</td>
<td>${item.max || '-'}</td>
<td>${item.step || '-'}</td>
<td>${item.unit || '-'}</td>
<td>${match.default_val || '-'}</td>
`;
} else {
addNormalRow(type, item, index+1);
}
});
}
});
}
// 转换控制类型
function getCtrlText(val){
if(val === undefined || val === null) return "-";
return ctrlTypeMap[val] || val;
}
// 新增行
function addRow(type, item, index) {
function addNormalRow(type, item, index) {
const body = tableBodies[type];
const tr = body.insertRow();
let html = `
@ -229,27 +241,10 @@
<td>${item.type || '-'}</td>
<td>${item.val || '-'}</td>
`;
// yk 增加控制权限文字
if (type === 'yk') {
html += `<td>${getCtrlText(item.ctrl_type)}</td>`;
}
// ao 增加完整参数列
if (type === 'yk') html += `<td>${ctrlTypeMap[item.ctrl_type] || item.ctrl_type}</td>`;
if (type === 'ao') {
html += `
<td>${getCtrlText(item.ctrl_type)}</td>
<td>${item.min || '-'}</td>
<td>${item.max || '-'}</td>
<td>${item.step || '-'}</td>
<td>${item.unit || '-'}</td>
<td>${item.default || '-'}</td>
`;
}
// param 增加完整参数列
if (type === 'param') {
html += `
<td>${getCtrlText(item.ctrl_type)}</td>
<td>${ctrlTypeMap[item.ctrl_type] || item.ctrl_type}</td>
<td>${item.min || '-'}</td>
<td>${item.max || '-'}</td>
<td>${item.step || '-'}</td>
@ -264,12 +259,23 @@
const saddr = document.getElementById('saddr').value.trim();
const type = document.getElementById('signal_type').value;
const curd = document.getElementById('curd').value;
const setting_zone = document.getElementById('setting_zone').value.trim();
const data = document.getElementById('signal_data').value.trim();
if (!saddr) return addLog('saddr required', 'error');
if (!ws || ws.readyState !== 1) return addLog('not connected', 'error');
const msg = { saddr, signal_type: type, curd, signal_data: data };
const msg = {
saddr,
signal_type: type,
curd,
setting_zone: setting_zone,
signal_data: data
};
ws.send(JSON.stringify(msg));
addLog(`sent: ${JSON.stringify(msg)}`, 'send');
parseData(JSON.parse(ws._lastData || '{}'));
}
function clearForm() {