#include "cJSON.h" #include "common.h" #include "json_handle.h" #include "sqlite_handle.h" #include "common.h" #include "switch_ctrl.h" #include "sys.h" #include "thread.h" #include "cfg.h" #include "cascade.h" #include "upg.h" #include "lock.h" #include "file.h" #include "paras.h" #include "mongoose.h" #include "language_common.h" #include "websocket_handle.h" #include "breaker_detection.h" #include "Cellular.h" #include "wifi.h" #define TOTAL_COUNT 60 #define FN_MAX 30 enum { FILE_IMPORT=0, FILE_EXPORT, }; enum { FILE_SYS_CFG=0, FILE_SERV_CFG, FILE_ALARM_CFG, FILE_SENSOR_CFG, FILE_POWER_ALL, FILE_POWER_CHN, FILE_LOG_RUN, FILE_LOG_OPERA, FILE_LOG_ALARM, FILE_LOGO, FILE_HOST_FW, }; typedef void (*http_fn_t)(void *arg); typedef struct mg_tls_opts mg_tls_t; typedef struct { struct mg_connection *c; int ev; void *ev_data; }mg_stream_t; typedef struct { http_fn_t f; char *uri; }mg_fn_t; typedef struct { int cnt; mg_fn_t fn[FN_MAX]; char rootDir[MG_PATH_MAX]; mg_tls_t tls; pthread_t tid; }mg_handle_t; typedef struct { _OverAllPwrAckInfo all; _OverAllPwrAckInfo chn; }status_data_t; typedef struct { mg_handle_t mg; pthread_t tid; status_data_t stt; }web_handle_t; static char* g_product_board_cpu[] = { "xxx", "T113" }; static char* g_product_type_str[] = { "SmartPDU(DC)", "SmartPDU(AC)", "SmartPDU", "SmartPDU(Three_AC_Tree)", "SmartPDU(Three_AC_One)", "SmartPDU(Three_AC_One_B)", }; static char* g_product_pwr_type_str[] = { "xxx", "直流", "交流单相", "交流三相三出", "交流三相单出", }; static web_handle_t webHandle; static int webSetCallback(void); /////////////////////////////////////////////////// static int upload_file(void *conn, char *path) { int r=-1,flag=0; char name[200]; struct mg_http_part part; mg_stream_t *s=(mg_stream_t*)conn; size_t pos = 0, total_bytes = 0; struct mg_http_message *hm = (struct mg_http_message *)s->ev_data; memset(name, 0, sizeof(name)); while ((pos = mg_http_next_multipart(hm->body, pos, &part)) > 0) { memcpy(name, part.filename.buf, part.filename.len); printf("filename: %s length: %lu bytes\n", name, (unsigned long) part.body.len); if(flag==0) { file_remove(path); flag = 1; } r = file_append(path, part.body.buf, part.body.len); if (r==0) { total_bytes += part.body.len; } } printf("___ upload file to %s %d\n", path, total_bytes); return r; } static int download_file(void *conn, char *fpath) { mg_stream_t *s=(mg_stream_t*)conn; struct mg_http_message *hm = (struct mg_http_message *)s->ev_data; struct mg_http_serve_opts opts={.root_dir=NULL}; mg_http_serve_file2(s->c, hm, fpath, &opts); return 0; } static int http_reply(void *conn, int status, char *ack) { int r=0; mg_stream_t *s=(mg_stream_t*)conn; r = mg_http_reply2(s->c, status, "", ack); return r; } static void httpAddCallback(char *uri, http_fn_t f) { mg_handle_t *h=&webHandle.mg; if(h->cntfn[h->cnt].uri = uri; h->fn[h->cnt].f = f; h->cnt++; } } static time_t gettime(char *timestr) { int r; struct tm tm={0}; //2024-10-29 05:19:09 r = sscanf(timestr, "%d-%d-%d %d:%d:%d", &tm.tm_year,&tm.tm_mon,&tm.tm_mday,&tm.tm_hour,&tm.tm_min,&tm.tm_sec); if(r<6) { return -1; } tm.tm_year -= 1900; tm.tm_mon -= 1; return mktime(&tm); } static int gettime2(char *buf, char *tok, char *timestr) { char *p=strstr(buf, tok); if(!p) { return -1; } p += strlen(tok); memcpy(timestr, p, 10); timestr[10] = ' '; memcpy(timestr+11, p+13, 8); timestr[19] = 0; return 0; } static int get_range(time_t *from, time_t *to, char *start, char *end, int max_days) { time_t cur=gettime(start); time_t pre=gettime(end); time_t sss=mktime0(),secs=3600*24*max_days; if(cur<=sss) { cur = sss; } if(pre<=sss) { pre = sss; } if(abs(cur-pre)>=secs) { if(cur>pre) { *from = cur-secs; *to = cur; } else { *from = pre-secs; *to = pre; } } else { if(cur>pre) { *from = pre; *to = cur; } else { *from = cur; *to = pre; } } return 0; } static int power_export(char *path, char *start, char *end) { int r; time_t from,to; char tmp1[100],tmp2[100]; GlobalDeviceManager *dm=&__globalDeviceManage; get_range(&from, &to, start, end, 7); get_time_str2(tmp1,sizeof(tmp1),from); get_time_str2(tmp2,sizeof(tmp2),to); sprintf(path, "/tmp/power_%s_%s.csv", tmp1, tmp2); return dev_power_xport(from, to, path); } static int file_io(void *conn, int ftype, int io, char *buf) { int r,flag=0; char tmp[200],path[200]; web_handle_t *wh=&webHandle; mg_stream_t *s=(mg_stream_t*)conn; struct mg_http_message *hm = (struct mg_http_message *)s->ev_data; switch(ftype) { case FILE_SYS_CFG: { sprintf(tmp, "/tmp/config.ini"); sys_get_path(path, INI_FILE_NAME); if(io==FILE_IMPORT) { r = upload_file(conn, tmp); if(r==0) { r = paras_check(tmp); if(r==0) { paras_copy(path, tmp); file_remove(tmp); //clear some database table exit(0); //restart smartPDU } file_remove(tmp); } } else { file_copy(tmp, path); download_file(conn, tmp); file_remove(tmp); } } break; case FILE_SERV_CFG: { sprintf(path, "/tmp/service.ini"); if(io==FILE_IMPORT) { r = upload_file(conn, path); if(r==0) { //thread_stop(THREAD_ID_POWER); r = paras_serv_xport(path, PARAS_IMPORT); file_remove(path); if(r==0) exit(0); //thread_start2(THREAD_ID_POWER); } } else { r = paras_serv_xport(path, PARAS_EXPORT); if(r==0) { r = download_file(conn, path); } file_remove(path); } } break; case FILE_ALARM_CFG: { sprintf(path, "/tmp/alarm.ini"); if(io==FILE_IMPORT) { r = upload_file(conn, path); if(r==0) { r = paras_alarm_xport(path, PARAS_IMPORT); file_remove(path); if(r==0) exit(0); } } else { r = paras_alarm_xport(path, PARAS_EXPORT); if(r==0) { r = download_file(conn, path); file_remove(path); } } } break; case FILE_SENSOR_CFG: { sprintf(path, "/tmp/sensor.ini"); if(io==FILE_IMPORT) { r = upload_file(conn, path); if(r==0) { r = paras_sensor_xport(path, PARAS_IMPORT); file_remove(path); if(r==0) exit(0); } } else { r = paras_sensor_xport(path, PARAS_EXPORT); if(r==0) { r = download_file(conn, path); file_remove(path); } } } break; case FILE_POWER_ALL: case FILE_POWER_CHN: { if(io==FILE_EXPORT) { char start[100],end[100]; gettime2(buf, "startTime=", start); gettime2(buf, "endTime=", end); r = power_export(path, start, end); if(r==0) { download_file(conn, path); file_remove(path); } } } break; case FILE_LOG_RUN: { if(io==FILE_EXPORT) { //download_file(path); } } break; case FILE_LOG_OPERA: { if(io==FILE_EXPORT) { //download_file(path); } } break; case FILE_LOG_ALARM: { if(io==FILE_EXPORT) { //download_file(path); } } break; case FILE_LOGO: { if(io==FILE_IMPORT) { char tmp[100]; sprintf(tmp, "%s/%s", IMAGE_FOLDER, LOGO_FILE); sys_get_path(path, tmp); upload_file(conn, path); } } break; case FILE_HOST_FW: { if(io==FILE_IMPORT) { sprintf(path, "%s/%s", DOWN_FOLDER, UPG_PKG_NAME); r = upload_file(conn, path); if(r==0) { printf("_____ upg_start\n"); upg_host_send(UPGRADE_EVT_UPLOAD_FINISH); } } } break; default: return -1; } return 0; } ///////////////////////////////////////////////////////////////////////// static void http_mg_cb(struct mg_connection *c, int ev, void *ev_data) { int i,j,flag=0; mg_handle_t *h=&webHandle.mg; mg_stream_t s={c,ev,ev_data}; if (ev == MG_EV_HTTP_MSG) { struct mg_http_message *hm = ev_data; for(i=0; icnt; i++) { if (h->fn[i].f && h->fn[i].uri && mg_match(hm->uri, mg_str(h->fn[i].uri), NULL)) { h->fn[i].f(&s); flag = 1; break; } } if (flag==0) { struct mg_http_serve_opts opts = {.root_dir = h->rootDir}; mg_http_serve_dir(c, ev_data, &opts); } } else if(ev == MG_EV_ACCEPT) { if (c->fn_data) { mg_tls_init(c, &h->tls); } } } static void *web_thread(void *arg) { struct mg_mgr mgr; struct mg_connection *c; mg_handle_t *mh=&webHandle.mg; thread_handle_t *h=(thread_handle_t*)arg; const char *http_addr="http://[::]:80"; const char *https_addr="https://[::]:443"; //mg_log_set(MG_LL_DEBUG); mg_mgr_init(&mgr); //sys_get_path(mh->rootDir, WEB_ROOT); #if (CHIP_TYPE == CHIP_T113s) strcpy(mh->rootDir, "/mnt/UDISK/web"); #else strcpy(mh->rootDir, "/root/run/web"); #endif if (mg_http_listen(&mgr, http_addr, http_mg_cb, NULL) == NULL) { MG_ERROR(("cannot listen on %s\n", http_addr)); return NULL; } if (mg_http_listen(&mgr, https_addr, http_mg_cb, (void*)1) == NULL) { MG_ERROR(("cannot listen on %s\n", https_addr)); return NULL; } webSetCallback(); printf("_____mgHandle.cnt: %d, rootdir: %s\n", mh->cnt, mh->rootDir); #if (CHIP_TYPE == CHIP_T113s) mh->tls.cert = mg_str(file_load2("/mnt/UDISK/app/cert/server.crt",0)); mh->tls.key = mg_str(file_load2("/mnt/UDISK/app/cert/server.key",0)); #else mh->tls.cert = mg_str(file_load2("/root/run/app/cert/server.crt",0)); mh->tls.key = mg_str(file_load2("/root/run/app/cert/server.key",0)); #endif //mh->tls.name = mg_url_host(https_addr); while(h->quit==0) { mg_mgr_poll(&mgr, 200); } mg_mgr_free(&mgr); pthread_exit(NULL); } /// @brief 系统信息 /// @param stream static void systemConfiguration(void* conn) { char *ack_str = NULL; char *g_token = NULL; mg_stream_t *s=(mg_stream_t *)conn; struct mg_http_message *hm=s->ev_data; char* rx_Head_buf=(char *)hm->head.buf; int tls=s->c->is_tls; g_token = json_to_Token_info(rx_Head_buf); // 检查token是否有效 if (g_token != NULL && !CheckLoginStatus(g_token)) { ack_str = log_AthFailedinfo_to_json(); } else { ack_str = json_to_system_config_info(tls); } http_reply(conn, 200, ack_str); if (g_token != NULL) { free(g_token); } cJSON_free((void *)ack_str); } /// @brief 多语言切换 /// @param stream static void changeLanguages(void* conn) { char* ack_str = NULL; mg_stream_t *s=(mg_stream_t*)conn; struct mg_http_message *hm=s->ev_data; char* rx_body_buf=(char*)hm->body.buf; json_to_switch_language(rx_body_buf); paras_save(); ack_str = ctrl_sts_ack_to_json(); http_reply(conn, 200, ack_str); cJSON_free((void*)ack_str); } /// @brief 登录信息 /// @param stream static void loginFunc(void* conn) { char* ack_str = NULL ; char g_token[64] = {0}; mg_stream_t *s=(mg_stream_t*)conn; struct mg_http_message *hm=s->ev_data; char *rx_body_buf=hm->body.buf; //用户信息创建-未析构 _User_Log *_newUserLogin = (_User_Log *)malloc(sizeof(_User_Log)); memset(_newUserLogin, 0, sizeof(_User_Log)); //转换json参数 if(json_to_User_login_info(rx_body_buf,_newUserLogin)!=0) { http_reply(conn, 400, NULL); return; } bool LoginFlag = false; // 查询用户信息 UserInfo User_list; INIT_LIST_HEAD(&User_list.list); if (0 == dev_get_user_info(__globalDeviceManage.db, &User_list)) { UserInfo *_UserInfoTemp = NULL; list_for_each_entry(_UserInfoTemp, &User_list.list, list) { if (_UserInfoTemp == NULL) break; if (strcmp(_UserInfoTemp->userName,_newUserLogin->user_name)==0 && strcmp(_UserInfoTemp->userPW,_newUserLogin->user_password)==0) { LoginFlag=true; _GlobalUserInfoNew = *_UserInfoTemp; break; } } } //if (strcmp(_newUserLogin.user_name, "gowone") == 0 && strcmp(_newUserLogin.user_password,"gowone520") == 0) //{ // LoginFlag = true; //} //获取随机token get_rand_str(g_token,32); //记录token strcpy(_newUserLogin->user_token,g_token); int ack_code=0; if (!LoginFlag) { ack_str = log_LoginFailedinfo_to_json(); ack_code = 201; } else { strcpy(_GlobalUserToken,g_token); list_add_tail(&_newUserLogin->list, &_GlobalUserLoginInfo.list); ack_str = log_info_to_json(g_token); ack_code = 200; } http_reply(conn, ack_code, ack_str); cJSON_free((void*)ack_str); } /// @brief 注销信息 /// @param stream static void loginOutFunc(void* conn) { char* ack_str = NULL ; char* g_token; mg_stream_t *s=(mg_stream_t*)conn; struct mg_http_message *hm=s->ev_data; char *rx_body_buf = (char*)hm->body.buf; //转换json参数 if(json_to_User_loginOut_info(rx_body_buf,&g_token)!=0) { http_reply(conn, 400, NULL); return ; } ack_str = log_info_to_json(g_token); http_reply(conn, 200, ack_str); free(g_token); cJSON_free((void*)ack_str); } /// @brief 获取用户信息 /// @param stream static void getUserInfo(void* conn) { char* ack_str = NULL ; ack_str = user_info_to_json(); http_reply(conn, 200, ack_str); cJSON_free((void*)ack_str); } /// @brief 获取菜单数据 /// @param stream static void getUserRouters(void* conn) { char* ack_str = NULL ; char* g_token=NULL; mg_stream_t *s=(mg_stream_t*)conn; struct mg_http_message *hm=s->ev_data; char *rx_Head_buf = (char*)hm->head.buf; // 查询用户信息 UserInfo User_list; INIT_LIST_HEAD(&User_list.list); // 查询角色信息 RoleInfo Role_list; INIT_LIST_HEAD(&Role_list.list); g_token = json_to_Token_info(rx_Head_buf); // 根据token获取用户及用户权限 int nRoleID=3; if (0 == dev_get_user_info(__globalDeviceManage.db, &User_list) ) { char *nName = getUserNamebyToken(g_token); if (nName != NULL) { nRoleID = GetRoleIDByUserName(nName,&User_list); } } SetMenuAuthority(nRoleID); ack_str = user_routers_info_to_json(); http_reply(conn, 200, ack_str); if (g_token != NULL) { free(g_token); } cJSON_free((void*)ack_str); } /// @brief 设备总体信息 /// @param stream static void overallStatusMonitoring(void* conn) { int ret = -1 ; cJSON *cjson=NULL; cmd_data_t cmd; _Over_All_Sts_Monitor _over_all_sts_monitor={0}; _OverBackStsInfo _over_back_sts_info; //设备总体状态信息 _OverAllPwrAckInfo _over_all_pwr_back_info; //设备电源信息 _OverAllPwrAckInfo *pall=&webHandle.stt.all; char* ack_str=NULL; mg_stream_t *s=(mg_stream_t*)conn; struct mg_http_message *hm=s->ev_data; char *rx_body_buf = (char*)hm->body.buf; //转换json参数 cjson = json_to_overall_status_monitor(rx_body_buf,&_over_all_sts_monitor); if(cjson==NULL) { if (strstr(hm->uri.buf,"type=export")) { file_io(conn, FILE_POWER_ALL, FILE_EXPORT, hm->uri.buf); } else { http_reply(conn, 400, NULL); } return; } //总电压电流信息 if(strcmp(_over_all_sts_monitor.type,"listQuery")==0) { cur_dev_addr = _over_all_sts_monitor.product_id; if(cur_dev_addr>0) { int r=0; cmd.cmd = CASCADE_CMD_GET_INFO; cmd.obj = OBJ_OVERALL; r = cascade_request(&cmd); if(r) { goto quit; } cmd.cmd = CASCADE_CMD_QUERY_CH; cascade_request(&cmd); goto quit; } else { GlobalPowerInfo __globalPowerInfo; memset(&__globalPowerInfo,0,sizeof(GlobalPowerInfo)); _over_all_pwr_back_info.product_name = __globalDeviceManage._globalDevInfo.product.name; _over_all_pwr_back_info.product_id = __globalDeviceManage._globalDevInfo.product.id; _over_all_pwr_back_info.product_number = __globalDeviceManage._globalDevInfo.product.number; //查询数据库总电源信息 if (__globalDeviceManage._globalDevInfo.product.pwr_type == SmartPDU_Tree_AC_Tree ||__globalDeviceManage._globalDevInfo.product.pwr_type == SmartPDU_Tree_AC_One ||__globalDeviceManage._globalDevInfo.product.pwr_type == SmartPDU_Tree_AC_One_B ) { if (strcmp(_over_all_sts_monitor.product_phOrder, "L1") == 0) // a相 { __globalDeviceManage.nTreeACLshow = 0; dev_search_latest_t_ac_power_statistic_info(0, 0, &_over_all_pwr_back_info,&__globalDeviceManage); ack_str = over_all_pwr_monitor_to_json(0,&_over_all_pwr_back_info); } else if (strcmp(_over_all_sts_monitor.product_phOrder, "L2") == 0) // b相 { __globalDeviceManage.nTreeACLshow = 1; dev_search_latest_t_ac_power_statistic_info(0, 1, &_over_all_pwr_back_info,&__globalDeviceManage); ack_str = over_all_pwr_monitor_to_json(1,&_over_all_pwr_back_info); } else if (strcmp(_over_all_sts_monitor.product_phOrder, "L3") == 0) // c相 { __globalDeviceManage.nTreeACLshow = 2; dev_search_latest_t_ac_power_statistic_info(0, 2, &_over_all_pwr_back_info,&__globalDeviceManage); ack_str = over_all_pwr_monitor_to_json(2,&_over_all_pwr_back_info); } } else { if (dev_search_latest_power_info(__globalDeviceManage.db, __globalDeviceManage._globalDevInfo.product.id, 0, &__globalPowerInfo) != 0) { log_e("serach total pwr err."); } _over_all_pwr_back_info.voltage = __globalPowerInfo._power_info.voltage ; _over_all_pwr_back_info.current = __globalPowerInfo._power_info.current ; _over_all_pwr_back_info.power = __globalPowerInfo._power_info.power ; _over_all_pwr_back_info.freq = __globalPowerInfo._power_info.freq ; _over_all_pwr_back_info.consumption = __globalPowerInfo._power_info.consumption ; _over_all_pwr_back_info.factor = __globalPowerInfo._power_info.factor ; } ack_str = over_all_pwr_monitor_to_json(0,&_over_all_pwr_back_info); } } //打开所有开关 else if(strcmp(_over_all_sts_monitor.type,"open")==0) { log_i("over all request:open"); //总开 int nSendAddr=0; char buff[256]; if(cur_dev_addr>0) { cmd.cmd = CASCADE_CMD_OPEN; cmd.obj = OBJ_OVERALL; cmd.chId = 0xff; cascade_request(&cmd); ack_str = ctrl_sts_ack_to_json(); goto quit; } GlobalPowerManger* _globalPowerMangerTemp = NULL ; list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list) { if(_globalPowerMangerTemp==NULL) break; if(_globalPowerMangerTemp->product_saddr==nSendAddr)continue; nSendAddr=_globalPowerMangerTemp->product_saddr; log_i("Open All address Start"); int rec=g_switch_set_all_ctrl(&__globalDeviceManage._globalRelaySampManger,_globalPowerMangerTemp->product_ch_type,_globalPowerMangerTemp->product_saddr,1); if(rec<0)log_i("Open All address:%d rec:%d:%s",nSendAddr,rec,modbus_strerror(errno)); } sprintf(buff,"$开启$|$所有$|$通道$"); dev_insert_alarm_ctrl(__globalDeviceManage.db,_globalPowerMangerTemp->product_id,ALARM_TYPE_OPRATION,buff); ack_str = ctrl_sts_ack_to_json(); } //关闭所有开关 else if(strcmp(_over_all_sts_monitor.type,"close")==0) { log_i("over all request:close"); if(cur_dev_addr>0) { cmd.cmd = CASCADE_CMD_CLOSE; cmd.obj = OBJ_OVERALL; cmd.chId = 0xff; cascade_request(&cmd); ack_str = ctrl_sts_ack_to_json(); goto quit; } //总关 int nSendAddr=0; char buff[256]; GlobalPowerManger* _globalPowerMangerTemp = NULL ; list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list) { if(_globalPowerMangerTemp==NULL) break; if(_globalPowerMangerTemp->product_saddr==nSendAddr)continue; nSendAddr=_globalPowerMangerTemp->product_saddr; log_i("Close All address Start"); int rec=g_switch_set_all_ctrl(&__globalDeviceManage._globalRelaySampManger,_globalPowerMangerTemp->product_ch_type,_globalPowerMangerTemp->product_saddr,0); if(rec<0)log_i("Close All address:%d rec:%d:%s",nSendAddr,rec,modbus_strerror(errno)); } sprintf(buff,"$关闭$|$所有$|$通道$"); dev_insert_alarm_ctrl(__globalDeviceManage.db,_globalPowerMangerTemp->product_id,ALARM_TYPE_OPRATION,buff); ack_str = ctrl_sts_ack_to_json(); } //查询历史记录 //ok else if(strcmp(_over_all_sts_monitor.type,"listHisQuery")==0) { #if 0 log_i("over all request:listHisQuery"); int ret = 0 ; int size = 0 ; int page_num = 0 ; int page_size = 0 ; page_num = atoi(_over_all_sts_monitor.page_num); page_size = atoi(_over_all_sts_monitor.page_size); GlobalPowerInfo _globalPowerInfo; INIT_LIST_HEAD(&_globalPowerInfo.list); ret = dev_search_power_info(__globalDeviceManage.db, __globalDeviceManage._globalDevInfo.product.id, 0, _over_all_sts_monitor.start_time, _over_all_sts_monitor.end_time, page_num, page_size, &size, &_globalPowerInfo); if(ret!=0) { log_e("dev all status history get error.\n"); } //返回应答 ack_str = overall_power_history_to_json(&_globalPowerInfo,&__globalDeviceManage); //释放资源 GlobalPowerInfo* node; GlobalPowerInfo* next; list_for_each_entry_safe(node, next, &_globalPowerInfo.list, list) { list_del(&node->list); free(node); } #endif } //电压统计 //1分钟1个点 6个小时 共360个点 else if(strcmp(_over_all_sts_monitor.type,"listDyTotalQuery")==0) { //申请电压统计信息参数 GlobalPowerInfo __globalPowerInfo; //清0 memset(&__globalPowerInfo,0,sizeof(GlobalPowerInfo)); if (_over_all_sts_monitor.product_pwr_type==SmartPDU_Tree_AC_Tree ||_over_all_sts_monitor.product_pwr_type==SmartPDU_Tree_AC_One ||_over_all_sts_monitor.product_pwr_type==SmartPDU_Tree_AC_One_B) { ack_str = over_all_data_t_ac_to_json(pall,&_over_all_sts_monitor, TOTAL_VOLTAGE_TYPE); } else if (_over_all_sts_monitor.lType && (strcmp(_over_all_sts_monitor.lType,"L1")==0 || strcmp(_over_all_sts_monitor.lType,"L2")==0 || strcmp(_over_all_sts_monitor.lType,"L3")==0)) { int ph_id=-1; if (strcmp(_over_all_sts_monitor.lType,"L1")==0) { ph_id=0; } else if (strcmp(_over_all_sts_monitor.lType,"L2")==0 ) { ph_id=1; } else if(strcmp(_over_all_sts_monitor.lType,"L3")==0 ) { ph_id=2; } // 查询数据库总电源信息 传给所申请的参数结构体 if (dev_search_time_t_ac_power_info(__globalDeviceManage.db, __globalDeviceManage._globalDevInfo.product.id, 0, ph_id, TOTAL_VOLTAGE_TYPE, &__globalPowerInfo, _over_all_sts_monitor.start_time, _over_all_sts_monitor.end_time) != 0) { log_e("serach total voltage err."); } //else { // 传值给总管理结构体 for (int i = 0; i < TOTAL_COUNT; i++) { strcpy(pall->_total_voltage.xAxis[i], __globalPowerInfo._total_voltage.xAxis[i]); pall->_total_voltage.ydata[i] = __globalPowerInfo._total_voltage.ydata[i]; } // 返回电压统计 ack_str = over_all_total_info_to_json(pall, TOTAL_VOLTAGE_TYPE); } } else { // 查询数据库总电源信息 传给所申请的参数结构体 if (dev_search_time_power_info(__globalDeviceManage.db, __globalDeviceManage._globalDevInfo.product.id, 0, TOTAL_VOLTAGE_TYPE, &__globalPowerInfo, _over_all_sts_monitor.start_time, _over_all_sts_monitor.end_time) != 0) { log_e("serach total voltage err."); } //else { // 传值给总管理结构体 for (int i = 0; i < TOTAL_COUNT; i++) { strcpy(pall->_total_voltage.xAxis[i], __globalPowerInfo._total_voltage.xAxis[i]); pall->_total_voltage.ydata[i] = __globalPowerInfo._total_voltage.ydata[i]; } // 返回电压统计 ack_str = over_all_total_info_to_json(pall, TOTAL_VOLTAGE_TYPE); } } } //电流统计 else if(strcmp(_over_all_sts_monitor.type,"listDlTotalQuery")==0) { #if DBUG_INFO log_i("over all request: listDlTotalQuery\n"); #endif //申请电流统计信息参数 GlobalPowerInfo __globalPowerInfo; //清0 memset(&__globalPowerInfo,0,sizeof(GlobalPowerInfo)); if (_over_all_sts_monitor.product_pwr_type==SmartPDU_Tree_AC_Tree ||_over_all_sts_monitor.product_pwr_type==SmartPDU_Tree_AC_One ||_over_all_sts_monitor.product_pwr_type==SmartPDU_Tree_AC_One_B) { ack_str = over_all_data_t_ac_to_json(pall, &_over_all_sts_monitor, TOTAL_CURRENT_TYPE); } else if (_over_all_sts_monitor.lType && (strcmp(_over_all_sts_monitor.lType,"L1")==0 || strcmp(_over_all_sts_monitor.lType,"L2")==0 || strcmp(_over_all_sts_monitor.lType,"L3")==0)) { int ph_id=-1; if (strcmp(_over_all_sts_monitor.lType,"L1")==0) { ph_id=0; } else if (strcmp(_over_all_sts_monitor.lType,"L2")==0 ) { ph_id=1; } else if(strcmp(_over_all_sts_monitor.lType,"L3")==0 ) { ph_id=2; } // 查询数据库总电源信息 传给所申请的参数结构体 if (dev_search_time_t_ac_power_info(__globalDeviceManage.db, __globalDeviceManage._globalDevInfo.product.id, 0, ph_id, TOTAL_CURRENT_TYPE, &__globalPowerInfo, _over_all_sts_monitor.start_time, _over_all_sts_monitor.end_time) != 0) { log_e("serach total current err."); } // 传值给总管理结构体 for (int i = 0; i < TOTAL_COUNT; i++) { strcpy(pall->_total_current.xAxis[i], __globalPowerInfo._total_current.xAxis[i]); pall->_total_current.ydata[i] = __globalPowerInfo._total_current.ydata[i]; } // 返回电流统计 ack_str = over_all_total_info_to_json(pall, TOTAL_CURRENT_TYPE); } else { // 查询数据库总电源信息 传给所申请的参数结构体 if (dev_search_time_power_info(__globalDeviceManage.db, __globalDeviceManage._globalDevInfo.product.id, 0, TOTAL_CURRENT_TYPE, &__globalPowerInfo, _over_all_sts_monitor.start_time, _over_all_sts_monitor.end_time) != 0) { log_e("serach total current err."); } // 传值给总管理结构体 for (int i = 0; i < TOTAL_COUNT; i++) { strcpy(pall->_total_current.xAxis[i], __globalPowerInfo._total_current.xAxis[i]); pall->_total_current.ydata[i] = __globalPowerInfo._total_current.ydata[i]; } // 返回电流统计 ack_str = over_all_total_info_to_json(pall, TOTAL_CURRENT_TYPE); } } //功率统计 else if(strcmp(_over_all_sts_monitor.type,"listGlTotalQuery")==0) { #if DBUG_INFO log_i("over all request: listGlTotalQuery\n"); #endif //申请功率统计信息参数 GlobalPowerInfo __globalPowerInfo; //清0 memset(&__globalPowerInfo,0,sizeof(GlobalPowerInfo)); if (_over_all_sts_monitor.product_pwr_type==SmartPDU_Tree_AC_Tree ||_over_all_sts_monitor.product_pwr_type==SmartPDU_Tree_AC_One ||_over_all_sts_monitor.product_pwr_type==SmartPDU_Tree_AC_One_B) { ack_str = over_all_data_t_ac_to_json(pall, &_over_all_sts_monitor, TOTAL_POWER_TYPE); } else if (_over_all_sts_monitor.lType && (strcmp(_over_all_sts_monitor.lType,"L1")==0 || strcmp(_over_all_sts_monitor.lType,"L2")==0 || strcmp(_over_all_sts_monitor.lType,"L3")==0)) { int ph_id=-1; if (strcmp(_over_all_sts_monitor.lType,"L1")==0) { ph_id=0; } else if (strcmp(_over_all_sts_monitor.lType,"L2")==0 ) { ph_id=1; } else if(strcmp(_over_all_sts_monitor.lType,"L3")==0 ) { ph_id=2; } // 查询数据库总电源信息 传给所申请的参数结构体 if (dev_search_time_t_ac_power_info(__globalDeviceManage.db, __globalDeviceManage._globalDevInfo.product.id, 0, ph_id, TOTAL_POWER_TYPE, &__globalPowerInfo, _over_all_sts_monitor.start_time, _over_all_sts_monitor.end_time) != 0) { log_e("serach total power err."); } // 传值给总管理结构体 for (int i = 0; i < TOTAL_COUNT; i++) { strcpy(pall->_total_power.xAxis[i], __globalPowerInfo._total_power.xAxis[i]); pall->_total_power.ydata[i] = __globalPowerInfo._total_power.ydata[i]; } // 返回功率统计 ack_str = over_all_total_info_to_json(pall, TOTAL_POWER_TYPE); } else { // 查询数据库总电源信息 传给所申请的参数结构体 if (dev_search_time_power_info(__globalDeviceManage.db, __globalDeviceManage._globalDevInfo.product.id, 0, TOTAL_POWER_TYPE, &__globalPowerInfo, _over_all_sts_monitor.start_time, _over_all_sts_monitor.end_time) != 0) { log_e("serach total power err."); } // 传值给总管理结构体 for (int i = 0; i < TOTAL_COUNT; i++) { strcpy(pall->_total_power.xAxis[i], __globalPowerInfo._total_power.xAxis[i]); pall->_total_power.ydata[i] = __globalPowerInfo._total_power.ydata[i]; } // 返回功率统计 ack_str = over_all_total_info_to_json(pall, TOTAL_POWER_TYPE); } } //耗电量统计 else if(strcmp(_over_all_sts_monitor.type,"listHdlTotalQuery")==0) { #if DBUG_INFO log_i("over all request: listHdlTotalQuery\n"); #endif //申请耗电量统计信息参数 GlobalPowerInfo __globalPowerInfo; //清0 memset(&__globalPowerInfo,0,sizeof(GlobalPowerInfo)); if (_over_all_sts_monitor.product_pwr_type==SmartPDU_Tree_AC_Tree ||_over_all_sts_monitor.product_pwr_type==SmartPDU_Tree_AC_One ||_over_all_sts_monitor.product_pwr_type==SmartPDU_Tree_AC_One_B) { ack_str = over_all_data_t_ac_to_json(pall, &_over_all_sts_monitor, TOTAL_POWER_CONS_TYPE); } else if (_over_all_sts_monitor.product_pwr_type >= 0) { // 查询数据库总电源信息 传给所申请的参数结构体 if (dev_search_time_power_info(__globalDeviceManage.db, __globalDeviceManage._globalDevInfo.product.id, 0, TOTAL_POWER_CONS_TYPE, &__globalPowerInfo, _over_all_sts_monitor.start_time, _over_all_sts_monitor.end_time) != 0) { log_e("serach total power consumption err."); } // 传值给总管理结构体 for (int i = 0; i < TOTAL_COUNT; i++) { strcpy(pall->_total_consumption.xAxis[i], __globalPowerInfo._total_consumption.xAxis[i]); pall->_total_consumption.ydata[i] = __globalPowerInfo._total_consumption.ydata[i]; } // 返回耗电量统计 ack_str = over_all_total_info_to_json(pall, TOTAL_POWER_CONS_TYPE); } else if (_over_all_sts_monitor.lType && (strcmp(_over_all_sts_monitor.lType,"L1")==0 || strcmp(_over_all_sts_monitor.lType,"L2")==0 || strcmp(_over_all_sts_monitor.lType,"L3")==0) &&(__globalDeviceManage._globalDevInfo.product.pwr_type == SmartPDU_Tree_AC_Tree||__globalDeviceManage._globalDevInfo.product.pwr_type == SmartPDU_Tree_AC_One||__globalDeviceManage._globalDevInfo.product.pwr_type == SmartPDU_Tree_AC_One_B) ) { int ph_id=-1; if (strcmp(_over_all_sts_monitor.lType,"L1")==0) { ph_id=0; } else if (strcmp(_over_all_sts_monitor.lType,"L2")==0 ) { ph_id=1; } else if(strcmp(_over_all_sts_monitor.lType,"L3")==0 ) { ph_id=2; } // 查询数据库总电源信息 传给所申请的参数结构体 if (dev_search_time_t_ac_power_info(__globalDeviceManage.db, __globalDeviceManage._globalDevInfo.product.id, 0, ph_id, TOTAL_POWER_CONS_TYPE, &__globalPowerInfo, _over_all_sts_monitor.start_time, _over_all_sts_monitor.end_time) != 0) { log_e("serach total power consumption err."); } // 传值给总管理结构体 for (int i = 0; i < TOTAL_COUNT; i++) { strcpy(pall->_total_consumption.xAxis[i], __globalPowerInfo._total_consumption.xAxis[i]); pall->_total_consumption.ydata[i] = __globalPowerInfo._total_consumption.ydata[i]; } // 返回耗电量统计 ack_str = over_all_total_info_to_json(pall, TOTAL_POWER_CONS_TYPE); } else { // 查询数据库总电源信息 传给所申请的参数结构体 if (dev_search_time_power_info(__globalDeviceManage.db, __globalDeviceManage._globalDevInfo.product.id, 0, TOTAL_POWER_CONS_TYPE, &__globalPowerInfo, _over_all_sts_monitor.start_time, _over_all_sts_monitor.end_time) != 0) { log_e("serach total power consumption err."); } // 传值给总管理结构体 for (int i = 0; i < TOTAL_COUNT; i++) { strcpy(pall->_total_consumption.xAxis[i], __globalPowerInfo._total_consumption.xAxis[i]); pall->_total_consumption.ydata[i] = __globalPowerInfo._total_consumption.ydata[i]; } // 返回耗电量统计 ack_str = over_all_total_info_to_json(pall, TOTAL_POWER_CONS_TYPE); } } //查询系统总数情况 else if(strcmp(_over_all_sts_monitor.type,"listTotalQuery")==0) { #if DBUG_INFO log_i("over all request: listTotalQuery\n"); #endif //初始化系统总数结构体 SystemTotalInfo __system_total_info; memset(&__system_total_info, 0, sizeof(SystemTotalInfo)); struct tm *t; struct timeval tv; char start_time[32] = {0}; char stop_time[32] = {0}; gettimeofday(&tv, NULL); t = localtime(&tv.tv_sec); sprintf(start_time, "%04d-%02d-%02d %02d:%02d:%02d", t->tm_year + 1900, t->tm_mon+1, t->tm_mday, 0,0,0); //sprintf(start_time, "%04d-%02d-%02d %02d:%02d:%02d", 1970, 1, 1, 0,0,0); log_d(start_time); sprintf(stop_time, "%04d-%02d-%02d %02d:%02d:%02d", t->tm_year + 1900, t->tm_mon+1, t->tm_mday, 23,59, 59); //sprintf(stop_time, "%04d-%02d-%02d %02d:%02d:%02d", 1970, 1, 1, 23,59, 59); log_d(stop_time); //从数据库获取参数信息 if(dev_get_system_total_info(__globalDeviceManage.db,__globalDeviceManage._globalDevInfo.product.id,0,&__system_total_info,start_time,stop_time)!=0) { log_e("serach total System total err."); } int nSumChannel=0; GlobalPowerManger* _globalPowerMangerTemp = NULL ; list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list) { nSumChannel+=1; } __system_total_info.channel_total = nSumChannel ; //获取通道总数 // __GetSystemTotalInfo.channel_total = _globalDeviceManager->useSlaveCount; //获取系统总数情况 _over_back_sts_info.system_total.channel_total = __system_total_info.channel_total; _over_back_sts_info.system_total.log_total = __system_total_info.log_total; _over_back_sts_info.system_total.sensor_total = __system_total_info.sensor_total; _over_back_sts_info.system_total.warn_total = __system_total_info.warn_total; //返回系统总数情况 ack_str = over_system_total_monitor_to_json(&_over_back_sts_info); } //功率趋势图接口 else if(strcmp(_over_all_sts_monitor.type,"listGlAllTotalQuery")==0) { #if DBUG_INFO log_i("over all request: listGlAllTotalQuery\n"); #endif //初始化功率趋势图参数 GlobalPowerInfo __PowerTrendInfo; //清0 memset(&__PowerTrendInfo,0,sizeof(GlobalPowerInfo)); #if 1 if (_over_all_sts_monitor.lType && (strcmp(_over_all_sts_monitor.lType,"L1")==0 || strcmp(_over_all_sts_monitor.lType,"L2")==0 || strcmp(_over_all_sts_monitor.lType,"L3")==0) &&(__globalDeviceManage._globalDevInfo.product.pwr_type == SmartPDU_Tree_AC_Tree||__globalDeviceManage._globalDevInfo.product.pwr_type == SmartPDU_Tree_AC_One||__globalDeviceManage._globalDevInfo.product.pwr_type == SmartPDU_Tree_AC_One_B) ) { int ph_id=-1; if (strcmp(_over_all_sts_monitor.lType,"L1")==0) { ph_id=0; } else if (strcmp(_over_all_sts_monitor.lType,"L2")==0 ) { ph_id=1; } else if(strcmp(_over_all_sts_monitor.lType,"L3")==0 ) { ph_id=2; } // 查询数据库总电源信息 传给所申请的参数结构体 if (dev_search_power_AC_trend_info(__globalDeviceManage.db, __globalDeviceManage._globalDevInfo.product.id, 0, ph_id, &__PowerTrendInfo, _over_all_sts_monitor.start_time, _over_all_sts_monitor.end_time) != 0) { log_e("serach total power consumption err."); } } else { // 查询数据库总电源信息 传给所申请的参数结构体 if (dev_search_power_trend_info(__globalDeviceManage.db, __globalDeviceManage._globalDevInfo.product.id, 0, &__PowerTrendInfo, _over_all_sts_monitor.start_time, _over_all_sts_monitor.end_time) != 0) { log_e("serach total power consumption err."); } } //传值给总管理结构体 for(int i=0;i< TOTAL_COUNT;i++) { strcpy(_over_all_pwr_back_info._Power_Trend_Info.xAxis[i],__PowerTrendInfo._power_trend_info.xAxis[i]); _over_all_pwr_back_info._Power_Trend_Info.ydata[POWER_MERITORIOUS_TYPE][i] = __PowerTrendInfo._power_trend_info.ydata[POWER_MERITORIOUS_TYPE][i]; _over_all_pwr_back_info._Power_Trend_Info.ydata[POWER_REACTIVE_TYPE][i] = __PowerTrendInfo._power_trend_info.ydata[POWER_REACTIVE_TYPE][i]; _over_all_pwr_back_info._Power_Trend_Info.ydata[POWER_APPARENT_TYPE][i] = __PowerTrendInfo._power_trend_info.ydata[POWER_APPARENT_TYPE][i]; } #else for(int i=0;i< TOTAL_COUNT;i++) { strcpy(_over_all_pwr_back_info._Power_Trend_Info.xAxis[i],"00:00 "); _over_all_pwr_back_info._Power_Trend_Info.ydata[POWER_MERITORIOUS_TYPE][i] = 10+i; _over_all_pwr_back_info._Power_Trend_Info.ydata[POWER_REACTIVE_TYPE][i] = 20+i; _over_all_pwr_back_info._Power_Trend_Info.ydata[POWER_APPARENT_TYPE][i] = 30+i; } #endif //返回功率趋势 ack_str = over_power_trend_to_json(&_over_all_pwr_back_info); } quit: cJSON_Delete(cjson); http_reply(conn, 200, ack_str); cJSON_free((void*)ack_str); } /// @brief 电源通道 /// @param stream static void channelStatusMonitoring(void* conn) { int ret = -1 ; cJSON *cjson; cmd_data_t cmd; _OverChnPwrRequest _over_chn_pwr_request; _OverAllPwrAckInfo _over_all_pwr_back_info; _OverAllPwrAckInfo *pch=&webHandle.stt.chn; char* ack_str = NULL ; mg_stream_t *s=(mg_stream_t*)conn; struct mg_http_message *hm=s->ev_data; char *rx_body_buf=(char*)hm->body.buf; //转换json参数 memset(&_over_chn_pwr_request,0,sizeof(_OverChnPwrRequest)); cjson = json_to_chn_pwr_status_monitor(rx_body_buf,&_over_chn_pwr_request); if(cjson==NULL) { if (strstr(hm->uri.buf,"type=export")) { file_io(conn, FILE_POWER_CHN, FILE_EXPORT, hm->uri.buf); } return; } if (_over_chn_pwr_request.Zerotype!=NULL) { if (strcmp(_over_chn_pwr_request.Zerotype, "open") == 0) // 零线开 { int ret = 0; int product_chn_id = 0; char buff[256]; log_i("channel NF status request:open"); product_chn_id = _over_chn_pwr_request.productChId; if (cur_dev_addr > 0) { cmd.cmd = CASCADE_CMD_OPEN_NF; cmd.obj = OBJ_CHANNEL; cmd.chId = product_chn_id; cascade_request(&cmd); ack_str = ctrl_sts_ack_to_json(); goto quit; } GlobalPowerManger *_globalPowerMangerTemp = NULL; list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list) { // log_d("channel:%d", _globalPowerMangerTemp->product_ch_id); if (_globalPowerMangerTemp == NULL) break; if (product_chn_id == _globalPowerMangerTemp->product_ch_id) { log_d("switch ctrl:%d", _globalPowerMangerTemp->product_ch_id); ret = g_switch_set_t_ac_chn_NF_ctrl(&__globalDeviceManage._globalRelaySampManger, _globalPowerMangerTemp->product_saddr, _globalPowerMangerTemp->product_ch_addr, 1); if (ret < 0) { ret = g_switch_set_t_ac_chn_NF_ctrl(&__globalDeviceManage._globalRelaySampManger, _globalPowerMangerTemp->product_saddr, _globalPowerMangerTemp->product_ch_addr, 1); } sprintf(buff, "$开启$|$通道$|%d Naught wire!", _globalPowerMangerTemp->product_ch_id); dev_insert_alarm_ctrl(__globalDeviceManage.db, _globalPowerMangerTemp->product_id, ALARM_TYPE_OPRATION, buff); break; } } ack_str = ctrl_sts_ack_to_json(); } else if (strcmp(_over_chn_pwr_request.Zerotype, "close") == 0) // 零线关 { int ret = 0; int product_chn_id = 0; char buff[256]; log_i("channel NF status request:open"); product_chn_id = _over_chn_pwr_request.productChId; if (cur_dev_addr > 0) { cmd.cmd = CASCADE_CMD_CLOSE_NF; cmd.obj = OBJ_CHANNEL; cmd.chId = product_chn_id; cascade_request(&cmd); ack_str = ctrl_sts_ack_to_json(); goto quit; } GlobalPowerManger *_globalPowerMangerTemp = NULL; list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list) { // log_d("channel:%d", _globalPowerMangerTemp->product_ch_id); if (_globalPowerMangerTemp == NULL) break; if (product_chn_id == _globalPowerMangerTemp->product_ch_id) { log_d("switch ctrl:%d", _globalPowerMangerTemp->product_ch_id); ret = g_switch_set_t_ac_chn_NF_ctrl(&__globalDeviceManage._globalRelaySampManger, _globalPowerMangerTemp->product_saddr, _globalPowerMangerTemp->product_ch_addr, 0); if (ret < 0) { ret = g_switch_set_t_ac_chn_NF_ctrl(&__globalDeviceManage._globalRelaySampManger, _globalPowerMangerTemp->product_saddr, _globalPowerMangerTemp->product_ch_addr, 0); } sprintf(buff, "$关闭$|$通道$|%d Naught wire!", _globalPowerMangerTemp->product_ch_id); dev_insert_alarm_ctrl(__globalDeviceManage.db, _globalPowerMangerTemp->product_id, ALARM_TYPE_OPRATION, buff); break; } } ack_str = ctrl_sts_ack_to_json(); } } if (_over_chn_pwr_request.type==NULL) { goto quit; } if(strcmp(_over_chn_pwr_request.type,"listQuery")==0||strcmp(_over_chn_pwr_request.type,"resetChannel")==0) { //log_i("channel status request:listQuery"); //log_d(rx_body_buf); if (strcmp(_over_chn_pwr_request.type,"resetChannel")==0) { //__globalDeviceManage._ReloadChm_flag=true; //ResetChmData(); //__globalDeviceManage._ReloadChm_flag=false; } GlobalPowerInfo _powerInfo; GlobalPowerManger* _globalPowerMangerTemp = NULL ; int product_chn_id = 0 ; _OverChnPwrAckInfo _over_chn_pwr_back_info; INIT_LIST_HEAD(&_over_chn_pwr_back_info.list); product_chn_id = _over_chn_pwr_request.productChId; cur_dev_addr = _over_chn_pwr_request.product_id; if(cur_dev_addr>0) { int r; cmd.cmd = CASCADE_CMD_GET_INFO; cmd.obj = OBJ_CHANNEL; r = cascade_request(&cmd); if(r) { goto quit; } cmd.cmd = CASCADE_CMD_QUERY_CH; r = cascade_request(&cmd); if(r) { goto quit; } cascade_get_ch(&_over_chn_pwr_back_info); } else { if(product_chn_id==0) { lock_s_hold(LOCK_ID_POWER_UPDATE); dev_search_latest_power_All_info(&__globalDeviceManage,&_over_chn_pwr_back_info, cur_dev_addr); lock_s_release(LOCK_ID_POWER_UPDATE); } else //指定通道 { list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list) { if(product_chn_id==_globalPowerMangerTemp->product_ch_id) { break; } } //更新数据 //log_d("serach ch%d pwr ok.",product_chn_id); _OverChnPwrAckInfo* _overChnPwrBackInfoTemp = (_OverChnPwrAckInfo*)malloc(sizeof(_OverChnPwrAckInfo)); if(_overChnPwrBackInfoTemp==NULL) { log_e("_overChnPwrBackInfoTemp malloc err."); } //查询数据库总电源信息 if(dev_search_latest_power_info(__globalDeviceManage.db, __globalDeviceManage._globalDevInfo.product.id, product_chn_id, &_powerInfo)!=0) { log_e("serach total pwr err."); } { //填数据 _overChnPwrBackInfoTemp->product_name = __globalDeviceManage._globalDevInfo.product.name; _overChnPwrBackInfoTemp->product_number = __globalDeviceManage._globalDevInfo.product.number; _overChnPwrBackInfoTemp->product_id = __globalDeviceManage._globalDevInfo.product.id; _overChnPwrBackInfoTemp->productChName = _globalPowerMangerTemp->product_ch_name; _overChnPwrBackInfoTemp->productChId = _globalPowerMangerTemp->product_ch_id; _overChnPwrBackInfoTemp->status = _powerInfo._power_info.status; _overChnPwrBackInfoTemp->NF_status = _powerInfo._power_info.NF_status; _overChnPwrBackInfoTemp->voltage = _powerInfo._power_info.voltage; _overChnPwrBackInfoTemp->current = _powerInfo._power_info.current; _overChnPwrBackInfoTemp->power = _powerInfo._power_info.power ; _overChnPwrBackInfoTemp->freq = _powerInfo._power_info.freq ; _overChnPwrBackInfoTemp->consumption = _powerInfo._power_info.consumption ; _overChnPwrBackInfoTemp->factor = _powerInfo._power_info.factor ; list_add_tail(&_overChnPwrBackInfoTemp->list,&_over_chn_pwr_back_info.list); } } ack_str = over_chn_pwr_monitor_to_json(&_over_chn_pwr_back_info); _OverChnPwrAckInfo *node,*next; list_for_each_entry_safe(node, next, &_over_chn_pwr_back_info.list, list) { list_del(&node->list); free(node); } } } else if(strcmp(_over_chn_pwr_request.type,"open")==0)//通道开 { int ret=0; int product_chn_id = 0 ; char buff[256]; log_i("channel status request:open"); /* * todo:添加控制 */ product_chn_id = _over_chn_pwr_request.productChId; if(cur_dev_addr>0) { cmd.cmd = CASCADE_CMD_OPEN; cmd.obj = OBJ_CHANNEL; cmd.chId = product_chn_id; cascade_request(&cmd); ack_str = ctrl_sts_ack_to_json(); goto quit; } log_d("channel id:%d", product_chn_id); // product_chn_id = strtol(_over_chn_pwr_request.productChId,NULL,10); // log_d("productChId:%d",product_chn_id); GlobalPowerManger* _globalPowerMangerTemp = NULL ; list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list) { //log_d("channel:%d", _globalPowerMangerTemp->product_ch_id); if(_globalPowerMangerTemp==NULL) break; if(product_chn_id==_globalPowerMangerTemp->product_ch_id) { log_d("switch ctrl:%d",_globalPowerMangerTemp->product_ch_id); ret=g_switch_set_all_chn_ctrl(&__globalDeviceManage._globalRelaySampManger,_globalPowerMangerTemp, _globalPowerMangerTemp->product_saddr, _globalPowerMangerTemp->product_ch_addr, 1,false); if (ret < 0) { ret = g_switch_set_all_chn_ctrl(&__globalDeviceManage._globalRelaySampManger, _globalPowerMangerTemp, _globalPowerMangerTemp->product_saddr, _globalPowerMangerTemp->product_ch_addr, 1,false); } char buff[256]; sprintf(buff,"$开启$|$通道$|%d",_globalPowerMangerTemp->product_ch_id); dev_insert_alarm_ctrl(__globalDeviceManage.db,_globalPowerMangerTemp->product_id,ALARM_TYPE_OPRATION,buff); break; } } ack_str = ctrl_sts_ack_to_json(); } else if(strcmp(_over_chn_pwr_request.type,"close")==0)//通道关 { log_i("channel status request:close"); /* * todo:添加控制 */ char buff[256]; int product_chn_id = 0 ; product_chn_id = _over_chn_pwr_request.productChId; if(cur_dev_addr>0) { cmd.cmd = CASCADE_CMD_CLOSE; cmd.obj = OBJ_CHANNEL; cmd.chId = product_chn_id; cascade_request(&cmd); ack_str = ctrl_sts_ack_to_json(); goto quit; } // product_chn_id = strtol(_over_chn_pwr_request.productChId,NULL,10); // log_d("productChId:%d",product_chn_id); GlobalPowerManger* _globalPowerMangerTemp = NULL ; list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list) { if(_globalPowerMangerTemp==NULL) break; if(product_chn_id==_globalPowerMangerTemp->product_ch_id) { //log_d("switch ctrl:%d",_globalPowerMangerTemp->product_ch_id); ret=g_switch_set_all_chn_ctrl(&__globalDeviceManage._globalRelaySampManger,_globalPowerMangerTemp, _globalPowerMangerTemp->product_saddr, _globalPowerMangerTemp->product_ch_addr ,//多版端口余8 0,false); if (ret < 0) { ret = g_switch_set_all_chn_ctrl(&__globalDeviceManage._globalRelaySampManger, _globalPowerMangerTemp, _globalPowerMangerTemp->product_saddr, _globalPowerMangerTemp->product_ch_addr, // 多版端口余8 0,false); /* code */ } sprintf(buff,"$关闭$|$通道$|%d",_globalPowerMangerTemp->product_ch_id); dev_insert_alarm_ctrl(__globalDeviceManage.db,_globalPowerMangerTemp->product_id,ALARM_TYPE_OPRATION,buff); break; } } ack_str = ctrl_sts_ack_to_json(); } else if(strcmp(_over_chn_pwr_request.type,"save")==0)//负载 { log_i("channel status request:save"); if(cur_dev_addr>0) { cmd.cmd = CASCADE_CMD_SAVE; cmd.obj = OBJ_CHANNEL; cmd.chId = _over_chn_pwr_request.productChId; cascade_request(&cmd); ack_str = ctrl_sts_ack_to_json(); goto quit; } GlobalPowerManger *_globalPowerMangerTemp = NULL; list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list) { if (_over_chn_pwr_request.productChId == _globalPowerMangerTemp->product_ch_id) { break; } } if (_globalPowerMangerTemp != NULL) { if (strlen(_over_chn_pwr_request.productChName)<32) { strcpy(_globalPowerMangerTemp->product_ch_name, _over_chn_pwr_request.productChName); if (dev_update_power_manage_genera_info(__globalDeviceManage.db, __globalDeviceManage._globalDevInfo.product.id, _globalPowerMangerTemp->product_ch_id, _globalPowerMangerTemp) != 0) { log_e("update pwr general data err."); } }else{ log_e("ChName too long."); } } ack_str = ctrl_sts_ack_to_json(); } else if(strcmp(_over_chn_pwr_request.type,"listHisQuery")==0) //历史记录查询 { #if 0 int ret = 0 ; int size = 0 ; int h_pwrchn = 0 ; int page_num = 0 ; int page_size = 0 ; GlobalPowerInfo _globalPowerInfo; INIT_LIST_HEAD(&_globalPowerInfo.list); h_pwrchn = strtol(_over_chn_pwr_request.productChId,NULL,10); page_num = atoi(_over_chn_pwr_request.pageNum); page_size = atoi(_over_chn_pwr_request.pageSize); //查询数据 ret = dev_search_power_info(__globalDeviceManage.db, __globalDeviceManage._globalDevInfo.product.id, h_pwrchn, _over_chn_pwr_request.start_time, _over_chn_pwr_request.end_time, page_num, page_size, &size, &_globalPowerInfo); if(ret!=0) { log_e("dev all status history get error.\n"); } //应答 ack_str = over_channel_power_history_to_json(&_globalPowerInfo, &__globalDeviceManage._globalDevInfo, _over_chn_pwr_request.productChName, h_pwrchn); //释放资源 GlobalPowerInfo* node; GlobalPowerInfo* next; list_for_each_entry_safe(node, next, &_globalPowerInfo.list, list) { list_del(&node->list); free(node); } #endif } else if(strcmp(_over_chn_pwr_request.type,"listDyTotalQuery")==0) { #if DBUG_INFO log_i("over all request: listDyTotalQuery\n"); #endif int product_chn_id = 0 ; product_chn_id = _over_chn_pwr_request.productChId; /* log_d("productChId:%d",product_chn_id); log_i("channel status request:listDyTotalQuery"); log_d("productChId:%d",_over_chn_pwr_request.productChId); log_d("start_time:%s",_over_chn_pwr_request.start_time); log_d("end_time:%s",_over_chn_pwr_request.end_time); log_d("lType:%s",_over_chn_pwr_request.lType); log_d("type:%s",_over_chn_pwr_request.type); log_d("user_token:%s",_over_chn_pwr_request.user_token); */ //ack_str = ctrl_sts_ack_to_json(); //申请电压统计信息参数 GlobalPowerInfo __globalPowerInfo; //清0 memset(&__globalPowerInfo,0,sizeof(GlobalPowerInfo)); //查询数据库通道电源信息 传给所申请的参数结构体 if (_over_chn_pwr_request.lType && (strcmp(_over_chn_pwr_request.lType,"L1")==0 || strcmp(_over_chn_pwr_request.lType,"L2")==0 || strcmp(_over_chn_pwr_request.lType,"L3")==0)) { int ph_id=-1; if (strcmp(_over_chn_pwr_request.lType,"L1")==0) { ph_id=0; } else if (strcmp(_over_chn_pwr_request.lType,"L2")==0 ) { ph_id=1; } else if(strcmp(_over_chn_pwr_request.lType,"L3")==0 ) { ph_id=2; } // 查询数据库总电源信息 传给所申请的参数结构体 if (dev_search_time_t_ac_power_info(__globalDeviceManage.db, __globalDeviceManage._globalDevInfo.product.id, product_chn_id, ph_id, TOTAL_VOLTAGE_TYPE, &__globalPowerInfo, _over_chn_pwr_request.start_time, _over_chn_pwr_request.end_time) != 0) { log_e("serach total power voltage err."); } // else { // 传值给总管理结构体 for (int i = 0; i < TOTAL_COUNT; i++) { strcpy(pch->_total_voltage.xAxis[i], __globalPowerInfo._total_voltage.xAxis[i]); pch->_total_voltage.ydata[i] = __globalPowerInfo._total_voltage.ydata[i]; } // 返回电压统计 ack_str = over_all_total_info_to_json(pch, TOTAL_VOLTAGE_TYPE); } } else { if (dev_search_time_power_info(__globalDeviceManage.db, __globalDeviceManage._globalDevInfo.product.id, product_chn_id, TOTAL_VOLTAGE_TYPE, &__globalPowerInfo, _over_chn_pwr_request.start_time, _over_chn_pwr_request.end_time) != 0) { log_e("serach total voltage err."); } // else { // 传值给总管理结构体 for (int i = 0; i < TOTAL_COUNT; i++) { strcpy(pch->_total_voltage.xAxis[i], __globalPowerInfo._total_voltage.xAxis[i]); pch->_total_voltage.ydata[i] = __globalPowerInfo._total_voltage.ydata[i]; } // 返回电压统计 ack_str = over_all_total_info_to_json(pch, TOTAL_VOLTAGE_TYPE); } } } //电流统计 else if(strcmp(_over_chn_pwr_request.type,"listDlTotalQuery")==0) { #if DBUG_INFO log_i("over all request: listDlTotalQuery\n"); #endif int product_chn_id = 0 ; log_i("channel status request:listDlTotalQuery"); product_chn_id = _over_chn_pwr_request.productChId; log_d("productChId:%d",product_chn_id); //申请电流统计信息参数 GlobalPowerInfo __globalPowerInfo; //清0 memset(&__globalPowerInfo,0,sizeof(GlobalPowerInfo)); //查询数据库通道电源信息 传给所申请的参数结构体 if (_over_chn_pwr_request.lType && (strcmp(_over_chn_pwr_request.lType,"L1")==0 || strcmp(_over_chn_pwr_request.lType,"L2")==0 || strcmp(_over_chn_pwr_request.lType,"L3")==0)) { int ph_id=-1; if (strcmp(_over_chn_pwr_request.lType,"L1")==0) { ph_id=0; } else if (strcmp(_over_chn_pwr_request.lType,"L2")==0 ) { ph_id=1; } else if(strcmp(_over_chn_pwr_request.lType,"L3")==0 ) { ph_id=2; } // 查询数据库总电源信息 传给所申请的参数结构体 if (dev_search_time_t_ac_power_info(__globalDeviceManage.db, __globalDeviceManage._globalDevInfo.product.id, product_chn_id, ph_id, TOTAL_CURRENT_TYPE, &__globalPowerInfo, _over_chn_pwr_request.start_time, _over_chn_pwr_request.end_time) != 0) { log_e("serach total power current err."); } // else { // 传值给总管理结构体 for (int i = 0; i < TOTAL_COUNT; i++) { strcpy(pch->_total_current.xAxis[i], __globalPowerInfo._total_current.xAxis[i]); pch->_total_current.ydata[i] = __globalPowerInfo._total_current.ydata[i]; } // 返回电流统计 ack_str = over_all_total_info_to_json(pch, TOTAL_CURRENT_TYPE); } } else { // 查询数据库总电源信息 传给所申请的参数结构体 if (dev_search_time_power_info(__globalDeviceManage.db, __globalDeviceManage._globalDevInfo.product.id, product_chn_id, TOTAL_CURRENT_TYPE, &__globalPowerInfo, _over_chn_pwr_request.start_time, _over_chn_pwr_request.end_time) != 0) { log_e("serach total current err."); } //else { // 传值给总管理结构体 for (int i = 0; i < TOTAL_COUNT; i++) { strcpy(pch->_total_current.xAxis[i], __globalPowerInfo._total_current.xAxis[i]); pch->_total_current.ydata[i] = __globalPowerInfo._total_current.ydata[i]; } // 返回电流统计 ack_str = over_all_total_info_to_json(pch, TOTAL_CURRENT_TYPE); } } } //功率统计 else if(strcmp(_over_chn_pwr_request.type,"listGlTotalQuery")==0) { #if DBUG_INFO log_i("over all request: listGlTotalQuery\n"); #endif int product_chn_id = 0 ; log_i("channel status request:listGlTotalQuery"); product_chn_id = _over_chn_pwr_request.productChId; log_d("productChId:%d",product_chn_id); //申请功率统计信息参数 GlobalPowerInfo __globalPowerInfo; //清0 memset(&__globalPowerInfo,0,sizeof(GlobalPowerInfo)); //查询数据库通道电源信息 传给所申请的参数结构体 if (_over_chn_pwr_request.lType && (strcmp(_over_chn_pwr_request.lType,"L1")==0 || strcmp(_over_chn_pwr_request.lType,"L2")==0 || strcmp(_over_chn_pwr_request.lType,"L3")==0)) { int ph_id=-1; if (strcmp(_over_chn_pwr_request.lType,"L1")==0) { ph_id=0; } else if (strcmp(_over_chn_pwr_request.lType,"L2")==0 ) { ph_id=1; } else if(strcmp(_over_chn_pwr_request.lType,"L3")==0 ) { ph_id=2; } // 查询数据库总电源信息 传给所申请的参数结构体 if (dev_search_time_t_ac_power_info(__globalDeviceManage.db, __globalDeviceManage._globalDevInfo.product.id, product_chn_id, ph_id, TOTAL_POWER_TYPE, &__globalPowerInfo, _over_chn_pwr_request.start_time, _over_chn_pwr_request.end_time) != 0) { log_e("serach total power err."); } //else { // 传值给总管理结构体 for (int i = 0; i < TOTAL_COUNT; i++) { strcpy(pch->_total_power.xAxis[i], __globalPowerInfo._total_power.xAxis[i]); pch->_total_power.ydata[i] = __globalPowerInfo._total_power.ydata[i]; } // 返回功率统计 ack_str = over_all_total_info_to_json(pch, TOTAL_POWER_TYPE); } } else { // 查询数据库总电源信息 传给所申请的参数结构体 if (dev_search_time_power_info(__globalDeviceManage.db, __globalDeviceManage._globalDevInfo.product.id, product_chn_id, TOTAL_POWER_TYPE, &__globalPowerInfo, _over_chn_pwr_request.start_time, _over_chn_pwr_request.end_time) != 0) { log_e("serach total power err."); } //else { // 传值给总管理结构体 for (int i = 0; i < TOTAL_COUNT; i++) { strcpy(pch->_total_power.xAxis[i], __globalPowerInfo._total_power.xAxis[i]); pch->_total_power.ydata[i] = __globalPowerInfo._total_power.ydata[i]; } // 返回功率统计 ack_str = over_all_total_info_to_json(pch, TOTAL_POWER_TYPE); } } } //耗电量统计 else if(strcmp(_over_chn_pwr_request.type,"listHdlTotalQuery")==0) { #if DBUG_INFO log_i("over all request: listHdlTotalQuery\n"); #endif int product_chn_id = 0 ; log_i("channel status request:listHdlTotalQuery"); product_chn_id = _over_chn_pwr_request.productChId; log_d("productChId:%d",product_chn_id); //申请耗电量统计信息参数 GlobalPowerInfo __globalPowerInfo; //清0 memset(&__globalPowerInfo,0,sizeof(GlobalPowerInfo)); //查询数据库通道电源信息 传给所申请的参数结构体 if (_over_chn_pwr_request.lType && (strcmp(_over_chn_pwr_request.lType,"L1")==0 || strcmp(_over_chn_pwr_request.lType,"L2")==0 || strcmp(_over_chn_pwr_request.lType,"L3")==0)) { int ph_id=-1; if (strcmp(_over_chn_pwr_request.lType,"L1")==0) { ph_id=0; } else if (strcmp(_over_chn_pwr_request.lType,"L2")==0 ) { ph_id=1; } else if(strcmp(_over_chn_pwr_request.lType,"L3")==0 ) { ph_id=2; } // 查询数据库总电源信息 传给所申请的参数结构体 if (dev_search_time_t_ac_power_info(__globalDeviceManage.db, __globalDeviceManage._globalDevInfo.product.id, product_chn_id, ph_id, TOTAL_POWER_CONS_TYPE, &__globalPowerInfo, _over_chn_pwr_request.start_time, _over_chn_pwr_request.end_time) != 0) { log_e("serach total power err."); } // else { for (int i = 0; i < TOTAL_COUNT; i++) { strcpy(pch->_total_consumption.xAxis[i], __globalPowerInfo._total_consumption.xAxis[i]); pch->_total_consumption.ydata[i] = __globalPowerInfo._total_consumption.ydata[i]; } // 返回耗电量统计 ack_str = over_all_total_info_to_json(pch, TOTAL_POWER_CONS_TYPE); } } else { // 查询数据库总电源信息 传给所申请的参数结构体 if (dev_search_time_power_info(__globalDeviceManage.db, __globalDeviceManage._globalDevInfo.product.id, product_chn_id, TOTAL_POWER_CONS_TYPE, &__globalPowerInfo, _over_chn_pwr_request.start_time, _over_chn_pwr_request.end_time) != 0) { log_e("serach total power consumption err."); } // else { // 传值给总管理结构体 for (int i = 0; i < TOTAL_COUNT; i++) { strcpy(pch->_total_consumption.xAxis[i], __globalPowerInfo._total_consumption.xAxis[i]); pch->_total_consumption.ydata[i] = __globalPowerInfo._total_consumption.ydata[i]; } // 返回耗电量统计 ack_str = over_all_total_info_to_json(pch, TOTAL_POWER_CONS_TYPE); } } } else if(strcmp(_over_chn_pwr_request.type,"threeTypeSave")==0) { GlobalPowerManger *_globalPowerMangerTemp = NULL; if(cur_dev_addr>0) { cmd.cmd = CASCADE_CMD_SAVE3; cmd.obj = OBJ_CHANNEL; cmd.chId = _over_chn_pwr_request.productChId; cascade_request(&cmd); goto quit; } list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list) { if (_over_chn_pwr_request.productChId == _globalPowerMangerTemp->product_ch_id) { break; } } if (__globalDeviceManage._globalDevInfo.product.pwr_type == SmartPDU_Tree_AC_One ||__globalDeviceManage._globalDevInfo.product.pwr_type == SmartPDU_Tree_AC_One_B) { if (_over_chn_pwr_request.outputType == 1) { http_reply(conn, 201, ack_str); cJSON_free((void *)ack_str); return; } } if (_globalPowerMangerTemp != NULL) { GlobalTreeACManager *_globalTACManager = NULL; list_for_each_entry(_globalTACManager, &_globalPowerMangerTemp->list_Tree_AC, list_Tree_AC) { if (_over_chn_pwr_request.outputType == 2) { if (strcmp(g_product_t_ac_type_str[_globalTACManager->product_ph_type], _over_chn_pwr_request.productPhOrder) == 0) { _globalTACManager->product_ph_outputStatus = 1; } else { _globalTACManager->product_ph_outputStatus = 2; } } else { _globalTACManager->product_ph_outputStatus = 1; } _globalTACManager->product_ph_outputType=_over_chn_pwr_request.outputType; if (dev_update_t_ac_power_manage_info(__globalDeviceManage.db, _globalTACManager) != 0) { log_e("update pwr general data err."); } } } } else if (strcmp(_over_chn_pwr_request.type, "batteryReset") == 0) // 耗电量复位 { GlobalPowerManger *_globalPowerMangerTemp = NULL; char *pCHlist; char *pCHListSave; pCHlist = strtok_r(_over_chn_pwr_request.strProductChIds, ",", &pCHListSave); // 其他版本功能 while (pCHlist != NULL) { int g_pwr_ch_id = atoi(pCHlist); _globalPowerMangerTemp=NULL; list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list) { if (g_pwr_ch_id != _globalPowerMangerTemp->product_ch_id) { continue; } if (__globalDeviceManage._globalDevInfo.product.pwr_type == SmartPDU_DC) { if(g_switch_set_dcpdu_chn_reset(&__globalDeviceManage._globalRelaySampManger, _globalPowerMangerTemp->product_saddr, _globalPowerMangerTemp->product_ch_addr-1)<0) { log_e("Error: g_switch_set_dcpdu_chn_reset"); } } else { if (__globalDeviceManage._globalDevInfo.product.pwr_type == SmartPDU_AC) { if (g_switch_set_t_ac_chn_reset(&__globalDeviceManage._globalRelaySampManger, _globalPowerMangerTemp->product_saddr, _globalPowerMangerTemp->product_ch_addr - 1) < 0) { log_e("Error: g_switch_set_t_ac_chn_reset"); } } else { GlobalTreeACManager *_globalTACManager = NULL; list_for_each_entry(_globalTACManager, &_globalPowerMangerTemp->list_Tree_AC, list_Tree_AC) { if (__globalDeviceManage._globalDevInfo.product.pwr_type == SmartPDU_Tree_AC_Tree) { if (g_switch_set_t_ac_phchn_reset(&__globalDeviceManage._globalRelaySampManger, _globalTACManager->product_saddr, _globalTACManager->product_ch_addr - 1) < 0) { log_e("Error: g_switch_set_t_ac_phchn_reset"); } } else { if (g_switch_set_t_ac_chn_reset(&__globalDeviceManage._globalRelaySampManger, _globalTACManager->product_saddr, _globalTACManager->product_ch_addr - 1) < 0) { log_e("Error: g_switch_set_t_ac_chn_reset"); } } } } } } pCHlist = strtok_r(NULL, ",", &pCHListSave); } char log_buff[256]; sprintf(log_buff, "Reset power consumption!"); dev_insert_alarm_ctrl(__globalDeviceManage.db, __globalDeviceManage._globalDevInfo.product.id, ALARM_TYPE_OPRATION, log_buff); } quit: cJSON_Delete(cjson); http_reply(conn, 200, ack_str); cJSON_free((void*)ack_str); } /// @brief 传感器状态请求应答 /// @param stream static void sensorStatusMonitoring(void* conn) { int ret = -1 ; cJSON *cjson; _OverSensorRequest _over_all_sensor_request; _OverSensorBackInfo _over_all_sensor_back_info; GlobalSensorManger _globalSensorMangerTemp ; GlobalSensorInfo _globalSensorInfo; char* ack_str = NULL ; mg_stream_t *s=(mg_stream_t*)conn; struct mg_http_message *hm=s->ev_data; char *rx_body_buf=(char*)hm->body.buf; //转换json参数 cjson = json_to_sensor_manage(rx_body_buf,&_over_all_sensor_request); if(cjson==NULL) { http_reply(conn, 400, NULL); return ; } //查询json参数 if(strcmp(_over_all_sensor_request.type,"listQuery")==0) { log_d("start listQuery handle."); #if(1) lock_s_hold(LOCK_ID_SENSOR); INIT_LIST_HEAD(&_over_all_sensor_back_info.list); //获取传感器当前的最新值 GlobalSensorManger* _globalSensorManagerTemp = NULL; list_for_each_entry(_globalSensorManagerTemp, &__globalDeviceManage._globalSensorManger.list, list) { _OverSensorBackInfo* _overSensorBackInfoTemp = (_OverSensorBackInfo*)malloc(sizeof(_OverSensorBackInfo)); if(_overSensorBackInfoTemp==NULL) log_e("_OverSensorBackInfo malloc error."); memset(_overSensorBackInfoTemp,0,sizeof(_OverSensorBackInfo)); //基本信息 _overSensorBackInfoTemp->sensorId = _globalSensorManagerTemp->sensor_id; strcpy(_overSensorBackInfoTemp->sensorName,_globalSensorManagerTemp->sensor_name); _overSensorBackInfoTemp->sensorType = _globalSensorManagerTemp->sensor_type; memcpy(&_overSensorBackInfoTemp->comSlogan,&_globalSensorManagerTemp->sensor_port_name,sizeof(_overSensorBackInfoTemp->comSlogan)); //485独有 _overSensorBackInfoTemp->connectionStatus = _globalSensorManagerTemp->sensor_status; _overSensorBackInfoTemp->nodeNumber = __globalDeviceManage._globalSensorManger.sensor_node_number; if(_globalSensorManagerTemp->sensor_interface_type==1) { _overSensorBackInfoTemp->sensorAddr = _globalSensorManagerTemp->sensor_addr ; _overSensorBackInfoTemp->sensorBaud = _globalSensorManagerTemp->sensor_baud; strcpy(_overSensorBackInfoTemp->sensorvaluech,"RS485"); } else { //_overSensorBackInfoTemp->connectionStatus = -1; strcpy(_overSensorBackInfoTemp->sensorvaluech,_overSensorBackInfoTemp->comSlogan); _overSensorBackInfoTemp->nodeNumber =_globalSensorManagerTemp->sensor_addr; } //拿数据 memset(&_globalSensorInfo, 0, sizeof(_globalSensorInfo)); switch(_globalSensorManagerTemp->sensor_type) { case SENSOR_TYPE_TEMP_HUMI://温湿度传感器 2个值 { _overSensorBackInfoTemp->temperatureValue = _globalSensorManagerTemp->Cur_sensor_info.val1; _overSensorBackInfoTemp->humidityValue =_globalSensorManagerTemp->Cur_sensor_info.val2; }break; case SENSOR_TYPE_SMOKE://烟雾传感器 1个值 { _overSensorBackInfoTemp->alarmStatus = ! (bool) _globalSensorManagerTemp->Cur_sensor_info.val1; // 1/0 报警未报警 }break; case SENSOR_TYPE_WATER://水浸传感器 1个值 c { _overSensorBackInfoTemp->waterImmersionState = !(bool)_globalSensorManagerTemp->Cur_sensor_info.val1; // 1/0 报警未报警 }break; case SENSOR_TYPE_ACCESS://门禁传感器 { _overSensorBackInfoTemp->accessControlStatus = !(bool)_globalSensorManagerTemp->Cur_sensor_info.val1; // 1/0 报警未报警 }break; case SENSOR_TYPE_GAS: //气体传感器 1个值 { _overSensorBackInfoTemp->gasConcentration = _globalSensorManagerTemp->Cur_sensor_info.val1; // 气体浓度 }break; case SENSOR_TYPE_AIR_PRESS://气压气流传感器 2个值 { _overSensorBackInfoTemp->airPressureValue = _globalSensorManagerTemp->Cur_sensor_info.val1; // 气压 _overSensorBackInfoTemp->airflowValue = _globalSensorManagerTemp->Cur_sensor_info.val2; // 气流 };break; case SENSOR_TYPE_AIR_COND://空调遥控器 没有值 { }break; case SENSOR_TYPE_TEMP_DOUBLE://双头温度传感器 2个值 { _overSensorBackInfoTemp->temperatureValue = _globalSensorManagerTemp->Cur_sensor_info.val1; _overSensorBackInfoTemp->temperatureValue2 =_globalSensorManagerTemp->Cur_sensor_info.val2; }break; case SENSOR_TYPE_TEMP: { _overSensorBackInfoTemp->temperatureValue = _globalSensorManagerTemp->Cur_sensor_info.val1; }break; case SENSOR_TYPE_LEAK: { _overSensorBackInfoTemp->temperatureValue = _globalSensorManagerTemp->Cur_sensor_info.val1; }break; } //入队 list_add_tail(&_overSensorBackInfoTemp->list,&_over_all_sensor_back_info.list); } lock_s_release(LOCK_ID_SENSOR); //参数转换json ack_str = over_all_sensor_info_to_json(&_over_all_sensor_back_info,0); //释放资源 _OverSensorBackInfo* node; _OverSensorBackInfo* next; list_for_each_entry_safe(node, next, &_over_all_sensor_back_info.list, list) { list_del(&node->list); free(node); } #endif } //删除传感器 else if(strcmp(_over_all_sensor_request.type,"delete")==0) { log_d("start delete handle."); int sensor_id_temp = _over_all_sensor_request.sensorId; if(dev_delete_sensor_manage(__globalDeviceManage.db, __globalDeviceManage._globalDevInfo.product.id,sensor_id_temp)!=0) { log_e("sensor delete failed."); } else { // 维护列表也需要删除 lock_s_hold(LOCK_ID_SENSOR); GlobalSensorManger *node; GlobalSensorManger *next; list_for_each_entry_safe(node, next, &__globalDeviceManage._globalSensorManger.list, list) { if (node->sensor_id == sensor_id_temp) { list_del(&node->list); free(node); break; } } lock_s_release(LOCK_ID_SENSOR); } char temp[100]; //sprintf(temp,"$删除$|$传感器$|%d",sensor_id_temp); sprintf(temp,"Delete sensor %d",sensor_id_temp); dev_insert_alarm_ctrl(__globalDeviceManage.db,__globalDeviceManage._globalDevInfo.product.id, ALARM_TYPE_OPRATION, temp); ack_str = ctrl_sts_ack_to_json(); } //更新传感器 else if(strcmp(_over_all_sensor_request.type,"update")==0) { log_d("start update handle."); int sensor_id_temp = _over_all_sensor_request.sensorId; GlobalSensorManger *node = NULL; GlobalSensorManger *next = NULL; list_for_each_entry_safe(node, next, &__globalDeviceManage._globalSensorManger.list, list) { if (node->sensor_id == sensor_id_temp) { break; } } if (node) { #if (1) GlobalSensorManger *_globalSensorMangerTemp = node; // 填充数据 _globalSensorMangerTemp->sensor_type = strtol(_over_all_sensor_request.sensorType, NULL, 10); if (_over_all_sensor_request.sensorName) { int nSize=strlen(_over_all_sensor_request.sensorName); if (nSize<=64) { strcpy(_globalSensorMangerTemp->sensor_name, _over_all_sensor_request.sensorName); } else{ //响应 //stream->errorMsg="Edit Name Too Long"; http_reply(conn, 500, ack_str); //释放资源 cJSON_free((void*)ack_str); return ; } } if(_over_all_sensor_request.cgqtd) { #ifdef IN_INDEX_MAP char index_map[4]=IN_INDEX_MAP; #else char index_map[4]={0,1,3,2}; #endif if (strcmp(_over_all_sensor_request.cgqtd, "RS485") == 0) { _globalSensorMangerTemp->sensor_interface_type = 1; if (_over_all_sensor_request.sensorAddr) { _globalSensorMangerTemp->sensor_addr = strtol(_over_all_sensor_request.sensorAddr,NULL,10); } //前端未传com口信息，暂且不改 //if (_over_all_sensor_request.comSlogan) // { // strcpy(_globalSensorMangerTemp->sensor_port_name, _over_all_sensor_request.comSlogan); // } } else if (strcmp(_over_all_sensor_request.cgqtd, "IN1") == 0) { _globalSensorMangerTemp->sensor_interface_type = 2; _globalSensorMangerTemp->sensor_addr = index_map[0]; strcpy(_globalSensorMangerTemp->sensor_port_name, _over_all_sensor_request.cgqtd); } else if (strcmp(_over_all_sensor_request.cgqtd, "IN2") == 0) { _globalSensorMangerTemp->sensor_interface_type = 2; _globalSensorMangerTemp->sensor_addr = index_map[1]; strcpy(_globalSensorMangerTemp->sensor_port_name, _over_all_sensor_request.cgqtd); } else if (strcmp(_over_all_sensor_request.cgqtd, "IN3") == 0) { _globalSensorMangerTemp->sensor_interface_type = 2; _globalSensorMangerTemp->sensor_addr = index_map[2]; strcpy(_globalSensorMangerTemp->sensor_port_name, _over_all_sensor_request.cgqtd); } else if (strcmp(_over_all_sensor_request.cgqtd, "IN4") == 0) { _globalSensorMangerTemp->sensor_interface_type = 2; _globalSensorMangerTemp->sensor_addr = index_map[3]; strcpy(_globalSensorMangerTemp->sensor_port_name, _over_all_sensor_request.cgqtd); } } //_globalSensorMangerTemp->sensor_baud = strtol(_over_all_sensor_request.sensorBaud, NULL, 10); //_globalSensorMangerTemp->sensor_addr = strtol(_over_all_sensor_request.sensorAddr, NULL, 10); //_globalSensorMangerTemp->sensor_status = 0; switch (_globalSensorMangerTemp->sensor_type) { case SENSOR_TYPE_TEMP_HUMI: _globalSensorMangerTemp->sensor_val_count = 2; break; // 温湿度传感器 2个值 case SENSOR_TYPE_SMOKE: _globalSensorMangerTemp->sensor_val_count = 1; break; // 烟雾传感器 1个值 case SENSOR_TYPE_WATER: _globalSensorMangerTemp->sensor_val_count = 1; break; // 水浸传感器 1个值 case SENSOR_TYPE_ACCESS: _globalSensorMangerTemp->sensor_val_count = 1; break; // 门禁传感器 没有值 case SENSOR_TYPE_GAS: _globalSensorMangerTemp->sensor_val_count = 1; break; // 气体传感器 1个值 case SENSOR_TYPE_AIR_PRESS: _globalSensorMangerTemp->sensor_val_count = 2; break; // 气压气流传感器 2个值 case SENSOR_TYPE_AIR_COND: _globalSensorMangerTemp->sensor_val_count = 0; break; // 空调遥控器 没有值 case SENSOR_TYPE_TEMP_DOUBLE: _globalSensorMangerTemp->sensor_val_count = 2; break; // 双头温度传感器 2个值 case SENSOR_TYPE_TEMP: _globalSensorMangerTemp->sensor_val_count = 1; break; // 双头温度传感器 1个值 case SENSOR_TYPE_LEAK: _globalSensorMangerTemp->sensor_val_count = 1; break; // 双头温度传感器 1个值 } // 插入数据库 if (dev_update_sensor_genera_manage(__globalDeviceManage.db, __globalDeviceManage._globalDevInfo.product.id, _globalSensorMangerTemp->sensor_id, _globalSensorMangerTemp) != 0) { log_e("dev update error."); } #endif } char temp[100]; // sprintf(temp,"$修改$|$传感器$|%d",sensor_id_temp); sprintf(temp,"Update sensor %d",sensor_id_temp); dev_insert_alarm_ctrl(__globalDeviceManage.db,__globalDeviceManage._globalDevInfo.product.id, ALARM_TYPE_OPRATION, temp); ack_str = ctrl_sts_ack_to_json(); } //添加传感器 else if(strcmp(_over_all_sensor_request.type,"add")==0) //正常跑过 { log_d("start add handle."); int r,wrong_param=0,new_flag=0; GlobalSensorManger* _globalSensorMangerTemp=NULL; #ifdef IN_INDEX_MAP char index_map[4]=IN_INDEX_MAP; #else char index_map[4]={0,1,3,2}; #endif int nmaxID=0; lock_s_hold(LOCK_ID_SENSOR); GlobalSensorManger *node; GlobalSensorManger *next; list_for_each_entry_safe(node, next, &__globalDeviceManage._globalSensorManger.list, list) { if (_over_all_sensor_request.cgqtd) { if (strcmp(_over_all_sensor_request.cgqtd, "RS485") == 0 && node->sensor_interface_type == 1) { if (strtol(_over_all_sensor_request.sensorAddr, NULL, 10) == node->sensor_addr) { _globalSensorMangerTemp = node; } } if (strcmp(_over_all_sensor_request.cgqtd, "IN1") == 0 && node->sensor_interface_type == 2) { if (index_map[0] == node->sensor_addr) { _globalSensorMangerTemp = node; } } if (strcmp(_over_all_sensor_request.cgqtd, "IN2") == 0 && node->sensor_interface_type == 2) { if (index_map[1] == node->sensor_addr) { _globalSensorMangerTemp = node; } } if (strcmp(_over_all_sensor_request.cgqtd, "IN3") == 0 && node->sensor_interface_type == 2) { if (index_map[2] == node->sensor_addr) { _globalSensorMangerTemp = node; } } if (strcmp(_over_all_sensor_request.cgqtd, "IN4") == 0 && node->sensor_interface_type == 2) { if (index_map[3] == node->sensor_addr) { _globalSensorMangerTemp = node; } } } if (node->sensor_id > nmaxID) { nmaxID = node->sensor_id; } } lock_s_release(LOCK_ID_SENSOR); if(_globalSensorMangerTemp==NULL) { _globalSensorMangerTemp = (GlobalSensorManger*)malloc(sizeof(GlobalSensorManger)); if(_globalSensorMangerTemp==NULL) { log_e("___ malloc failed\n"); return; } new_flag = 1; memset(_globalSensorMangerTemp, 0, sizeof(GlobalSensorManger)); _globalSensorMangerTemp->product_id = __globalDeviceManage._globalDevInfo.product.id ; _globalSensorMangerTemp->sensor_id = nmaxID+1; } strcpy( _globalSensorMangerTemp->sensor_name,_over_all_sensor_request.sensorName); if(_over_all_sensor_request.sensorType && strlen(_over_all_sensor_request.sensorType)) { _globalSensorMangerTemp->sensor_type = strtol(_over_all_sensor_request.sensorType,NULL,10); } else { wrong_param = 1; } if (_over_all_sensor_request.cgqtd) { if (strcmp(_over_all_sensor_request.cgqtd, "RS485") == 0) { _globalSensorMangerTemp->sensor_interface_type = 1; if (_over_all_sensor_request.sensorAddr) { _globalSensorMangerTemp->sensor_addr = strtol(_over_all_sensor_request.sensorAddr, NULL, 10); } // if (_over_all_sensor_request.sensorBaud && strlen(_over_all_sensor_request.sensorBaud)) // { _globalSensorMangerTemp->sensor_baud = 9600; // strtol(_over_all_sensor_request.sensorBaud,NULL,10);//默认9600 // } // 前端未传com口信息，暂且不改 // if (_over_all_sensor_request.comSlogan) // { strcpy(_globalSensorMangerTemp->sensor_port_name, "COM"); // } } else if (strcmp(_over_all_sensor_request.cgqtd, "IN1") == 0) { _globalSensorMangerTemp->sensor_interface_type = 2; _globalSensorMangerTemp->sensor_addr = index_map[0]; strcpy(_globalSensorMangerTemp->sensor_port_name, _over_all_sensor_request.cgqtd); _globalSensorMangerTemp->sensor_baud = 0; } else if (strcmp(_over_all_sensor_request.cgqtd, "IN2") == 0) { _globalSensorMangerTemp->sensor_interface_type = 2; _globalSensorMangerTemp->sensor_addr = index_map[1]; strcpy(_globalSensorMangerTemp->sensor_port_name, _over_all_sensor_request.cgqtd); _globalSensorMangerTemp->sensor_baud = 0; } else if (strcmp(_over_all_sensor_request.cgqtd, "IN3") == 0) { _globalSensorMangerTemp->sensor_interface_type = 2; _globalSensorMangerTemp->sensor_addr =index_map[2]; strcpy(_globalSensorMangerTemp->sensor_port_name, _over_all_sensor_request.cgqtd); _globalSensorMangerTemp->sensor_baud = 0; } else if (strcmp(_over_all_sensor_request.cgqtd, "IN4") == 0) { _globalSensorMangerTemp->sensor_interface_type = 2; _globalSensorMangerTemp->sensor_addr = index_map[3]; strcpy(_globalSensorMangerTemp->sensor_port_name, _over_all_sensor_request.cgqtd); _globalSensorMangerTemp->sensor_baud = 0; } } else { wrong_param = 1; } if(wrong_param) { cJSON_Delete(cjson); ack_str = ctrl_breaker_err_ack_to_json("Sensor parameter error!"); http_reply(conn, 200, ack_str); cJSON_free((void*)ack_str); return ; } _globalSensorMangerTemp->sensor_status = 0; switch( _globalSensorMangerTemp->sensor_type) { case SENSOR_TYPE_TEMP_HUMI: _globalSensorMangerTemp->sensor_val_count = 2 ;break; //温湿度传感器 2个值 case SENSOR_TYPE_SMOKE: _globalSensorMangerTemp->sensor_val_count = 1 ;break; //烟雾传感器 1个值 case SENSOR_TYPE_WATER: _globalSensorMangerTemp->sensor_val_count = 1 ;break; //水浸传感器 1个值 case SENSOR_TYPE_ACCESS: _globalSensorMangerTemp->sensor_val_count = 1 ;break; //门禁传感器 没有值 case SENSOR_TYPE_GAS: _globalSensorMangerTemp->sensor_val_count = 1 ;break; //气体传感器 1个值 case SENSOR_TYPE_AIR_PRESS: _globalSensorMangerTemp->sensor_val_count = 2 ;break; //气压气流传感器 2个值 case SENSOR_TYPE_AIR_COND: _globalSensorMangerTemp->sensor_val_count = 0 ;break; //空调遥控器 没有值 case SENSOR_TYPE_TEMP_DOUBLE: _globalSensorMangerTemp->sensor_val_count = 2 ;break; //双头温度传感器 2个值 case SENSOR_TYPE_TEMP: _globalSensorMangerTemp->sensor_val_count = 1 ;break; //温度传感器 1个值 case SENSOR_TYPE_LEAK: _globalSensorMangerTemp->sensor_val_count = 1 ;break; //双头温度传感器 1个值 default:break; } if(new_flag) { if(dev_insert_sensor_genera_manage(__globalDeviceManage.db,_globalSensorMangerTemp)!=0) { log_e("dev insert error."); } //全局接口体中也需要添加相关参数 lock_s_hold(LOCK_ID_SENSOR); list_add_tail(&_globalSensorMangerTemp->list,&__globalDeviceManage._globalSensorManger.list); lock_s_release(LOCK_ID_SENSOR); char temp[100]; //sprintf(temp,"$新增$|$传感器$|%d",_over_all_sensor_request.sensorId); sprintf(temp,"Add sensor %d",_over_all_sensor_request.sensorId); dev_insert_alarm_ctrl(__globalDeviceManage.db,__globalDeviceManage._globalDevInfo.product.id, ALARM_TYPE_OPRATION, temp); } else { r = dev_update_sensor_genera_manage(__globalDeviceManage.db, __globalDeviceManage._globalDevInfo.product.id, _globalSensorMangerTemp->sensor_id, _globalSensorMangerTemp); if(r) { log_e("dev_update_sensor_genera_manage error."); } } ack_str = ctrl_sts_ack_to_json(); } //烟雾报警复位 else if(strcmp(_over_all_sensor_request.type,"reset")==0) { ack_str = ctrl_sts_ack_to_json(); } //门禁释放 else if(strcmp(_over_all_sensor_request.type,"release")==0) { ack_str = ctrl_sts_ack_to_json(); } //打开空调开关 else if(strcmp(_over_all_sensor_request.type,"open")==0) { ack_str = ctrl_sts_ack_to_json(); } //关闭空调开关 else if(strcmp(_over_all_sensor_request.type,"close")==0) { ack_str = ctrl_sts_ack_to_json(); } #if(1) //历史信息 else if(strcmp(_over_all_sensor_request.type,"listHisQuery")==0) { int rsize = 0 ; int g_sensor_id = 0 ; int g_sensor_type = -1; GlobalSensorManger* _globalSensorMangerSTemp; int page_num = 0; int page_size = 60; char start_time[32] = {0}; char stop_time[32] = {0}; INIT_LIST_HEAD(&_over_all_sensor_back_info.list); if (_over_all_sensor_request.sensorType) { g_sensor_type = atoi(_over_all_sensor_request.sensorType); } if ( _over_all_sensor_request.startTime == NULL || _over_all_sensor_request.endTime == NULL) { struct tm *t; struct timeval tv; gettimeofday(&tv, NULL); t = localtime(&tv.tv_sec); sprintf(stop_time, "%04d-%02d-%02d %02d:%02d:%02d", t->tm_year + 1900, t->tm_mon + 1, t->tm_mday, 23, 59, 59); log_d(stop_time); sprintf(start_time, "%04d-%02d-%02d %02d:%02d:%02d", t->tm_year + 1900, t->tm_mon + 1, t->tm_mday, 0, 0, 0); log_d(start_time); } else { strncpy(start_time, _over_all_sensor_request.startTime , sizeof(start_time) ); strncpy(stop_time, _over_all_sensor_request.endTime , sizeof(stop_time) ); } // log_d("page_num:%d",page_num); // log_d("page_size:%d",page_size); lock_s_hold(LOCK_ID_SENSOR); // 查找管理表找到关联信息 list_for_each_entry(_globalSensorMangerSTemp, &__globalDeviceManage._globalSensorManger.list, list) { // ID相等 记录信息 if (_globalSensorMangerSTemp->sensor_type != g_sensor_type) { continue; } // 查询数据 GlobalSensorInfo SensorInfoList; INIT_LIST_HEAD(&SensorInfoList.list); ret = dev_search_sensor_info(__globalDeviceManage.db, __globalDeviceManage._globalDevInfo.product.id, _globalSensorMangerSTemp->sensor_id, start_time, stop_time, page_num, page_size, &rsize, &SensorInfoList); if (ret != 0) { log_e("get sensor history error."); continue; } _OverSensorBackInfo *_overSensorBackInfoTemp = (_OverSensorBackInfo *)malloc(sizeof(_OverSensorBackInfo)); if (_overSensorBackInfoTemp == NULL) log_e("_OverSensorBackInfo malloc error."); memset(_overSensorBackInfoTemp, 0, sizeof(_OverSensorBackInfo)); // 基本信息 _overSensorBackInfoTemp->sensorId = _globalSensorMangerSTemp->sensor_id; strcpy(_overSensorBackInfoTemp->sensorName,_globalSensorMangerSTemp->sensor_name); _overSensorBackInfoTemp->sensorType = _globalSensorMangerSTemp->sensor_type; strcpy(_overSensorBackInfoTemp->comSlogan, _globalSensorMangerSTemp->sensor_port_name); // 485独有 if (_globalSensorMangerSTemp->sensor_interface_type == 1) { _overSensorBackInfoTemp->sensorAddr = _globalSensorMangerSTemp->sensor_addr; _overSensorBackInfoTemp->sensorBaud = _globalSensorMangerSTemp->sensor_baud; } _overSensorBackInfoTemp->connectionStatus = _globalSensorMangerSTemp->sensor_status; _overSensorBackInfoTemp->nodeNumber = _globalSensorMangerSTemp->sensor_node_number; // 组返回数据 int _TempCount=0; GlobalSensorInfo* _globalSensorInfoTemp; list_for_each_entry(_globalSensorInfoTemp, &SensorInfoList.list, list) { if (_TempCount>=TOTAL_COUNT) { break; } // 判断sensor type 填充数据 switch (_globalSensorMangerSTemp->sensor_type) { case SENSOR_TYPE_TEMP_HUMI: // 温湿度传感器 2个值 { _overSensorBackInfoTemp->temp_humi_sensor.ydata[0][_TempCount] = _globalSensorInfoTemp->val1; _overSensorBackInfoTemp->temp_humi_sensor.ydata[1][_TempCount] = _globalSensorInfoTemp->val2; strcpy(_overSensorBackInfoTemp->temp_humi_sensor.xAxis[_TempCount], _globalSensorInfoTemp->samp_time); } break; case SENSOR_TYPE_SMOKE: // 烟雾传感器 1个值 { _overSensorBackInfoTemp->alarmStatus =! (bool)_globalSensorInfoTemp->val1; // 1/0 报警未报警 } break; case SENSOR_TYPE_WATER: // 水浸传感器 { _overSensorBackInfoTemp->waterImmersionState =! (bool)_globalSensorInfoTemp->val1; // 1/0 报警未报警 } break; case SENSOR_TYPE_ACCESS: // 门禁传感器 没有值 { _overSensorBackInfoTemp->accessControlStatus =! (bool)_globalSensorInfoTemp->val1; // 1/0 报警未报警 } break; case SENSOR_TYPE_GAS: // 气体传感器 1个值 { _overSensorBackInfoTemp->gas_sensor.ydata[_TempCount] = _globalSensorInfoTemp->val1; // 气体浓度 strcpy(_overSensorBackInfoTemp->gas_sensor.xAxis[_TempCount], _globalSensorInfoTemp->samp_time); } break; case SENSOR_TYPE_AIR_PRESS: { _overSensorBackInfoTemp->air_press_sensor.ydata[0][_TempCount] = _globalSensorInfoTemp->val1; _overSensorBackInfoTemp->air_press_sensor.ydata[1][_TempCount] = _globalSensorInfoTemp->val2; strcpy(_overSensorBackInfoTemp->air_press_sensor.xAxis[_TempCount], _globalSensorInfoTemp->samp_time); } break; case SENSOR_TYPE_AIR_COND: // 空调遥控器 没有值 { } break; case SENSOR_TYPE_TEMP_DOUBLE: // 温湿度传感器 2个值 { _overSensorBackInfoTemp->temp_humi_sensor.ydata[0][_TempCount] = _globalSensorInfoTemp->val1; _overSensorBackInfoTemp->temp_humi_sensor.ydata[1][_TempCount] = _globalSensorInfoTemp->val2; strcpy(_overSensorBackInfoTemp->temp_humi_sensor.xAxis[_TempCount], _globalSensorInfoTemp->samp_time); } break; case SENSOR_TYPE_TEMP: { _overSensorBackInfoTemp->temp_sensor.ydata[_TempCount] = _globalSensorInfoTemp->val1; strcpy(_overSensorBackInfoTemp->temp_sensor.xAxis[_TempCount], _globalSensorInfoTemp->samp_time); } break; case SENSOR_TYPE_LEAK: { _overSensorBackInfoTemp->leakStatus = !(bool)_globalSensorInfoTemp->val1; } break; } _TempCount++; } // 入队 list_add_tail(&_overSensorBackInfoTemp->list, &_over_all_sensor_back_info.list); // 释放资源 GlobalSensorInfo *node; GlobalSensorInfo *next; list_for_each_entry_safe(node, next, &SensorInfoList.list, list) { list_del(&node->list); free(node); } } lock_s_release(LOCK_ID_SENSOR); if(strcmp(_over_all_sensor_request.sensorType,"0")==0 || strcmp(_over_all_sensor_request.sensorType,"4")==0 || strcmp(_over_all_sensor_request.sensorType,"5")==0 || strcmp(_over_all_sensor_request.sensorType,"7")==0 || strcmp(_over_all_sensor_request.sensorType,"8")==0) { ack_str = over_sensor_history_info_to_json(&_over_all_sensor_back_info, SENSOR_TYPE_VALUE); } else if(strcmp(_over_all_sensor_request.sensorType,"1")==0 || strcmp(_over_all_sensor_request.sensorType,"2")==0 || strcmp(_over_all_sensor_request.sensorType,"3")==0 || strcmp(_over_all_sensor_request.sensorType,"6")==0 || strcmp(_over_all_sensor_request.sensorType,"9")==0) { ack_str = over_sensor_history_info_to_json(&_over_all_sensor_back_info, SENSOR_TYPE_LIST); } else ack_str = ctrl_sts_ack_to_json(); // //参数转换json // ack_str = over_all_sensor_info_to_json(&_over_all_sensor_back_info); // 释放资源 _OverSensorBackInfo *node; _OverSensorBackInfo *next; list_for_each_entry_safe(node, next, &_over_all_sensor_back_info.list, list) { list_del(&node->list); free(node); } } #endif cJSON_Delete(cjson); http_reply(conn, 200, ack_str); cJSON_free((void*)ack_str); } /** * @brief 设置通道报警阈值 * * 根据给定的通道ID，设置报警请求的通道阈值。 * * @param _alarm_request_info 报警请求信息指针 * @param nChID 通道ID * * @return 指向设置后的通道阈值字符串的指针 */ char* setThresholdToCh(_AlarmRequestInfo* _alarm_request_info,int nChID) { int ret = -1 ; char *ack_str = NULL; GlobalPowerManger *_globalPowerMangerSaveTemp; // int g_pwr_ch_id = atoi(_alarm_request_info->_pwr_info.productChId); int g_pwr_ch_id = nChID; if (g_pwr_ch_id == 0) { _globalPowerMangerSaveTemp = &__globalDeviceManage._globalPowerManger; } else { list_for_each_entry(_globalPowerMangerSaveTemp, &__globalDeviceManage._globalPowerManger.list, list) { // ID相等 记录信息 if (_globalPowerMangerSaveTemp->product_ch_id == nChID) { break; } } } // 更新参数，使能全部放在控制板上判断，表头不做判断，统一发1 if (_alarm_request_info->_pwr_info.voltageUpperValue) { _globalPowerMangerSaveTemp->global_over_manager.product_vol_upper_threshold = atof(_alarm_request_info->_pwr_info.voltageUpperValue); } _globalPowerMangerSaveTemp->global_over_manager.product_vol_upper_enable = 1; /*if (_globalPowerMangerSaveTemp->global_over_manager.product_vol_upper_threshold != 0) { _globalPowerMangerSaveTemp->global_over_manager.product_vol_upper_enable = 1; } else { _globalPowerMangerSaveTemp->global_over_manager.product_vol_upper_enable = 0; }*/ if (_alarm_request_info->_pwr_info.voltageDownValue) { _globalPowerMangerSaveTemp->global_over_manager.product_vol_lower_threshold = atof(_alarm_request_info->_pwr_info.voltageDownValue); } _globalPowerMangerSaveTemp->global_over_manager.product_vol_lower_enable = 1; /*if (_globalPowerMangerSaveTemp->global_over_manager.product_vol_lower_threshold != 0) { _globalPowerMangerSaveTemp->global_over_manager.product_vol_lower_enable = 1; } else { _globalPowerMangerSaveTemp->global_over_manager.product_vol_lower_enable = 0; }*/ if (_alarm_request_info->_pwr_info.currentUpperValue) { _globalPowerMangerSaveTemp->global_over_manager.product_cur_upper_threshold = atof(_alarm_request_info->_pwr_info.currentUpperValue); } _globalPowerMangerSaveTemp->global_over_manager.product_cur_upper_enable = 1; /*if (_globalPowerMangerSaveTemp->global_over_manager.product_cur_upper_threshold != 0) { _globalPowerMangerSaveTemp->global_over_manager.product_cur_upper_enable = 1; } else { _globalPowerMangerSaveTemp->global_over_manager.product_cur_upper_enable = 0; }*/ if (_alarm_request_info->_pwr_info.powerUpperValue) { _globalPowerMangerSaveTemp->global_over_manager.product_pwr_upper_threshold = atof(_alarm_request_info->_pwr_info.powerUpperValue); } _globalPowerMangerSaveTemp->global_over_manager.product_pwr_upper_enable = 1; /*if (_globalPowerMangerSaveTemp->global_over_manager.product_pwr_upper_threshold != 0) { _globalPowerMangerSaveTemp->global_over_manager.product_pwr_upper_enable = 1; } else { _globalPowerMangerSaveTemp->global_over_manager.product_pwr_upper_enable = 0; }*/ if (_alarm_request_info->_pwr_info.alarmContentUpperValue) { _globalPowerMangerSaveTemp->global_over_manager.product_pwrcon_upper_threshold = atof(_alarm_request_info->_pwr_info.alarmContentUpperValue); } _globalPowerMangerSaveTemp->global_over_manager.product_pwrcon_upper_enable = 1; /* if (_globalPowerMangerSaveTemp->global_over_manager.product_pwrcon_upper_threshold != 0) { _globalPowerMangerSaveTemp->global_over_manager.product_pwrcon_upper_enable = 1; } else { _globalPowerMangerSaveTemp->global_over_manager.product_pwrcon_upper_enable = 0; }*/ //_globalPowerMangerSaveTemp->global_over_manager.product_pwrcon_upper_enable = 1 ; char Alarm_Ctrl_type[16]; memset(Alarm_Ctrl_type, 0, sizeof(Alarm_Ctrl_type)); sprintf(Alarm_Ctrl_type, "%d", ALARM_CTRL_CLOSE_CH); if (_alarm_request_info->_pwr_info.currentUpperAction && strcmp(_alarm_request_info->_pwr_info.currentUpperAction, Alarm_Ctrl_type) == 0) { _globalPowerMangerSaveTemp->global_over_manager.product_cur_over_upper_threshold_ctrl = ALARM_CTRL_CLOSE_CH; } else _globalPowerMangerSaveTemp->global_over_manager.product_cur_over_upper_threshold_ctrl = ALARM_CTRL_ALARM_ONLY; if (_alarm_request_info->_pwr_info.voltageUpperAction && strcmp(_alarm_request_info->_pwr_info.voltageUpperAction, Alarm_Ctrl_type) == 0) { _globalPowerMangerSaveTemp->global_over_manager.product_vol_over_upper_threshold_ctrl = ALARM_CTRL_CLOSE_CH; } else _globalPowerMangerSaveTemp->global_over_manager.product_vol_over_upper_threshold_ctrl = ALARM_CTRL_ALARM_ONLY; if (_alarm_request_info->_pwr_info.voltageDownAction && strcmp(_alarm_request_info->_pwr_info.voltageDownAction, Alarm_Ctrl_type) == 0) { _globalPowerMangerSaveTemp->global_over_manager.product_vol_over_lower_threshold_ctrl = ALARM_CTRL_CLOSE_CH; } else _globalPowerMangerSaveTemp->global_over_manager.product_vol_over_lower_threshold_ctrl = ALARM_CTRL_ALARM_ONLY; if (_alarm_request_info->_pwr_info.powerUpperAction && strcmp(_alarm_request_info->_pwr_info.powerUpperAction, Alarm_Ctrl_type) == 0) { _globalPowerMangerSaveTemp->global_over_manager.product_pwr_over_upper_threshold_ctrl = ALARM_CTRL_CLOSE_CH; } else _globalPowerMangerSaveTemp->global_over_manager.product_pwr_over_upper_threshold_ctrl = ALARM_CTRL_ALARM_ONLY; if (_alarm_request_info->_pwr_info.alarmContentUpperAction && strcmp(_alarm_request_info->_pwr_info.alarmContentUpperAction, Alarm_Ctrl_type) == 0) { _globalPowerMangerSaveTemp->global_over_manager.product_pwrcon_over_upper_threshold_ctrl = ALARM_CTRL_CLOSE_CH; } else _globalPowerMangerSaveTemp->global_over_manager.product_pwrcon_over_upper_threshold_ctrl = ALARM_CTRL_ALARM_ONLY; if (__globalDeviceManage._globalDevInfo.product.pwr_type == SmartPDU_Tree_AC_Tree || __globalDeviceManage._globalDevInfo.product.pwr_type == SmartPDU_Tree_AC_One) { GlobalTreeACManager *_pTreeACPowerMangerTemp = NULL; list_for_each_entry(_pTreeACPowerMangerTemp, &_globalPowerMangerSaveTemp->list_Tree_AC, list_Tree_AC) { _pTreeACPowerMangerTemp->global_over_manager = _globalPowerMangerSaveTemp->global_over_manager; ret = g_switch_set_all_single_threshold(&__globalDeviceManage._globalRelaySampManger, _globalPowerMangerSaveTemp->product_ch_type, _pTreeACPowerMangerTemp->product_saddr, _pTreeACPowerMangerTemp->product_ch_addr, _globalPowerMangerSaveTemp, 1); } } else { ret = g_switch_set_all_single_threshold(&__globalDeviceManage._globalRelaySampManger, _globalPowerMangerSaveTemp->product_ch_type, _globalPowerMangerSaveTemp->product_saddr, _globalPowerMangerSaveTemp->product_ch_addr, _globalPowerMangerSaveTemp, 1); } if (ret < 0) { log_e("power threshold update error.ret:%d,%s", ret, modbus_strerror(errno)); /* code */ } if (__globalDeviceManage._globalDevInfo.product.pwr_type == SmartPDU_Tree_AC_Tree || __globalDeviceManage._globalDevInfo.product.pwr_type == SmartPDU_Tree_AC_One) { // 写入数据库 ret = dev_update_power_manage_over_info(__globalDeviceManage.db, __globalDeviceManage._globalDevInfo.product.id, _globalPowerMangerSaveTemp->product_ch_id, _globalPowerMangerSaveTemp); if (ret != 0) log_e("power threshold update error."); GlobalTreeACManager *_pTreeACPowerMangerTemp = NULL; list_for_each_entry(_pTreeACPowerMangerTemp, &_globalPowerMangerSaveTemp->list_Tree_AC, list_Tree_AC) { _pTreeACPowerMangerTemp->global_over_manager = _globalPowerMangerSaveTemp->global_over_manager; ret = dev_update_t_ac_power_manage_over_info(__globalDeviceManage.db, _pTreeACPowerMangerTemp); } } else { // 写入数据库 ret = dev_update_power_manage_over_info(__globalDeviceManage.db, __globalDeviceManage._globalDevInfo.product.id, _globalPowerMangerSaveTemp->product_ch_id, _globalPowerMangerSaveTemp); if (ret != 0) log_e("power threshold update error."); } // 返回数据 ack_str = ctrl_sts_ack_to_json(); return ack_str; } /// @brief 告警保护 /// @param stream static void alarmProtect(void *conn) { int ret = -1 ; cJSON *cjson; _AlarmRequestInfo _alarm_request_info; _AlarmAckInfo _alarm_ack_info; //填充数据 char* ack_str = NULL ; int nAlarmNumber=0; mg_stream_t *s=(mg_stream_t*)conn; struct mg_http_message *hm=s->ev_data; char *rx_body_buf=(char*)hm->body.buf; memset(&_alarm_request_info, 0, sizeof(_alarm_request_info)); //转换json参数 cjson = json_to_alarm_manage(rx_body_buf,&_alarm_request_info); if(cjson==NULL) { http_reply(conn, 400, NULL); return ; } //查询json参数 if(strcmp(_alarm_request_info.type,"listAllQuery")==0) //告警信息查询 { int i = 0 ; //初始化表 INIT_LIST_HEAD(&_alarm_ack_info.list); //查询数据库，最近的10个报警信息 char start_time[32] = {0}; char stop_time[32] = {0}; if (_alarm_request_info.startTime == NULL || _alarm_request_info.endTime == NULL) { struct tm *t; struct timeval tv; gettimeofday(&tv, NULL); t = localtime(&tv.tv_sec); sprintf(stop_time, "%04d-%02d-%02d %02d:%02d:%02d", t->tm_year + 1900, t->tm_mon + 1, t->tm_mday, 23, 59, 59); log_d(stop_time); sprintf(start_time, "%04d-%02d-%02d %02d:%02d:%02d", t->tm_year + 1900, t->tm_mon + 1, t->tm_mday, 0, 0, 0); log_d(start_time); _alarm_request_info.startTime = start_time; _alarm_request_info.endTime = stop_time; } ret = dev_search_alarm_info(__globalDeviceManage.db, __globalDeviceManage._globalDevInfo.product.id, -1,_alarm_request_info.startTime,_alarm_request_info.endTime, 1,10, &_alarm_ack_info,&nAlarmNumber); if(ret!=0) { log_e("get power alarm error."); } else { ack_str = alarm_info_to_json(&_alarm_ack_info,nAlarmNumber); //释放资源 _AlarmAckInfo* node; _AlarmAckInfo* next; list_for_each_entry_safe(node, next, &_alarm_ack_info.list, list) { list_del(&node->list); free(node); } } } else if(strcmp(_alarm_request_info.type,"powerAlarmList")==0) //电源告警信息查询 { //初始化表 INIT_LIST_HEAD(&_alarm_ack_info.list); //查询数据库 ret = dev_search_alarm_info(__globalDeviceManage.db, __globalDeviceManage._globalDevInfo.product.id, ALARM_TYPE_POWER,_alarm_request_info.startTime,_alarm_request_info.endTime, _alarm_request_info.pagenum,_alarm_request_info.pagesize, &_alarm_ack_info,&nAlarmNumber); if(ret!=0) { log_e("get power alarm error."); } else { ack_str = alarm_info_to_json(&_alarm_ack_info,nAlarmNumber); //释放资源 _AlarmAckInfo* node; _AlarmAckInfo* next; list_for_each_entry_safe(node, next, &_alarm_ack_info.list, list) { list_del(&node->list); free(node); } } } else if(strcmp(_alarm_request_info.type,"sensorAlarmList")==0) //传感器告警信息查询 { //初始化表 INIT_LIST_HEAD(&_alarm_ack_info.list); //查询数据库 ret = dev_search_alarm_info(__globalDeviceManage.db, __globalDeviceManage._globalDevInfo.product.id, ALARM_TYPE_SENSOR,_alarm_request_info.startTime,_alarm_request_info.endTime, _alarm_request_info.pagenum,_alarm_request_info.pagesize, &_alarm_ack_info,&nAlarmNumber); if(ret!=0) { log_e("get sensor alarm error."); } else { ack_str = alarm_info_to_json(&_alarm_ack_info,nAlarmNumber); //释放资源 _AlarmAckInfo* node; _AlarmAckInfo* next; list_for_each_entry_safe(node, next, &_alarm_ack_info.list, list) { list_del(&node->list); free(node); } } } else if(strcmp(_alarm_request_info.type,"networAlarmkList")==0) //网络告警信息查询 { //初始化表 INIT_LIST_HEAD(&_alarm_ack_info.list); ret = dev_search_alarm_info(__globalDeviceManage.db, __globalDeviceManage._globalDevInfo.product.id, ALARM_TYPE_NETWORK,_alarm_request_info.startTime,_alarm_request_info.endTime, _alarm_request_info.pagenum,_alarm_request_info.pagesize, &_alarm_ack_info,&nAlarmNumber); if(ret!=0) { log_e("get net alarm error."); } else { //转换参数 ack_str = alarm_info_to_json(&_alarm_ack_info,nAlarmNumber); //释放资源 _AlarmAckInfo* node; _AlarmAckInfo* next; list_for_each_entry_safe(node, next, &_alarm_ack_info.list, list) { list_del(&node->list); free(node); } } } else if(strcmp(_alarm_request_info.type,"powerThresholdList")==0)//电源阈值查询 { //查询每个通道阈值 ack_str = alarm_power_threshold_to_json(&__globalDeviceManage._globalPowerManger); } else if(strcmp(_alarm_request_info.type,"save")==0)//电源阈值保存 { if (!_alarm_request_info.user_token) { return; } //拿到参数保存 //GlobalPowerManger* _globalPowerMangerSaveTemp ; // int g_pwr_ch_id = atoi(_alarm_request_info._pwr_info.productChId); int g_pwr_ch_id = _alarm_request_info._pwr_info.productChId; ack_str=setThresholdToCh(&_alarm_request_info,g_pwr_ch_id); char log_buff[256]; if (0==g_pwr_ch_id) { sprintf(log_buff, "Update power threshold ALL_CH!"); } else sprintf(log_buff, "Update power threshold CH%d!",g_pwr_ch_id); dev_insert_alarm_ctrl(__globalDeviceManage.db, __globalDeviceManage._globalDevInfo.product.id, ALARM_TYPE_OPRATION, log_buff); /* if (g_pwr_ch_id ==0) { _globalPowerMangerSaveTemp=&__globalDeviceManage._globalPowerManger; } else { list_for_each_entry(_globalPowerMangerSaveTemp, &__globalDeviceManage._globalPowerManger.list, list) { // ID相等 记录信息 if (_globalPowerMangerSaveTemp->product_ch_id == g_pwr_ch_id) { break; } } } //更新参数 if (_alarm_request_info._pwr_info.voltageUpperValue) { _globalPowerMangerSaveTemp->global_over_manager.product_vol_upper_threshold =atof(_alarm_request_info._pwr_info.voltageUpperValue); } if (_globalPowerMangerSaveTemp->global_over_manager.product_vol_upper_threshold!=0){_globalPowerMangerSaveTemp->global_over_manager.product_vol_upper_enable = 1 ; }else{_globalPowerMangerSaveTemp->global_over_manager.product_vol_upper_enable = 0;} if (_alarm_request_info._pwr_info.voltageDownValue) { _globalPowerMangerSaveTemp->global_over_manager.product_vol_lower_threshold =atof(_alarm_request_info._pwr_info.voltageDownValue); } if (_globalPowerMangerSaveTemp->global_over_manager.product_vol_lower_threshold!=0){_globalPowerMangerSaveTemp->global_over_manager.product_vol_lower_enable = 1 ; }else{_globalPowerMangerSaveTemp->global_over_manager.product_vol_lower_enable = 0 ;} if (_alarm_request_info._pwr_info.currentUpperValue) { _globalPowerMangerSaveTemp->global_over_manager.product_cur_upper_threshold = atof(_alarm_request_info._pwr_info.currentUpperValue); } if (_globalPowerMangerSaveTemp->global_over_manager.product_cur_upper_threshold!=0){_globalPowerMangerSaveTemp->global_over_manager.product_cur_upper_enable = 1 ; }else{_globalPowerMangerSaveTemp->global_over_manager.product_cur_upper_enable = 0 ;} if (_alarm_request_info._pwr_info.powerUpperValue) { _globalPowerMangerSaveTemp->global_over_manager.product_pwr_upper_threshold = atof(_alarm_request_info._pwr_info.powerUpperValue); } if (_globalPowerMangerSaveTemp->global_over_manager.product_pwr_upper_threshold!=0){_globalPowerMangerSaveTemp->global_over_manager.product_pwr_upper_enable = 1 ; }else{_globalPowerMangerSaveTemp->global_over_manager.product_pwr_upper_enable = 0 ;} if (_alarm_request_info._pwr_info.alarmContentUpperValue) { _globalPowerMangerSaveTemp->global_over_manager.product_pwrcon_upper_threshold = atof(_alarm_request_info._pwr_info.alarmContentUpperValue); } if (_globalPowerMangerSaveTemp->global_over_manager.product_pwrcon_upper_threshold!=0){_globalPowerMangerSaveTemp->global_over_manager.product_pwrcon_upper_enable = 1 ; }else{_globalPowerMangerSaveTemp->global_over_manager.product_pwrcon_upper_enable = 0 ;} //_globalPowerMangerSaveTemp->global_over_manager.product_pwrcon_upper_enable = 1 ; char Alarm_Ctrl_type[16]; memset(Alarm_Ctrl_type, 0, sizeof(Alarm_Ctrl_type)); sprintf(Alarm_Ctrl_type, "%d", ALARM_CTRL_CLOSE_CH); if (_alarm_request_info._pwr_info.currentUpperAction && strcmp(_alarm_request_info._pwr_info.currentUpperAction,Alarm_Ctrl_type) == 0) { _globalPowerMangerSaveTemp->global_over_manager.product_cur_over_upper_threshold_ctrl = ALARM_CTRL_CLOSE_CH; } else _globalPowerMangerSaveTemp->global_over_manager.product_cur_over_upper_threshold_ctrl = ALARM_CTRL_ALARM_ONLY; if (_alarm_request_info._pwr_info.voltageUpperAction && strcmp(_alarm_request_info._pwr_info.voltageUpperAction, Alarm_Ctrl_type) == 0) { _globalPowerMangerSaveTemp->global_over_manager.product_vol_over_upper_threshold_ctrl = ALARM_CTRL_CLOSE_CH; } else _globalPowerMangerSaveTemp->global_over_manager.product_vol_over_upper_threshold_ctrl = ALARM_CTRL_ALARM_ONLY; if (_alarm_request_info._pwr_info.voltageDownAction && strcmp(_alarm_request_info._pwr_info.voltageDownAction, Alarm_Ctrl_type) == 0) { _globalPowerMangerSaveTemp->global_over_manager.product_vol_over_lower_threshold_ctrl = ALARM_CTRL_CLOSE_CH; } else _globalPowerMangerSaveTemp->global_over_manager.product_vol_over_lower_threshold_ctrl = ALARM_CTRL_ALARM_ONLY; if (_alarm_request_info._pwr_info.powerUpperAction && strcmp(_alarm_request_info._pwr_info.powerUpperAction, Alarm_Ctrl_type) == 0) { _globalPowerMangerSaveTemp->global_over_manager.product_pwr_over_upper_threshold_ctrl = ALARM_CTRL_CLOSE_CH; } else _globalPowerMangerSaveTemp->global_over_manager.product_pwr_over_upper_threshold_ctrl = ALARM_CTRL_ALARM_ONLY; if (_alarm_request_info._pwr_info.alarmContentUpperAction && strcmp(_alarm_request_info._pwr_info.alarmContentUpperAction, Alarm_Ctrl_type) == 0) { _globalPowerMangerSaveTemp->global_over_manager.product_pwrcon_over_upper_threshold_ctrl = ALARM_CTRL_CLOSE_CH; } else _globalPowerMangerSaveTemp->global_over_manager.product_pwrcon_over_upper_threshold_ctrl = ALARM_CTRL_ALARM_ONLY; if (__globalDeviceManage._globalDevInfo.product.pwr_type == SmartPDU_Tree_AC_Tree || __globalDeviceManage._globalDevInfo.product.pwr_type == SmartPDU_Tree_AC_One) { GlobalTreeACManager* _pTreeACPowerMangerTemp = NULL ; list_for_each_entry(_pTreeACPowerMangerTemp, &_globalPowerMangerSaveTemp->list_Tree_AC, list_Tree_AC) { memcpy(_pTreeACPowerMangerTemp->global_over_manager,_globalPowerMangerSaveTemp->global_over_manager,sizeof(GlobalOverManager)); ret = g_switch_set_all_single_threshold(&__globalDeviceManage._globalRelaySampManger, _globalPowerMangerSaveTemp->product_ch_type, _pTreeACPowerMangerTemp->product_saddr, _pTreeACPowerMangerTemp->product_ch_addr, _globalPowerMangerSaveTemp, 1); } } else { ret = g_switch_set_all_single_threshold(&__globalDeviceManage._globalRelaySampManger, _globalPowerMangerSaveTemp->product_ch_type, _globalPowerMangerSaveTemp->product_saddr, _globalPowerMangerSaveTemp->product_ch_addr, _globalPowerMangerSaveTemp, 0); } if (ret<0) { log_e("power threshold update error.ret:%d,%s",ret,modbus_strerror(errno)); } if (__globalDeviceManage._globalDevInfo.product.pwr_type == SmartPDU_Tree_AC_Tree || __globalDeviceManage._globalDevInfo.product.pwr_type == SmartPDU_Tree_AC_One) { // 写入数据库 ret = dev_update_power_manage_over_info(__globalDeviceManage.db, __globalDeviceManage._globalDevInfo.product.id, _globalPowerMangerSaveTemp->product_ch_id, _globalPowerMangerSaveTemp); if (ret != 0) log_e("power threshold update error."); GlobalTreeACManager *_pTreeACPowerMangerTemp = NULL; list_for_each_entry(_pTreeACPowerMangerTemp, &_globalPowerMangerSaveTemp->list_Tree_AC, list_Tree_AC) { memcpy(_pTreeACPowerMangerTemp->global_over_manager, _globalPowerMangerSaveTemp->global_over_manager, sizeof(GlobalOverManager)); ret = dev_update_t_ac_power_manage_over_info(__globalDeviceManage.db,_pTreeACPowerMangerTemp); } } else { // 写入数据库 ret = dev_update_power_manage_over_info(__globalDeviceManage.db, __globalDeviceManage._globalDevInfo.product.id, _globalPowerMangerSaveTemp->product_ch_id, _globalPowerMangerSaveTemp); if (ret != 0) log_e("power threshold update error."); } //返回数据 ack_str = ctrl_sts_ack_to_json();*/ } else if (strcmp(_alarm_request_info.type, "batchSave") == 0) // 批量设置 { if (!_alarm_request_info.user_token) { return; } char *pCHlist; char *pCHListSave; pCHlist = strtok_r(_alarm_request_info.strProductChIds, ",", &pCHListSave); // 其他版本功能 while (pCHlist != NULL) { int g_pwr_ch_id = atoi(pCHlist); ack_str = setThresholdToCh(&_alarm_request_info, g_pwr_ch_id); pCHlist = strtok_r(NULL, ",", &pCHListSave); //usleep(30000);//延时30ms，等待控制板串口写完 } char log_buff[256]; sprintf(log_buff, "Batch setting power threshold!"); dev_insert_alarm_ctrl(__globalDeviceManage.db, __globalDeviceManage._globalDevInfo.product.id, ALARM_TYPE_OPRATION, log_buff); } else if(strcmp(_alarm_request_info.type,"sensorThresholdList")==0)//传感器阈值查询 { ack_str = alarm_sensor_threshold_to_json(&__globalDeviceManage._globalSensorManger); } else if(strcmp(_alarm_request_info.type,"update")==0)//传感器阈值保存 { GlobalSensorManger* _globalSensorMangerSaveTemp; int g_sensor_id = _alarm_request_info._sensor_info.sensorId; list_for_each_entry(_globalSensorMangerSaveTemp, &__globalDeviceManage._globalSensorManger.list, list) { //ID相等 记录信息 if(_globalSensorMangerSaveTemp->sensor_id== g_sensor_id) { break; } } char Alarm_Ctrl_type[16]; memset(Alarm_Ctrl_type, 0, sizeof(Alarm_Ctrl_type)); sprintf(Alarm_Ctrl_type, "%d", ALARM_CTRL_CLOSE_CH); switch (_globalSensorMangerSaveTemp->sensor_type) { case SENSOR_TYPE_TEMP_HUMI: case SENSOR_TYPE_TEMP_DOUBLE: case SENSOR_TYPE_TEMP: { char strName1[100]={0}; char strName2[100]={0}; sprintf(strName1, "%s%d", language_temperature[__globalDeviceManage._globalDevInfo.product.language], 1); sprintf(strName2, "%s%d", language_temperature[__globalDeviceManage._globalDevInfo.product.language], 2); if (strcmp(_alarm_request_info._sensor_info.thresholdType, language_temperature[__globalDeviceManage._globalDevInfo.product.language]) == 0||strcmp(_alarm_request_info._sensor_info.thresholdType, strName1) == 0) { _globalSensorMangerSaveTemp->over_manager.sensor_val1_upper_threshold = atof(_alarm_request_info._sensor_info.thresholdUpperValue); _globalSensorMangerSaveTemp->over_manager.sensor_val1_lower_threshold = atof(_alarm_request_info._sensor_info.thresholdDownValue); if (_globalSensorMangerSaveTemp->over_manager.sensor_val1_upper_threshold<=0.05 &&_globalSensorMangerSaveTemp->over_manager.sensor_val1_upper_threshold>=-0.05 ) { _globalSensorMangerSaveTemp->over_manager.sensor_val1_upper_enabled = 0; } else _globalSensorMangerSaveTemp->over_manager.sensor_val1_upper_enabled = 1; if (_globalSensorMangerSaveTemp->over_manager.sensor_val1_lower_threshold<=0.05 &&_globalSensorMangerSaveTemp->over_manager.sensor_val1_lower_threshold>=-0.05 ) { _globalSensorMangerSaveTemp->over_manager.sensor_val1_lower_enabled = 0; } else _globalSensorMangerSaveTemp->over_manager.sensor_val1_lower_enabled =1; if (_alarm_request_info._sensor_info.thresholdUpperAction && strcmp(_alarm_request_info._sensor_info.thresholdUpperAction,Alarm_Ctrl_type) == 0) { _globalSensorMangerSaveTemp->over_manager.sensor_val1_upper_threshold_ctrl = ALARM_CTRL_CLOSE_CH; if(_alarm_request_info._sensor_info.thresholdUpperChanel)strcpy(_globalSensorMangerSaveTemp->over_manager.sensor_val1_upper_threshold_ctrl_para,_alarm_request_info._sensor_info.thresholdUpperChanel); } else _globalSensorMangerSaveTemp->over_manager.sensor_val1_upper_threshold_ctrl = ALARM_CTRL_ALARM_ONLY; if (_alarm_request_info._sensor_info.thresholdDownAction && strcmp(_alarm_request_info._sensor_info.thresholdDownAction, Alarm_Ctrl_type) == 0) { _globalSensorMangerSaveTemp->over_manager.sensor_val1_lower_threshold_ctrl = ALARM_CTRL_CLOSE_CH; if(_alarm_request_info._sensor_info.thresholdDownChanel)strcpy(_globalSensorMangerSaveTemp->over_manager.sensor_val1_lower_threshold_ctrl_para,_alarm_request_info._sensor_info.thresholdDownChanel); } else _globalSensorMangerSaveTemp->over_manager.sensor_val1_lower_threshold_ctrl = ALARM_CTRL_ALARM_ONLY; } else if (strcmp(_alarm_request_info._sensor_info.thresholdType, language_humidity[__globalDeviceManage._globalDevInfo.product.language]) == 0||strcmp(_alarm_request_info._sensor_info.thresholdType, strName2) == 0) { _globalSensorMangerSaveTemp->over_manager.sensor_val2_upper_threshold = atof(_alarm_request_info._sensor_info.thresholdUpperValue); _globalSensorMangerSaveTemp->over_manager.sensor_val2_lower_threshold = atof(_alarm_request_info._sensor_info.thresholdDownValue); if (_globalSensorMangerSaveTemp->over_manager.sensor_val2_upper_threshold<=0.05 &&_globalSensorMangerSaveTemp->over_manager.sensor_val2_upper_threshold>=-0.05 ) { _globalSensorMangerSaveTemp->over_manager.sensor_val2_upper_enabled = 0; } else _globalSensorMangerSaveTemp->over_manager.sensor_val2_upper_enabled = 1; if (_globalSensorMangerSaveTemp->over_manager.sensor_val2_lower_threshold<=0.05 &&_globalSensorMangerSaveTemp->over_manager.sensor_val2_lower_threshold>=-0.05 ) { _globalSensorMangerSaveTemp->over_manager.sensor_val2_lower_enabled = 0; } else _globalSensorMangerSaveTemp->over_manager.sensor_val2_lower_enabled = 1; if (_alarm_request_info._sensor_info.thresholdUpperAction && strcmp(_alarm_request_info._sensor_info.thresholdUpperAction, Alarm_Ctrl_type) == 0) { _globalSensorMangerSaveTemp->over_manager.sensor_val2_upper_threshold_ctrl = ALARM_CTRL_CLOSE_CH; if(_alarm_request_info._sensor_info.thresholdUpperChanel)strcpy(_globalSensorMangerSaveTemp->over_manager.sensor_val2_upper_threshold_ctrl_para,_alarm_request_info._sensor_info.thresholdUpperChanel); } else _globalSensorMangerSaveTemp->over_manager.sensor_val2_upper_threshold_ctrl = ALARM_CTRL_ALARM_ONLY; if (_alarm_request_info._sensor_info.thresholdDownAction && strcmp(_alarm_request_info._sensor_info.thresholdDownAction, Alarm_Ctrl_type) == 0) { _globalSensorMangerSaveTemp->over_manager.sensor_val2_lower_threshold_ctrl = ALARM_CTRL_CLOSE_CH; if(_alarm_request_info._sensor_info.thresholdDownChanel)strcpy(_globalSensorMangerSaveTemp->over_manager.sensor_val2_lower_threshold_ctrl_para,_alarm_request_info._sensor_info.thresholdDownChanel); } else _globalSensorMangerSaveTemp->over_manager.sensor_val2_lower_threshold_ctrl = ALARM_CTRL_ALARM_ONLY; } } break; case SENSOR_TYPE_SMOKE: case SENSOR_TYPE_WATER: case SENSOR_TYPE_ACCESS: case SENSOR_TYPE_LEAK: break; case SENSOR_TYPE_GAS: { char strName1[100] = {0}; char strName2[100] = {0}; sprintf(strName1, "%s%d", language_atmosphere_gas[__globalDeviceManage._globalDevInfo.product.language], 1); sprintf(strName2, "%s%d", language_atmosphere_gas[__globalDeviceManage._globalDevInfo.product.language], 2); if (strcmp(_alarm_request_info._sensor_info.thresholdType, language_atmosphere_gas[__globalDeviceManage._globalDevInfo.product.language]) == 0 || strcmp(_alarm_request_info._sensor_info.thresholdType, strName1) == 0) { _globalSensorMangerSaveTemp->over_manager.sensor_val1_upper_threshold = atof(_alarm_request_info._sensor_info.thresholdUpperValue); _globalSensorMangerSaveTemp->over_manager.sensor_val1_lower_threshold = atof(_alarm_request_info._sensor_info.thresholdDownValue); if (_globalSensorMangerSaveTemp->over_manager.sensor_val1_upper_threshold <= 0.05 && _globalSensorMangerSaveTemp->over_manager.sensor_val1_upper_threshold >= -0.05) { _globalSensorMangerSaveTemp->over_manager.sensor_val1_upper_enabled = 0; } else _globalSensorMangerSaveTemp->over_manager.sensor_val1_upper_enabled = 1; if (_globalSensorMangerSaveTemp->over_manager.sensor_val1_lower_threshold <= 0.05 && _globalSensorMangerSaveTemp->over_manager.sensor_val1_lower_threshold >= -0.05) { _globalSensorMangerSaveTemp->over_manager.sensor_val1_lower_enabled = 0; } else _globalSensorMangerSaveTemp->over_manager.sensor_val1_lower_enabled = 1; if (_alarm_request_info._sensor_info.thresholdUpperAction && strcmp(_alarm_request_info._sensor_info.thresholdUpperAction, Alarm_Ctrl_type) == 0) { _globalSensorMangerSaveTemp->over_manager.sensor_val1_upper_threshold_ctrl = ALARM_CTRL_CLOSE_CH; if (_alarm_request_info._sensor_info.thresholdUpperChanel) strcpy(_globalSensorMangerSaveTemp->over_manager.sensor_val1_upper_threshold_ctrl_para, _alarm_request_info._sensor_info.thresholdUpperChanel); } else _globalSensorMangerSaveTemp->over_manager.sensor_val1_upper_threshold_ctrl = ALARM_CTRL_ALARM_ONLY; if (_alarm_request_info._sensor_info.thresholdDownAction && strcmp(_alarm_request_info._sensor_info.thresholdDownAction, Alarm_Ctrl_type) == 0) { _globalSensorMangerSaveTemp->over_manager.sensor_val1_lower_threshold_ctrl = ALARM_CTRL_CLOSE_CH; if (_alarm_request_info._sensor_info.thresholdDownChanel) strcpy(_globalSensorMangerSaveTemp->over_manager.sensor_val1_lower_threshold_ctrl_para, _alarm_request_info._sensor_info.thresholdDownChanel); } else _globalSensorMangerSaveTemp->over_manager.sensor_val1_lower_threshold_ctrl = ALARM_CTRL_ALARM_ONLY; } } break; case SENSOR_TYPE_AIR_PRESS: default: break; } //更新参数 ret = dev_update_sensor_over_manage(__globalDeviceManage.db, __globalDeviceManage._globalDevInfo.product.id, g_sensor_id, _globalSensorMangerSaveTemp); if(ret!=0) log_e("power threshold update error."); char log_buff[256]; sprintf(log_buff, "Update sensor threshold ID%d!",g_sensor_id); dev_insert_alarm_ctrl(__globalDeviceManage.db, __globalDeviceManage._globalDevInfo.product.id, ALARM_TYPE_OPRATION, log_buff); //拿到参数保存 ack_str = ctrl_sts_ack_to_json(); } cJSON_Delete(cjson); http_reply(conn, 200, ack_str); cJSON_free((void*)ack_str); } /// @brief 查询日志 /// @param stream static void logInformation(void *conn) { int ret = -1 ; char* ack_str = NULL ; int nAlarmNum = 0; cJSON *cjson; _LogInformationRequestInfo __logInformationRequestInfo; _AlarmAckInfo _alarm_ack_info; //填充数据 mg_stream_t *s=(mg_stream_t*)conn; struct mg_http_message *hm=s->ev_data; char *rx_body_buf=(char*)hm->body.buf; memset(&__logInformationRequestInfo,0,sizeof(_LogInformationRequestInfo)); cjson = json_to_loginformation_manage(rx_body_buf,&__logInformationRequestInfo); if(cjson==NULL) { http_reply(conn, 400, NULL); return ; } //查询json参数 if(strcmp(__logInformationRequestInfo.type,"listJgrzQuery")==0) //告警日志 { //初始化表 INIT_LIST_HEAD(&_alarm_ack_info.list); if(__logInformationRequestInfo.startTime==NULL || __logInformationRequestInfo.endtime==NULL) { struct tm* t ; struct timeval tv; char start_time[32] = {0}; char stop_time[32] = {0}; gettimeofday(&tv, NULL); t = localtime(&tv.tv_sec); sprintf(stop_time,"%04d-%02d-%02d %02d:%02d:%02d",t->tm_year+1900,t->tm_mon+1,t->tm_mday,23,59,59); log_d(stop_time); sprintf(start_time,"%04d-%02d-%02d %02d:%02d:%02d",t->tm_year+1900,t->tm_mon+1,t->tm_mday,0,0,0); log_d(start_time); dev_search_alarm_info(__globalDeviceManage.db, __globalDeviceManage._globalDevInfo.product.id, 0, //注意注意 此处需要查询的参数是0 1 2 start_time,//启动时间 stop_time, //结束时间 __logInformationRequestInfo.pagenum, //页 __logInformationRequestInfo.pagesize, //条 &_alarm_ack_info,&nAlarmNum); ack_str = alarm_type_info_to_json(&_alarm_ack_info,nAlarmNum); //释放资源 _AlarmAckInfo* node; _AlarmAckInfo* next; list_for_each_entry_safe(node, next, &_alarm_ack_info.list, list) { list_del(&node->list); free(node); } } else { dev_search_alarm_info(__globalDeviceManage.db, __globalDeviceManage._globalDevInfo.product.id, 0, //注意注意 此处需要查询的参数是0 1 2 __logInformationRequestInfo.startTime,//开始时间 __logInformationRequestInfo.endtime, //结束时间 __logInformationRequestInfo.pagenum, //页 __logInformationRequestInfo.pagesize, //条 &_alarm_ack_info,&nAlarmNum); ack_str = alarm_type_info_to_json(&_alarm_ack_info,nAlarmNum); //释放资源 _AlarmAckInfo* node; _AlarmAckInfo* next; list_for_each_entry_safe(node, next, &_alarm_ack_info.list, list) { list_del(&node->list); free(node); } } //转换参数 //ack_str = alarm_type_info_to_json(&_alarm_ack_info); } else if(strcmp(__logInformationRequestInfo.type,"listCzrzQuery")==0) //操作日志 { //初始化表 INIT_LIST_HEAD(&_alarm_ack_info.list); //默认查当天日志 if(__logInformationRequestInfo.startTime==NULL || __logInformationRequestInfo.endtime==NULL) { struct tm* t ; struct timeval tv; char start_time[32] = {0}; char stop_time[32] = {0}; gettimeofday(&tv, NULL); t = localtime(&tv.tv_sec); sprintf(stop_time,"%04d-%02d-%02d %02d:%02d:%02d",t->tm_year+1900,t->tm_mon+1,t->tm_mday,23,59,59); log_d(stop_time); sprintf(start_time,"%04d-%02d-%02d %02d:%02d:%02d",t->tm_year+1900,t->tm_mon+1,t->tm_mday,0,0,0); log_d(start_time); dev_search_alarm_info(__globalDeviceManage.db, __globalDeviceManage._globalDevInfo.product.id, ALARM_TYPE_OPRATION, // alarm_type, 操作日志 start_time, stop_time, __logInformationRequestInfo.pagenum, __logInformationRequestInfo.pagesize, &_alarm_ack_info, &nAlarmNum); } else { dev_search_alarm_info(__globalDeviceManage.db, __globalDeviceManage._globalDevInfo.product.id, ALARM_TYPE_OPRATION,// alarm_type, 操作日志 __logInformationRequestInfo.startTime, __logInformationRequestInfo.endtime, __logInformationRequestInfo.pagenum, __logInformationRequestInfo.pagesize, &_alarm_ack_info,&nAlarmNum); } //转换参数 ack_str = alarm_ctrl_type_info_to_json(&_alarm_ack_info,nAlarmNum); //释放资源 _AlarmAckInfo* node; _AlarmAckInfo* next; list_for_each_entry_safe(node, next, &_alarm_ack_info.list, list) { list_del(&node->list); free(node); } } else if(strcmp(__logInformationRequestInfo.type,"listYxrzQuery")==0) //运行日志 { //初始化表 INIT_LIST_HEAD(&_alarm_ack_info.list); //默认查当天日志 if(__logInformationRequestInfo.startTime==NULL || __logInformationRequestInfo.endtime==NULL) { struct tm *t; struct timeval tv; char start_time[32] = {0}; char stop_time[32] = {0}; gettimeofday(&tv, NULL); t = localtime(&tv.tv_sec); sprintf(stop_time,"%04d-%02d-%02d %02d:%02d:%02d",t->tm_year+1900,t->tm_mon+1,t->tm_mday,23,59,59); log_d(stop_time); sprintf(start_time,"%04d-%02d-%02d %02d:%02d:%02d",t->tm_year+1900,t->tm_mon+1,t->tm_mday,0,0,0); log_d(start_time); dev_search_alarm_info(__globalDeviceManage.db, __globalDeviceManage._globalDevInfo.product.id, ALARM_TYPE_RUNNING, // alarm_type, 运行日志 start_time, stop_time, __logInformationRequestInfo.pagenum, __logInformationRequestInfo.pagesize, &_alarm_ack_info, &nAlarmNum); } else { dev_search_alarm_info(__globalDeviceManage.db, __globalDeviceManage._globalDevInfo.product.id, ALARM_TYPE_RUNNING, // alarm_type, 运行日志 __logInformationRequestInfo.startTime, __logInformationRequestInfo.endtime, __logInformationRequestInfo.pagenum, __logInformationRequestInfo.pagesize, &_alarm_ack_info, &nAlarmNum); } // 转换参数 ack_str = alarm_type_info_to_json(&_alarm_ack_info, nAlarmNum); //释放资源 _AlarmAckInfo* node; _AlarmAckInfo* next; list_for_each_entry_safe(node, next, &_alarm_ack_info.list, list) { list_del(&node->list); free(node); } } else if(strcmp(__logInformationRequestInfo.type,"exportCzrz")==0) //导出操作日志 { } else if(strcmp(__logInformationRequestInfo.type,"exportYxrz")==0) //导出运行日志 { } else if(strcmp(__logInformationRequestInfo.type,"exportJgrz")==0) //导出告警日志 { // } cJSON_Delete(cjson); http_reply(conn, 200, ack_str); cJSON_free((void*)ack_str); } /// @brief 通信网口设置 /// @param stream static void communicationManagement(void *conn) { int r = -1 ; char* ack_str = NULL ; cJSON *cjson; _CommunicationManageRequestInfo _communicationManageRequestInfo; _CommunicationManageRequestInfo reqInfo; GlobalDeviceInfo *devInfo=&__globalDeviceManage._globalDevInfo; mg_stream_t *s=(mg_stream_t*)conn; struct mg_http_message *hm=s->ev_data; char *rx_body_buf=(char*)hm->body.buf; //转换json参数 cjson = json_to_communication_manage(rx_body_buf,&reqInfo); if(cjson==NULL) { http_reply(conn, 400, NULL); return ; } //查询网络参数 if(strcmp(reqInfo.type,"listWkIPV4Query")==0 || strcmp(reqInfo.type,"listWkIPV6Query")==0)//缃戠粶鍙傛暟鏌ヨ { NetworkInfo_t info={0}; int r,ipv=(strstr(reqInfo.type, "listWkIPV4Query")?IP_V4:IP_V6); r = sys_get_net(&info, ipv); if(r==0) { ack_str = communication_net_ack_to_json(&info); } } else if(strcmp(reqInfo.type,"WkIPV4Save")==0 || strcmp(reqInfo.type,"WkIPV6Save")==0 ) //淇濆瓨鏁版嵁 { NetworkInfo_t* info = &devInfo->network; _NET_CommunicationRequestInfo *info2=&reqInfo._net_info; int ipv=(strstr(reqInfo.type, "WkIPV4Save")?IP_V4:IP_V6); int mode = atoi(info2->mode); if(ipv==IP_V4 || (ipv==IP_V6 && mode==IP_STATIC)) { info->mode = mode; if(info2->ipaddr) strcpy(info->ip_address, info2->ipaddr); if(info2->maskaddr) strcpy(info->mask, info2->maskaddr); if(info2->gateway) strcpy(info->gateway, info2->gateway); if(info2->dns1) strcpy(info->dns1, info2->dns1); if(info2->dns2) strcpy(info->dns2, info2->dns2); r = sys_set_net(info, ipv); //print_net("set", info); } ack_str = ctrl_sts_ack_to_json(); } //查询设置RS485参数 else if(strcmp(reqInfo.type,"listRsQuery")==0)//modbus鍙傛暟鏌ヨ { ModbusInfo_t* _modbusInfo_temp = &devInfo->cascade; ack_str = communication_rs_ack_to_json(_modbusInfo_temp); } else if(strcmp(reqInfo.type,"RsSave")==0)//淇濆瓨modbus鏁版嵁 { ModbusInfo_t* info = &devInfo->cascade; bool isStrMaster=strcmp(reqInfo._rs_info.mode,language_alarm_RS485_master[__globalDeviceManage._globalDevInfo.product.language])==0; bool isStrSlave=strcmp(reqInfo._rs_info.mode,language_alarm_RS485_slave[__globalDeviceManage._globalDevInfo.product.language])==0; if (isStrMaster||isStrSlave) { if (isStrMaster) { info->mode = MODBUS_MASTER; } else { info->mode =MODBUS_SLAVE; } } else { info->mode = atoi(reqInfo._rs_info.mode); } info->baudrate = atoi(reqInfo._rs_info.baud); info->addr = atoi(reqInfo._rs_info.addr); /////////////////////////////////////////////////////////////////////////////// r = cascade_set_modbus(info); if(r==0) { paras_save(); } char buff[256]; if (!info->mode) { sprintf(buff, "$%s$|$%s$|BD:%d", language_RS485_install[0],language_alarm_RS485_master[0],info->baudrate); } else { sprintf(buff, "$%s$|$%s$|addr:%d BD:%d",language_RS485_install[0],language_alarm_RS485_slave[0],info->addr,info->baudrate); } dev_insert_alarm_ctrl(__globalDeviceManage.db,__globalDeviceManage._globalPowerManger.product_id,ALARM_TYPE_OPRATION,buff); ack_str = ctrl_sts_ack_to_json(); } #ifdef USE_CELL else if (strcmp(reqInfo.type, "listfourgPZQuery") == 0) // 4G网络处理 { ack_str = communication_4G_ack_to_json(&_globalCellularManager,0); } else if (strcmp(reqInfo.type, "fourgPZSave") == 0) // 4G网络处理 { _globalCellularManager.mode = reqInfo._4g_wifi_info.Cellular_mode; if (_globalCellularManager.mode) { Cellular_init(); } else { thread_stop(THREAD_ID_Cellular); } __globalDeviceManage._globalDevInfo.cell = _globalCellularManager.mode; paras_save(); ack_str = ctrl_sts_ack_to_json(); } #endif #ifdef USE_WIFI else if(strcmp(reqInfo.type,"listWIFIPZQuery")==0) // WIFI处理 { ap_stat_t stat; WIFIManager *wm=&_globalWIFIManager; wifi_sta_stat(&stat); wm->Link_status = stat.link; strcpy(wm->WIFI_ip, stat.ipaddr); ack_str = communication_WIFI_ack_to_json(wm,0); } else if (strcmp(reqInfo.type, "WIFIPZSave") == 0) // WIFI处理 { _globalWIFIManager.mode = reqInfo._4g_wifi_info.WIFI_mode; strcpy(_globalWIFIManager.WIFI_name, reqInfo._4g_wifi_info.WIFI_name); strcpy(_globalWIFIManager.WIFI_code, reqInfo._4g_wifi_info.WIFI_code); wifi_set(&_globalWIFIManager); __globalDeviceManage._globalDevInfo.wifi = _globalWIFIManager; paras_save(); ack_str = ctrl_sts_ack_to_json(); } #endif cJSON_Delete(cjson); http_reply(conn, 200, ack_str); cJSON_free((void*)ack_str); } /// @brief 服务管理 /// @param stream static void serviceManagement(void *conn) { int ret = -1 ; cJSON *cjson; _ServiceManageRequestInfo _serviceManageRequestInfo; char* ack_str = NULL ; mg_stream_t *s=(mg_stream_t*)conn; struct mg_http_message *hm=s->ev_data; char *rx_body_buf = (char*)hm->body.buf; GlobalDeviceManager *gdm=&__globalDeviceManage; //转换json参数 memset(&_serviceManageRequestInfo, 0, sizeof(_serviceManageRequestInfo)); cjson = json_to_service_manage(rx_body_buf,&_serviceManageRequestInfo); if(cjson==NULL) { http_reply(conn, 400, NULL); return ; } if(strcmp(_serviceManageRequestInfo.type,"listSmtpQuery")==0) { ack_str = service_mail_ack_to_json(&gdm->mailInfo); } else if(strcmp(_serviceManageRequestInfo.type,"SmtpSave")==0) { mail_info_t mailInfo=gdm->mailInfo; mail_send_t *send=&mailInfo.send; mail_recv_t *recv=mailInfo.recv; _MAIL_ServerRequestInfo *info=&_serviceManageRequestInfo._smtp_info; if(info->mode) { int save_flag=0; int mode=atoi(info->mode); send->mode = mode; if(send->mode) { if(info->account && info->password && info->server && info->port && info->auth) { if(strcmp(send->account, info->account)) { strcpy(send->account, info->account); save_flag = 1; } if(strcmp(send->password, info->password)) { strcpy(send->password, info->password); save_flag = 1; } if(strcmp(send->server, info->server)) { strcpy(send->server, info->server); } if(strcmp(send->port, info->port)) { strcpy(send->port, info->port);; } if(strcmp(send->auth, info->auth)) { strcpy(send->auth, info->auth);; } } } else { //memset(send, 0, sizeof(mail_send_t)); } if(memcmp(&mailInfo.send, &gdm->mailInfo.send, sizeof(mail_send_t))) { dev_mail_update_send(gdm->db, send); gdm->mailInfo.send = mailInfo.send; } for(int i=0; irecvAccount[i]) { recv[i].use = 1; strcpy(recv[i].account, info->recvAccount[i]); } else{ recv[i].use = 0; if(mode) { strcpy(recv[i].account,""); } } } if(memcmp(mailInfo.recv, gdm->mailInfo.recv, sizeof(mail_recv_t)*MAIL_RECV_MAX)) { dev_mail_update_recv(gdm->db, recv); memcpy(gdm->mailInfo.recv, mailInfo.recv, sizeof(mail_recv_t)*MAIL_RECV_MAX); } } } #ifdef USE_MQTT else if(strcmp(_serviceManageRequestInfo.type,"listMqttQuery")==0) { ack_str = service_mqtt_ack_to_json(&gdm->mqttInfo); } else if(strcmp(_serviceManageRequestInfo.type,"mqttSave")==0) { int save_flag=0; _MQTT_ServerRequestInfo *req=&_serviceManageRequestInfo._mqtt_info; mqtt_server_t *ser=&gdm->mqttInfo.ser[req->idx]; if(req->idx |= ser->id) { ser->id = req->idx; save_flag=1; } if(req->name) { strcpy(ser->name, req->name); save_flag=1; } if(req->server) { strcpy(ser->server, req->server); save_flag=1; } if(req->port) { strcpy(ser->port, req->port); save_flag=1; } if(req->user) { strcpy(ser->user, req->user); save_flag=1; } if(req->password) { strcpy(ser->password, req->password); save_flag=1; } if(req->cid) { strcpy(ser->cid, req->cid); save_flag=1; } if(save_flag) { dev_mqtt_update_ser(gdm->db, ser); } } else if(strcmp(_serviceManageRequestInfo.type,"mqttOpen")==0 || strcmp(_serviceManageRequestInfo.type,"mqttClose")==0) { int save_flag=0; _MQTT_ServerRequestInfo *req=&_serviceManageRequestInfo._mqtt_info; mqtt_server_t *ser=&gdm->mqttInfo.ser[req->idx]; if(req->mode!=ser->mode) { ser->mode = req->mode; dev_mqtt_update_ser(gdm->db, ser); } } #endif else if(strcmp(_serviceManageRequestInfo.type,"listSnmpQuery")==0) { // 查询SNMP信息 if (0 == dev_get_snmp_info(__globalDeviceManage.db, &_globalSNMPManager)) { ack_str = service_snmp_ack_to_json(&_globalSNMPManager); } } else if(strcmp(_serviceManageRequestInfo.type,"SnmpSave")==0) { int len=0; _globalSNMPManager.mode = atoi(_serviceManageRequestInfo._snmp_info.mode); if (strcmp(_serviceManageRequestInfo._snmp_info.version,"SNMP V1")==0) { _globalSNMPManager.version=0; } else if (strcmp(_serviceManageRequestInfo._snmp_info.version,"SNMP V2c")==0) { _globalSNMPManager.version=1; } else if (strcmp(_serviceManageRequestInfo._snmp_info.version,"SNMP V3")==0) { _globalSNMPManager.version=2; } else { //_globalSNMPManager.version=1; } strcpy(_globalSNMPManager.public, _serviceManageRequestInfo._snmp_info.public); _globalSNMPManager.trapmode = atoi(_serviceManageRequestInfo._snmp_info.trapmode); if (_serviceManageRequestInfo._snmp_info.nms_IP) strcpy(_globalSNMPManager.nmsIP, _serviceManageRequestInfo._snmp_info.nms_IP); crypt_t *pc=&_globalSNMPManager.crypt; _SNMP_ServerRequestInfo *info=&_serviceManageRequestInfo._snmp_info; if (_globalSNMPManager.version == 2) { if (info->user) { len = strlen(info->user); if (len < 8 || len > 32) { log_e("snmp user length %d is wrong! correct is [8~32]", len); return; } strcpy(pc->user, info->user); if (info->auth_alg) { strcpy(pc->auth.alg, info->auth_alg); if (strlen(info->auth_alg) > 1 && info->auth_passwd) { len = strlen(info->auth_passwd); if (len < 8 || len > 32) { log_e("snmp auth passwd length %d is wrong! correct is [8~32]", len); return; } strcpy(pc->auth.passwd, info->auth_passwd); } } if (info->priv_alg) { strcpy(pc->priv.alg, info->priv_alg); if (strlen(info->priv_alg) > 1 && info->priv_passwd) { len = strlen(info->priv_passwd); if (len < 8 || len > 32) { log_e("snmp priv passwd length %d is wrong! correct is [8~32]", len); return; } strcpy(pc->priv.passwd, info->priv_passwd); } } } } _globalSNMPManager.product_id = __globalDeviceManage._globalDevInfo.product.id; if (dev_update_snmp_info(__globalDeviceManage.db,_globalSNMPManager.product_id,&_globalSNMPManager) != 0) { log_e("update snmp info err."); } else { extern int snmp_config(SNMPManager *m, int quit); snmp_config(&_globalSNMPManager, 1); } } //查询snmp_trap信息 else if(strcmp(_serviceManageRequestInfo.type,"listStQuery")==0) { } else if(strcmp(_serviceManageRequestInfo.type,"StSave")==0) { } //查询ntp信息 else if(strcmp(_serviceManageRequestInfo.type,"listNtpQuery")==0) { // 查询NTP信息 if (0 == dev_get_ntp_info(__globalDeviceManage.db,&_globalNTPManager)) { ack_str = service_ntp_ack_to_json(&_globalNTPManager); } } else if(strcmp(_serviceManageRequestInfo.type,"NtpSave")==0) { _globalNTPManager.mode = atoi(_serviceManageRequestInfo._ntp_info.mode); strcpy(_globalNTPManager.ntpaddress, _serviceManageRequestInfo._ntp_info.ntpaddress); strcpy(_globalNTPManager.ntpName, _serviceManageRequestInfo._ntp_info.ntpName); _globalNTPManager.port = atoi(_serviceManageRequestInfo._ntp_info.port); _globalNTPManager.product_id = __globalDeviceManage._globalDevInfo.product.id; strcpy(_globalNTPManager.time, _serviceManageRequestInfo._ntp_info.time); const char* key = "GMT/UTC"; char* p = strstr(_serviceManageRequestInfo._ntp_info.tzone, key); if (p == NULL) { log_e("time zone not contain GMT/UTC"); return; } p += strlen(key); int value = atoi(p); if (value > 12 || value < -12) { char buf[128]; memset(buf, 0, sizeof(buf)); sprintf(buf, "product id = %d timezone: %d, timezone err.", _globalNTPManager.product_id, value); log_e(buf); return; } _globalNTPManager.tzone = value; value = atoi(_serviceManageRequestInfo._ntp_info.weekday); if (value > 12 || value < -11) { char buf[128]; memset(buf, 0, sizeof(buf)); sprintf(buf, "product id = %d weekday err.", _globalNTPManager.product_id); log_e(buf); return; } _globalNTPManager.weekday = value; if (dev_update_ntp_info(__globalDeviceManage.db,_globalNTPManager.product_id,&_globalNTPManager) != 0) { log_e("update ntp info err."); } char temp[100]; if (0==_globalNTPManager.mode) { //sprintf(temp,"$设置$|$时间$|%s", _globalNTPManager.time); sprintf(temp,"Set Date & Time %s", _globalNTPManager.time); } else{ // sprintf(temp,"$设置$|$时间$|NTP %s", _globalNTPManager.ntpaddress); sprintf(temp,"Set Date & Time sync from NTP %s", _globalNTPManager.ntpaddress); } dev_insert_alarm_ctrl(__globalDeviceManage.db,__globalDeviceManage._globalDevInfo.product.id, ALARM_TYPE_OPRATION, temp); if (_globalNTPManager.mode == 0) { char tempstr[10]; memset(tempstr, 0, sizeof(tempstr)); p = strstr(_globalNTPManager.time, "-"); if (p == NULL) { log_e("find year of local time failed"); return; } memset(tempstr, 0, sizeof(tempstr)); memcpy(tempstr, _globalNTPManager.time, p - _globalNTPManager.time); struct tm tm_new; tm_new.tm_year = atoi(tempstr); char* p1 = strstr(&p[1], "-"); if (p1 == NULL) { log_e("find month of local time failed"); return; } int nSize= p1 - p - 1; memset(tempstr, 0, sizeof(tempstr)); memcpy(tempstr, &p[1],nSize); tm_new.tm_mon = atoi(tempstr); p = p1; p1 = strstr(&p[2], " ");//个位数第一位有可能是空格所以需要找空格后一个 if (p1 == NULL) { log_e("find mday of local time failed"); return; } memset(tempstr, 0, sizeof(tempstr)); memcpy(tempstr, &p[1], p1 - p - 1); tm_new.tm_mday = atoi(tempstr); p = p1; p1 = strstr(&p[0], " "); if (p1 == NULL) { log_e("find split of date and time failed"); return; } p = &p1[0]; p1 = strstr(p, ":"); if (p1 == NULL) { log_e("find hour of local time failed"); return; } memset(tempstr, 0, sizeof(tempstr)); memcpy(tempstr, &p[1], p1 - p); tm_new.tm_hour = atoi(tempstr); p = &p1[1]; p1 = strstr(p, ":"); if (p1 == NULL) { log_e("find minute of local time failed"); return; } memset(tempstr, 0, sizeof(tempstr)); memcpy(tempstr, &p[0], p1 - p); tm_new.tm_min = atoi(tempstr); p = &p1[1]; if (p == NULL) { log_e("find second of local time failed"); return; } memset(tempstr, 0, sizeof(tempstr)); memcpy(tempstr, &p[0], 2); tm_new.tm_sec = atoi(tempstr); set_time_zone(&tm_new, _globalNTPManager.tzone); } else if (_globalNTPManager.mode == 1) { set_tzone(_globalNTPManager.tzone); sleep(1); extern int ntp_config(NTPManager *nm); ntp_config(&_globalNTPManager); } ack_str = ctrl_sts_ack_to_json(); if (_serviceManageRequestInfo._ntp_info.mode) free(_serviceManageRequestInfo._ntp_info.mode); if (_serviceManageRequestInfo._ntp_info.port) free(_serviceManageRequestInfo._ntp_info.port); if (_serviceManageRequestInfo._ntp_info.tzone) free(_serviceManageRequestInfo._ntp_info.tzone); if (_serviceManageRequestInfo._ntp_info.weekday) free(_serviceManageRequestInfo._ntp_info.weekday); } // 定时设置 else if (strcmp(_serviceManageRequestInfo.type, "listDsQuery") == 0)//||strcmp(_serviceManageRequestInfo.type, "listRlQuery") == 0) { // 查询通道信息 /* GlobalPowerManger *_globalPowerMangerTemp = NULL; list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list) { if (_globalPowerMangerTemp->product_ch_id == chn_id) break; } */ // 返回定时信息 lock_s_hold(LOCK_ID_POWER_TIMER); ack_str = service_ds_all_ack_to_json(_serviceManageRequestInfo._ds_info.channelDate, _serviceManageRequestInfo._ds_info.productChName, _serviceManageRequestInfo._ds_info.productChId, &__globalDeviceManage._globalPowerManger); lock_s_release(LOCK_ID_POWER_TIMER); } else if (strcmp(_serviceManageRequestInfo.type, "dsSave") == 0) { lock_s_hold(LOCK_ID_POWER_TIMER); int chn_id = -1; for (int i = 0; i < 64; i++) { chn_id = _serviceManageRequestInfo._ds_info.productChIds[i]; if (chn_id <= 0) { break; } // 查询通道信息 GlobalPowerManger *_globalPowerMangerTemp = NULL; list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list) { if (_globalPowerMangerTemp->product_ch_id == chn_id) break; } int start_year, start_month, start_day; int end_year, end_month, end_day; char current_date[11]; // 足够存储 "YYYY-MM-DD\0" // 解析起始和结束日期 sscanf(_serviceManageRequestInfo._ds_info.StartDate, "%d-%d-%d", &start_year, &start_month, &start_day); sscanf(_serviceManageRequestInfo._ds_info.Enddate, "%d-%d-%d", &end_year, &end_month, &end_day); // 复制起始日期到current_date strcpy(current_date, _serviceManageRequestInfo._ds_info.StartDate); // 循环直到或超过结束日期 int done = 0; while (!done) { // 当前日期 _PowerDSManage_t *new_data = (_PowerDSManage_t *)calloc(1, sizeof(_PowerDSManage_t)); if(!new_data) { log_e("___ new_data calloc failed!\n"); break; } memset(new_data, 0, sizeof(_PowerDSManage_t)); strcpy(new_data->ds_date, current_date); strcpy(new_data->ds_time, _serviceManageRequestInfo._ds_info.channelTime); new_data->set_stats = atoi(_serviceManageRequestInfo._ds_info.setStatus); new_data->ds_is_triggered = 0; list_add_tail(&new_data->list, &_globalPowerMangerTemp->list_DS); dev_insert_power_ds(__globalDeviceManage.db, 1, chn_id, new_data); // 解析当前日期为年、月、日 sscanf(current_date, "%d-%d-%d", &start_year, &start_month, &start_day); // 增加一天 add_day_to_date(current_date, &start_year, &start_month, &start_day); // 检查是否超过结束日期 if (start_year > end_year || (start_year == end_year && start_month > end_month) || (start_year == end_year && start_month == end_month && start_day > end_day)) { done = 1; // 超过结束日期，退出循环 } } } lock_s_release(LOCK_ID_POWER_TIMER); char temp[100]; //sprintf(temp, "$设置$|定时$"); sprintf(temp, "Add scheduled tasks"); dev_insert_alarm_ctrl(__globalDeviceManage.db, __globalDeviceManage._globalDevInfo.product.id, ALARM_TYPE_OPRATION, temp); ack_str = ctrl_sts_ack_to_json(); } //批量删除 else if (strcmp(_serviceManageRequestInfo.type, "deleteDs")==0) { int nChID = 0; char pcDate[16]; char pcTime[16]; GlobalPowerManger *_globalPowerMangerTemp = NULL; _PowerDSManage_t* _powerDsManageTemp=NULL;; char *pCharData; lock_s_hold(LOCK_ID_POWER_TIMER); for (int i = 0; i < 64; i++) { pCharData = _serviceManageRequestInfo._ds_info.idx[i]; if (pCharData == NULL || *pCharData == '\0') { break; } sscanf(pCharData, "%d %s %s", &nChID, pcDate, pcTime); list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list) { if (_globalPowerMangerTemp->product_ch_id == nChID) break; } list_for_each_entry(_powerDsManageTemp, &_globalPowerMangerTemp->list_DS, list) { if (strcmp(_powerDsManageTemp->ds_date, pcDate) == 0&&strcmp(_powerDsManageTemp->ds_time, pcTime) == 0) { dev_delete_power_ds(__globalDeviceManage.db, 1, _globalPowerMangerTemp->product_ch_id, _powerDsManageTemp); list_del(&_powerDsManageTemp->list); free(_powerDsManageTemp); _powerDsManageTemp=NULL; break; } } } lock_s_release(LOCK_ID_POWER_TIMER); char temp[100]; // sprintf(temp, "$删除$|定时$"); sprintf(temp, "Delete scheduled tasks"); dev_insert_alarm_ctrl(__globalDeviceManage.db, __globalDeviceManage._globalDevInfo.product.id, ALARM_TYPE_OPRATION, temp); ack_str = ctrl_sts_ack_to_json(); } // 时序设置 else if (strcmp(_serviceManageRequestInfo.type, "listSxQuery") == 0) // 查询 { bool bflag = false; GlobalPowerManger *_globalPowerMangerTemp = NULL; list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list) { if (_globalPowerMangerTemp->product_id == atoi(_serviceManageRequestInfo._posix_info.productId)) { bflag = true; break; } } if (bflag == false) return; ack_str = service_sx_ack_to_json(_globalPowerMangerTemp->product_id, &__globalDeviceManage._globalPowerManger); if (_serviceManageRequestInfo._posix_info.productId) free(_serviceManageRequestInfo._posix_info.productId); } else if(strcmp(_serviceManageRequestInfo.type,"sXTimeSave")==0)//保存时间间隔 { int chn_id = atoi(_serviceManageRequestInfo._posix_info.productChId); int id = atoi(_serviceManageRequestInfo._posix_info.productId); GlobalPowerManger *_globalPowerMangerTemp = NULL; list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list) { if (_globalPowerMangerTemp->product_id == id && _globalPowerMangerTemp->product_ch_id == chn_id) { int value = atoi(_serviceManageRequestInfo._posix_info.firingInterval); if (value > 65535) { char buf[128]; memset(buf, 0, sizeof(buf)); sprintf(buf, "product id = %d, ch id = %d start delay err.", _globalPowerMangerTemp->product_id, _globalPowerMangerTemp->product_ch_id); log_e(buf); continue; } _globalPowerMangerTemp->product_ch_start_delay = value; value = atoi(_serviceManageRequestInfo._posix_info.closeInterval); if (value > 65535) { char buf[128]; memset(buf, 0, sizeof(buf)); sprintf(buf, "product id = %d, ch id = %d stop delay err.", _globalPowerMangerTemp->product_id, _globalPowerMangerTemp->product_ch_id); log_e(buf); continue; } _globalPowerMangerTemp->product_ch_stop_delay = value; ret=g_switch_set_all_start_time_delay(&__globalDeviceManage._globalRelaySampManger,_globalPowerMangerTemp->product_ch_type,_globalPowerMangerTemp->product_saddr,_globalPowerMangerTemp->product_ch_addr,_globalPowerMangerTemp->product_ch_start_delay); if (ret<0) { usleep(50000); g_switch_set_all_start_time_delay(&__globalDeviceManage._globalRelaySampManger,_globalPowerMangerTemp->product_ch_type,_globalPowerMangerTemp->product_saddr,_globalPowerMangerTemp->product_ch_addr,_globalPowerMangerTemp->product_ch_start_delay); /* code */ } ret = g_switch_set_all_stop_time_delay(&__globalDeviceManage._globalRelaySampManger,_globalPowerMangerTemp->product_ch_type,_globalPowerMangerTemp->product_saddr,_globalPowerMangerTemp->product_ch_addr,_globalPowerMangerTemp->product_ch_stop_delay); if (ret<0) { usleep(50000); g_switch_set_all_stop_time_delay(&__globalDeviceManage._globalRelaySampManger,_globalPowerMangerTemp->product_ch_type,_globalPowerMangerTemp->product_saddr,_globalPowerMangerTemp->product_ch_addr,_globalPowerMangerTemp->product_ch_stop_delay); /* code */ } if (dev_update_power_manage_genera_info(__globalDeviceManage.db,_globalPowerMangerTemp->product_id,_globalPowerMangerTemp->product_ch_id,_globalPowerMangerTemp) != 0) { log_e("update pwr general data err."); } break; } } ack_str = ctrl_sts_ack_to_json(); if (_serviceManageRequestInfo._posix_info.productId) free(_serviceManageRequestInfo._posix_info.productId); if (_serviceManageRequestInfo._posix_info.closeInterval) free(_serviceManageRequestInfo._posix_info.closeInterval); if (_serviceManageRequestInfo._posix_info.firingInterval) free(_serviceManageRequestInfo._posix_info.firingInterval); if (_serviceManageRequestInfo._posix_info.productChId) free(_serviceManageRequestInfo._posix_info.productChId); } // 分组设置 else if (strcmp(_serviceManageRequestInfo.type, "fzSave") == 0) // 分组设置 { int nMode = atoi(_serviceManageRequestInfo._group_info.mode); GlobalPowerManger* _globalPowerMangerTemp = NULL ; int chNum= 0; list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list) { chNum++; } //初始化分组-(未析构) GroupInfo group_list; INIT_LIST_HEAD(&group_list.list); if (0 == nMode)//相邻分组方式 { int xlnum = atoi(_serviceManageRequestInfo._group_info.xlnumber); if (xlnum > 0) { int pGroupNum = chNum/xlnum; if (chNum % xlnum>0) { pGroupNum++; } dev_delete__group_info(__globalDeviceManage.db,__globalDeviceManage._globalDevInfo.product.id); for (size_t i = 0; i < pGroupNum; i++) { GroupInfo *new_group = (GroupInfo *)malloc(sizeof(GroupInfo)); // 清空数据 memset(new_group, 0, sizeof(GroupInfo)); if (!new_group) { break; } new_group->product_id = __globalDeviceManage._globalDevInfo.product.id; new_group->GroupID = i + 1; sprintf(new_group->GroupName, "Group%d", i + 1); int j = 0; GlobalPowerManger *_globalPowerMangerTemp1 = NULL; list_for_each_entry(_globalPowerMangerTemp1, &__globalDeviceManage._globalPowerManger.list, list) { if (j >= i * xlnum && j < (i + 1) * xlnum) { char chTemp[64]; sprintf(chTemp, "%d,", _globalPowerMangerTemp1->product_ch_id); strcat(new_group->GroupChList, chTemp); } j++; } list_add_tail(&new_group->list, &group_list.list); dev_insert_group_info(__globalDeviceManage.db, new_group); } } } else if (1 == nMode)//间隔分组方式 { int jgnum = atoi(_serviceManageRequestInfo._group_info.jgnumber); int pGroupNum = jgnum+1; if (pGroupNum>chNum) { pGroupNum=chNum; } if (jgnum >= 0 && pGroupNum> 0 ) { dev_delete__group_info(__globalDeviceManage.db,__globalDeviceManage._globalDevInfo.product.id); for (size_t i = 0; i < pGroupNum; i++) { GroupInfo *new_group = (GroupInfo *)malloc(sizeof(GroupInfo)); // 清空数据 memset(new_group, 0, sizeof(GroupInfo)); if (!new_group) { break; } new_group->product_id = __globalDeviceManage._globalDevInfo.product.id; new_group->GroupID = i + 1; sprintf(new_group->GroupName, "Group%d", i + 1); int j = i; int m = 0; GlobalPowerManger *_globalPowerMangerTemp1 = NULL; list_for_each_entry(_globalPowerMangerTemp1, &__globalDeviceManage._globalPowerManger.list, list) { if (m==j) { char chTemp[64]; sprintf(chTemp, "%d,", _globalPowerMangerTemp1->product_ch_id); strcat(new_group->GroupChList, chTemp); j=j+jgnum+1; } m++; } list_add_tail(&new_group->list, &group_list.list); dev_insert_group_info(__globalDeviceManage.db, new_group); } } } GroupInfo *node; GroupInfo *next; list_for_each_entry_safe(node, next, &group_list.list, list) { list_del(&node->list); free(node); } ack_str = ctrl_sts_ack_to_json(); } else if (strcmp(_serviceManageRequestInfo.type, "listFzQuery") == 0) // 分组查询 { // 查询分组信息 GroupInfo group_list; INIT_LIST_HEAD(&group_list.list); if (0 == dev_get_group_info(__globalDeviceManage.db, &group_list)) { // 返回分组信息 ack_str = service_group_ack_to_json(&group_list); } GroupInfo *node; GroupInfo *next; list_for_each_entry_safe(node, next, &group_list.list, list) { list_del(&node->list); free(node); } } else if (strcmp(_serviceManageRequestInfo.type, "updateFz") == 0) // 分组修改 { if (_serviceManageRequestInfo._group_info.opergroupid && _serviceManageRequestInfo._group_info.updategroupName) { int ngroup = atoi(_serviceManageRequestInfo._group_info.opergroupid); // 查询分组信息 GroupInfo group_list; INIT_LIST_HEAD(&group_list.list); if (0 == dev_get_group_info(__globalDeviceManage.db, &group_list)) { GroupInfo *_GroupInfoTemp = NULL; list_for_each_entry(_GroupInfoTemp, &group_list.list, list) { if (_GroupInfoTemp->GroupID == ngroup) { strncpy(_GroupInfoTemp->GroupName, _serviceManageRequestInfo._group_info.updategroupName, sizeof(_GroupInfoTemp->GroupName)-1); _GroupInfoTemp->GroupName[sizeof(_GroupInfoTemp->GroupName) - 1] = '\0'; dev_update_group_info(__globalDeviceManage.db, _GroupInfoTemp); } } } GroupInfo *node; GroupInfo *next; list_for_each_entry_safe(node, next, &group_list.list, list) { list_del(&node->list); free(node); } char temp[100]; // sprintf(temp, "$打开$|$分组$|%d", ngroup); sprintf(temp, "Update group %d", ngroup); dev_insert_alarm_ctrl(__globalDeviceManage.db, __globalDeviceManage._globalDevInfo.product.id, ALARM_TYPE_OPRATION, temp); } ack_str = ctrl_sts_ack_to_json(); } else if (strcmp(_serviceManageRequestInfo.type, "fzOpen") == 0) // 分组开 { unsigned short pAddrCtrl[50]; memset(pAddrCtrl,0,sizeof(pAddrCtrl)); int ngroup= atoi(_serviceManageRequestInfo._group_info.opergroupid); // 查询分组信息 GroupInfo group_list; INIT_LIST_HEAD(&group_list.list); if (0 == dev_get_group_info(__globalDeviceManage.db, &group_list)) { GroupInfo *_GroupInfoTemp = NULL; list_for_each_entry(_GroupInfoTemp, &group_list.list, list) { if (_GroupInfoTemp->GroupID == ngroup) { if (__globalDeviceManage._globalDevInfo.product.pwr_type == 1) { // 直流版本功能 char *pCHlist; char *pCHListSave; pCHlist=strtok_r(_GroupInfoTemp->GroupChList, ",",&pCHListSave); while(pCHlist!=NULL) { GlobalPowerManger *_globalPowerMangerTemp = NULL; list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list) { if (_globalPowerMangerTemp == NULL) break; if (atoi(pCHlist) == _globalPowerMangerTemp->product_ch_id) { log_d("switch ctrl:%d,%d", _globalPowerMangerTemp->product_saddr, _globalPowerMangerTemp->product_ch_addr); pAddrCtrl[(int)_globalPowerMangerTemp->product_saddr] |= 1 << (_globalPowerMangerTemp->product_ch_addr - 1); break; } } pCHlist=strtok_r(NULL, ",",&pCHListSave); } for (size_t i = 0; i < 50; i++) { if (pAddrCtrl[i] != 0) { ret = g_switch_set_dcpdu_chns_ctrl(&__globalDeviceManage._globalRelaySampManger, i, pAddrCtrl[i], 1); if (ret < 0) { ret = g_switch_set_dcpdu_chns_ctrl(&__globalDeviceManage._globalRelaySampManger, i, pAddrCtrl[i], 1); } } } } else { char *pCHlist; char *pCHListSave; pCHlist = strtok_r(_GroupInfoTemp->GroupChList, ",",&pCHListSave); //其他版本功能 while (pCHlist!=NULL) { GlobalPowerManger *_globalPowerMangerTemp = NULL; list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list) { if (_globalPowerMangerTemp == NULL) break; if (atoi(pCHlist) == _globalPowerMangerTemp->product_ch_id) { log_d("switch ctrl:%d,%d", _globalPowerMangerTemp->product_saddr, _globalPowerMangerTemp->product_ch_addr); ret= g_switch_set_all_chn_ctrl(&__globalDeviceManage._globalRelaySampManger, _globalPowerMangerTemp, _globalPowerMangerTemp->product_saddr, _globalPowerMangerTemp->product_ch_addr, // 多版端口余8 1,true); if (ret < 0) { ret = g_switch_set_all_chn_ctrl(&__globalDeviceManage._globalRelaySampManger, _globalPowerMangerTemp, _globalPowerMangerTemp->product_saddr, _globalPowerMangerTemp->product_ch_addr, // 多版端口余8 1,true); } break; } } pCHlist = strtok_r(NULL, ",",&pCHListSave); } } } } } GroupInfo *node; GroupInfo *next; list_for_each_entry_safe(node, next, &group_list.list, list) { list_del(&node->list); free(node); } char temp[100]; //sprintf(temp, "$打开$|$分组$|%d", ngroup); sprintf(temp, "Open group %d", ngroup); dev_insert_alarm_ctrl(__globalDeviceManage.db, __globalDeviceManage._globalDevInfo.product.id, ALARM_TYPE_OPRATION, temp); ack_str = ctrl_sts_ack_to_json(); } else if (strcmp(_serviceManageRequestInfo.type, "fzClose") == 0) // 分组关 { unsigned short pAddrCtrl[50]; memset(pAddrCtrl, 0, sizeof(pAddrCtrl)); int ngroup = atoi(_serviceManageRequestInfo._group_info.opergroupid); // 查询分组信息 GroupInfo group_list; INIT_LIST_HEAD(&group_list.list); if (0 == dev_get_group_info(__globalDeviceManage.db, &group_list)) { GroupInfo *_GroupInfoTemp = NULL; list_for_each_entry(_GroupInfoTemp, &group_list.list, list) { if (_GroupInfoTemp->GroupID == ngroup) { /* code */ if (__globalDeviceManage._globalDevInfo.product.pwr_type == 1) { char *pCHlist; char *pCHListSave; pCHlist = strtok_r(_GroupInfoTemp->GroupChList, ",",&pCHListSave); // 直流版本功能 while (pCHlist!=NULL) { GlobalPowerManger *_globalPowerMangerTemp = NULL; list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list) { if (_globalPowerMangerTemp == NULL) break; if (atoi(pCHlist) == _globalPowerMangerTemp->product_ch_id) { log_d("switch ctrl:%d,%d", _globalPowerMangerTemp->product_saddr, _globalPowerMangerTemp->product_ch_addr); pAddrCtrl[(int)_globalPowerMangerTemp->product_saddr] |= 1 << (_globalPowerMangerTemp->product_ch_addr-1); break; } } pCHlist = strtok_r(NULL, ",",&pCHListSave); } for (size_t i = 0; i < 50; i++) { if (pAddrCtrl[i] != 0) { ret = g_switch_set_dcpdu_chns_ctrl(&__globalDeviceManage._globalRelaySampManger, i, pAddrCtrl[i], 0); if (ret < 0) { ret = g_switch_set_dcpdu_chns_ctrl(&__globalDeviceManage._globalRelaySampManger, i, pAddrCtrl[i], 0); /* code */ } } } } else { char *pCHlist; char *pCHListSave; pCHlist=strtok_r(_GroupInfoTemp->GroupChList, ",",&pCHListSave); while (pCHlist!=NULL) { GlobalPowerManger *_globalPowerMangerTemp = NULL; list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list) { if (_globalPowerMangerTemp == NULL) break; if (atoi(pCHlist) == _globalPowerMangerTemp->product_ch_id) { log_d("switch ctrl:%d,%d", _globalPowerMangerTemp->product_saddr, _globalPowerMangerTemp->product_ch_addr); ret = g_switch_set_all_chn_ctrl(&__globalDeviceManage._globalRelaySampManger, _globalPowerMangerTemp, _globalPowerMangerTemp->product_saddr, _globalPowerMangerTemp->product_ch_addr, // 多版端口余8 0,true); if (ret < 0) { ret = g_switch_set_all_chn_ctrl(&__globalDeviceManage._globalRelaySampManger, _globalPowerMangerTemp, _globalPowerMangerTemp->product_saddr, _globalPowerMangerTemp->product_ch_addr, // 多版端口余8 0,true); } break; } } pCHlist = strtok_r(NULL, ",",&pCHListSave); } } } } } GroupInfo *node; GroupInfo *next; list_for_each_entry_safe(node, next, &group_list.list, list) { list_del(&node->list); free(node); } char temp[100]; // sprintf(temp, "$关闭$|$分组$|%d", ngroup); sprintf(temp, "Close group %d", ngroup); dev_insert_alarm_ctrl(__globalDeviceManage.db, __globalDeviceManage._globalDevInfo.product.id, ALARM_TYPE_OPRATION, temp); ack_str = ctrl_sts_ack_to_json(); } else if (strcmp(_serviceManageRequestInfo.type, "gysbSave") == 0) { if (_serviceManageRequestInfo.productName) { /* code */ strncpy(__globalDeviceManage._globalDevInfo.product.name, _serviceManageRequestInfo.productName, sizeof(__globalDeviceManage._globalDevInfo.product.name) - 1); __globalDeviceManage._globalDevInfo.product.name[sizeof(__globalDeviceManage._globalDevInfo.product.name) - 1] = '\0'; // 确保字符串以null结尾 paras_save(); char log_buff[256]; sprintf(log_buff, "Modify device information!"); dev_insert_alarm_ctrl(__globalDeviceManage.db, __globalDeviceManage._globalDevInfo.product.id, ALARM_TYPE_OPRATION, log_buff); } ack_str = ctrl_sts_ack_to_json(); } //cJSON_Delete(cjson); http_reply(conn, 200, ack_str); cJSON_free((void*)ack_str); } static void serviceManagementUpload(void *conn) { int idx,r=-1 ; char path[200]; buf_t buf; char *p,*tok="idx="; mg_stream_t *s=(mg_stream_t*)conn; struct mg_http_message *hm=s->ev_data; GlobalDeviceManager *dm=&__globalDeviceManage; if(strstr(hm->uri.buf, "type=importData")) { //firmware upload sprintf(path, "%s/%s", DOWN_FOLDER, CERT_FILE); r = upload_file(conn, path); if(r==0) { p = strstr(hm->uri.buf, tok); if(p) { idx = atoi(p+strlen(tok)); if(idx<0 || idx>=MQTT_SER_MAX) { printf("_____ wrong idx, %d\n", idx); return; } r = file_load(path, &buf); if(r==0) { mqtt_server_t *ser=&dm->mqttInfo.ser[idx]; if(buf.dlen<=sizeof(ser->cert)) { memcpy(ser->cert, buf.buf, buf.dlen); dev_mqtt_update_ser(dm->db, ser); } else { printf("_____ cert is too long, %d\n", buf.dlen); } free(buf.buf); } } } } } /// @brief 系统管理 /// @param stream static void systemManagent(void *conn) { int ret = -1 ; cJSON *cjson; _UserRoleManageInfo _UserRoleManageRequestInfo; char* ack_str = NULL ; mg_stream_t *s=(mg_stream_t*)conn; struct mg_http_message *hm=s->ev_data; char *rx_body_buf = (char*)hm->body.buf; //转换json参数 cjson = json_to_user_manage(rx_body_buf,&_UserRoleManageRequestInfo); if(cjson==NULL) { http_reply(conn, 400, NULL); return ; } //获取角色信息 else if(strcmp(_UserRoleManageRequestInfo.type,"getUser")==0) { // 查询用户信息 UserInfo User_list; INIT_LIST_HEAD(&User_list.list); // 查询角色信息 RoleInfo Role_list; INIT_LIST_HEAD(&Role_list.list); ack_str = ctrl_sts_ack_to_json(); if (0 == dev_get_user_info(__globalDeviceManage.db, &User_list) && 0 == dev_get_role_info(__globalDeviceManage.db, &Role_list) /*&& strcmp(_UserRoleManageRequestInfo.userName,"")!=0*/) { char *nName=getUserNamebyToken(_UserRoleManageRequestInfo.user_token); if (nName!=NULL) { ack_str = service_userRole_ack_to_json(nName,&User_list, &Role_list); } } UserInfo *node; UserInfo *next; list_for_each_entry_safe(node, next, &User_list.list, list) { list_del(&node->list); free(node); } RoleInfo *node1; RoleInfo *next1; list_for_each_entry_safe(node1, next1, &Role_list.list, list) { list_del(&node1->list); free(node1); } } //查询用户列表 else if(strcmp(_UserRoleManageRequestInfo.type,"listUserQuery")==0) { // 查询用户信息 UserInfo User_list; INIT_LIST_HEAD(&User_list.list); // 查询角色信息 RoleInfo Role_list; INIT_LIST_HEAD(&Role_list.list); ack_str = ctrl_sts_ack_to_json(); if (0 == dev_get_user_info(__globalDeviceManage.db, &User_list) && 0 == dev_get_role_info(__globalDeviceManage.db, &Role_list) /*&& strcmp(_UserRoleManageRequestInfo.userName,"")!=0*/) { char *nName = getUserNamebyToken(_UserRoleManageRequestInfo.user_token); if (nName != NULL) { ack_str = service_userQuery_ack_to_json(nName, &User_list, &Role_list,_UserRoleManageRequestInfo.userName,_UserRoleManageRequestInfo.pagenum,_UserRoleManageRequestInfo.pagesize); } } UserInfo *node; UserInfo *next; list_for_each_entry_safe(node, next, &User_list.list, list) { list_del(&node->list); free(node); } RoleInfo *node1; RoleInfo *next1; list_for_each_entry_safe(node1, next1, &Role_list.list, list) { list_del(&node1->list); free(node1); } } //删除用户 else if(strcmp(_UserRoleManageRequestInfo.type,"deleteUser")==0) { bool CurUserFlag=false; char *nName = getUserNamebyToken(_UserRoleManageRequestInfo.user_token); if (nName != NULL) { UserInfo User_list; INIT_LIST_HEAD(&User_list.list); if (0 == dev_get_user_info(__globalDeviceManage.db, &User_list)) { UserInfo *_UserInfoTemp = NULL; list_for_each_entry(_UserInfoTemp, &User_list.list, list) { if (strcmp(_UserInfoTemp->userName, nName) == 0) { if (_UserRoleManageRequestInfo.userIds == _UserInfoTemp->userID) { CurUserFlag = true; break; } break; } } } UserInfo *node; UserInfo *next; list_for_each_entry_safe(node, next, &User_list.list, list) { list_del(&node->list); free(node); } } if (!CurUserFlag) { // char *pUserlist; // char *pUserListSave; // pUserlist = strtok_r(_UserRoleManageRequestInfo.userIds, ",", &pUserListSave); // while (pUserlist != NULL) //{ dev_delete_user_info(__globalDeviceManage.db, _UserRoleManageRequestInfo.userIds); // pUserlist = strtok_r(NULL, ",", &pUserListSave); // } char temp[100]; // sprintf(temp, "$删除$|$用户$|%d", _UserRoleManageRequestInfo.userIds); sprintf(temp, "Delete user %d", _UserRoleManageRequestInfo.userIds); dev_insert_alarm_ctrl(__globalDeviceManage.db, __globalDeviceManage._globalDevInfo.product.id, ALARM_TYPE_OPRATION, temp); ack_str = ctrl_sts_ack_to_json(); } else { ack_str = ctrl_breaker_err_ack_to_json("Can't delete logged in users!!!!"); } } //添加用户 else if(strcmp(_UserRoleManageRequestInfo.type,"addUser")==0) { //未析构 UserInfo *new_user = (UserInfo *)malloc(sizeof(UserInfo)); memset(new_user,0,sizeof(UserInfo)); new_user->product_id = __globalDeviceManage._globalDevInfo.product.id; int nMaxUserNum=1; bool existFlag=false; UserInfo User_list; INIT_LIST_HEAD(&User_list.list); // 查询角色信息 RoleInfo Role_list; INIT_LIST_HEAD(&Role_list.list); if (0 == dev_get_user_info(__globalDeviceManage.db, &User_list) && 0 == dev_get_role_info(__globalDeviceManage.db, &Role_list)) { UserInfo *_UserInfoTemp = NULL; list_for_each_entry(_UserInfoTemp, &User_list.list, list) { if (_UserInfoTemp == NULL) break; if (_UserInfoTemp->userID >= nMaxUserNum) { nMaxUserNum=_UserInfoTemp->userID; } if (strcmp(_UserInfoTemp->userName, _UserRoleManageRequestInfo.userName) == 0) { existFlag = true; break; } } if (existFlag) { ack_str = ctrl_breaker_err_ack_to_json("User already exists!"); } else { new_user->userID = nMaxUserNum + 1; strcpy(new_user->userName, _UserRoleManageRequestInfo.userName); strcpy(new_user->userPW, _UserRoleManageRequestInfo.password); strcpy(new_user->nickName, _UserRoleManageRequestInfo.nickName); new_user->roleID = _UserRoleManageRequestInfo.roleId; // GetRoleIDByName(_UserRoleManageRequestInfo.roleName,&Role_list); struct tm *t; struct timeval tv; gettimeofday(&tv, NULL); t = localtime(&tv.tv_sec); sprintf(new_user->createTime, "%04d-%02d-%02d %02d:%02d:%02d", t->tm_year + 1900, t->tm_mon + 1, t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec); dev_insert_user_info(__globalDeviceManage.db, new_user); char temp[100]; // sprintf(temp, "$添加$|$用户$|%s", _UserRoleManageRequestInfo.userName); sprintf(temp, "Add user %s", _UserRoleManageRequestInfo.userName); dev_insert_alarm_ctrl(__globalDeviceManage.db, __globalDeviceManage._globalDevInfo.product.id, ALARM_TYPE_OPRATION, temp); ack_str=ctrl_sts_ack_to_json(); } } free(new_user); UserInfo *node; UserInfo *next; list_for_each_entry_safe(node, next, &User_list.list, list) { list_del(&node->list); free(node); } RoleInfo *node1; RoleInfo *next1; list_for_each_entry_safe(node1, next1, &Role_list.list, list) { list_del(&node1->list); free(node1); } } //更新用户信息 else if(strcmp(_UserRoleManageRequestInfo.type,"updateUser")==0) { //未析构 UserInfo *new_user = (UserInfo *)malloc(sizeof(UserInfo)); memset(new_user,0,sizeof(UserInfo)); new_user->product_id = __globalDeviceManage._globalDevInfo.product.id; new_user->userID = _UserRoleManageRequestInfo.userId; strcpy(new_user->userName , _UserRoleManageRequestInfo.userName); strcpy(new_user->userPW , _UserRoleManageRequestInfo.password); strcpy(new_user->nickName , _UserRoleManageRequestInfo.nickName); new_user->roleID = _UserRoleManageRequestInfo.roleId; strcpy(new_user->createTime , _UserRoleManageRequestInfo.createTime); dev_update_user_info(__globalDeviceManage.db, new_user); free(new_user); char temp[100]; //sprintf(temp, "$修改$|$用户$|%s", _UserRoleManageRequestInfo.userName); sprintf(temp, "Update user %s", _UserRoleManageRequestInfo.userName); dev_insert_alarm_ctrl(__globalDeviceManage.db, __globalDeviceManage._globalDevInfo.product.id, ALARM_TYPE_OPRATION, temp); ack_str=ctrl_sts_ack_to_json(); } cJSON_Delete(cjson); http_reply(conn, 200, ack_str); cJSON_free((void*)ack_str); } /// @brief 设备重启 /// @param stream static void equipmentMintenance(void *conn) { int ret = -1 ; char* ack_str = NULL ; cJSON *cjson; _OverBackStsInfo _over_back_sts_info; //设备总体状态信息 _Equipment_Mintenance _Over_equipment_mintenance; mg_stream_t *s=(mg_stream_t*)conn; struct mg_http_message *hm=s->ev_data; char *rx_body_buf = (char*)hm->body.buf; //转换json参数 cjson = json_to_over_equipment_mintenance(rx_body_buf,&_Over_equipment_mintenance); if(cjson==NULL) { http_reply(conn, 400, NULL); return ; } //查询设备列表 if(strcmp(_Over_equipment_mintenance.type,"listSbRestartQuery")==0 || strcmp(_Over_equipment_mintenance.type,"listSbWhQuery")==0) { _over_back_sts_info.product_name = __globalDeviceManage._globalDevInfo.product.name; _over_back_sts_info.product_number = __globalDeviceManage._globalDevInfo.product.number; _over_back_sts_info.product_id = __globalDeviceManage._globalDevInfo.product.id; _over_back_sts_info.product_Code = __globalDeviceManage._globalDevInfo.product.pnumber; // _over_back_sts_info.product_type = malloc(32); //strcpy(_over_back_sts_info.product_type, "GC Series"); _over_back_sts_info.product_type=g_product_type_str[__globalDeviceManage._globalDevInfo.product.type]; _over_back_sts_info.productVersion = __globalDeviceManage._globalDevInfo.product.version; _over_back_sts_info.product_sysTime = malloc(32); struct tm *t; struct timeval tv; gettimeofday(&tv, NULL); t = localtime(&tv.tv_sec); sprintf(_over_back_sts_info.product_sysTime, "%04d-%02d-%02d %02d:%02d:%02d", t->tm_year + 1900, t->tm_mon + 1, t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec); long diff =0; struct timespec ts; if (clock_gettime(CLOCK_MONOTONIC, &ts) == 0) { diff = ts.tv_sec; } _over_back_sts_info.product_runTime = malloc(32); sprintf(_over_back_sts_info.product_runTime, "%02ld:%02ld:%02ld", diff / 3600, (diff % 3600) / 60, diff % 60); _over_back_sts_info.productAddr = getLocalIpAddress("eth0"); _over_back_sts_info.product_mac = get_mac_address("eth0"); _over_back_sts_info.product_RS485Addr = __globalDeviceManage._globalDevInfo.cascade.addr; //_over_back_sts_info.product_status = __globalDeviceManage._globalDevInfo.product.status; _over_back_sts_info.product_status = malloc(16); strcpy(_over_back_sts_info.product_status, "online"); _over_back_sts_info.product_type_id = __globalDeviceManage._globalDevInfo.product.pwr_type; if (strcmp(_Over_equipment_mintenance.type, "listSbWhQuery") == 0) { ack_str = over_product_list_info_to_json(&__globalDeviceManage, &_over_back_sts_info, true); } else ack_str = over_product_list_info_to_json(&__globalDeviceManage, &_over_back_sts_info, false); } else if(strcmp(_Over_equipment_mintenance.type,"listShfwQuery")==0) { GlobalDeviceInfo *dev=&__globalDeviceManage._globalDevInfo; ack_str = vendor_info_to_json(dev); } else if(strcmp(_Over_equipment_mintenance.type,"sBRestart")==0) { //restart char temp[100]; //sprintf(temp, "$系统$|$重启$"); sprintf(temp, "System Reboot!"); dev_insert_alarm_ctrl(__globalDeviceManage.db, __globalDeviceManage._globalDevInfo.product.id, ALARM_TYPE_OPRATION, temp); sys_reboot(); }else if(strcmp(_Over_equipment_mintenance.type,"listKgSbQuery")==0) // part of device infomation { _OverBackBreakerInfo breaker_info; printf("get listKgSbQuery infomation!!!\n"); breaker_info.product_id = __globalDeviceManage._globalDevInfo.product.id; breaker_info.product_name = __globalDeviceManage._globalDevInfo.product.name; breaker_info.product_number = __globalDeviceManage._globalDevInfo.product.number; breaker_info.product_type = __globalDeviceManage._globalDevInfo.product.type; ack_str = over_breaker_product_list_info_to_json(&__globalDeviceManage,&breaker_info,false); }else if(strcmp(_Over_equipment_mintenance.type,"listKgTdQuery")==0) { _OverBreakerChnInfo _over_breaker_chn_info; INIT_LIST_HEAD(&_over_breaker_chn_info.list); //_OverBraekerChnInfo *temp = NULL; GlobalPowerManger * _globalPowerTemp = NULL; int cur_dev_addr = 0; if(_Over_equipment_mintenance.product_id) cur_dev_addr = atoi(_Over_equipment_mintenance.product_id); if(cur_dev_addr) //slave { // }else{ //zhuji printf("get listKgTdQuery infomation!!!\n"); list_for_each_entry(_globalPowerTemp, &__globalDeviceManage._globalPowerManger.list, list) { _OverBreakerChnInfo *temp = (_OverBreakerChnInfo *) malloc(sizeof(_OverBreakerChnInfo)); temp->product_id = __globalDeviceManage._globalDevInfo.product.id; strcpy(temp->product_name,__globalDeviceManage._globalDevInfo.product.name); strcpy(temp->product_number,__globalDeviceManage._globalDevInfo.product.number); strcpy(temp->product_ch_name,_globalPowerTemp->product_ch_name); temp->product_ch_id = _globalPowerTemp->product_ch_id; printf("%s %s %s %d\n",temp->product_name,temp->product_number,temp->product_ch_name,temp->product_ch_id); list_add_tail(&temp->list,&_over_breaker_chn_info.list); } } //参数转换json ack_str = over_all_breaker_chn_info_to_json(&_over_breaker_chn_info,0); //释放资源 _OverBreakerChnInfo* node; _OverBreakerChnInfo* next; list_for_each_entry_safe(node, next, &_over_breaker_chn_info.list, list) { list_del(&node->list); free(node); } }else if(strcmp(_Over_equipment_mintenance.type,"listSwitchtatusQuery") == 0) { _OverBreakerSwitchInfo _over_breaker_switch_info; INIT_LIST_HEAD(&_over_breaker_switch_info.list); if(_Over_equipment_mintenance.product_id) cur_dev_addr = atoi(_Over_equipment_mintenance.product_id); if(cur_dev_addr) //slave { cmd_data_t cmd = {0}; int r=0; cmd.cmd = CASCADE_CMD_BREAKER_GET_INFO; cmd.obj = OBJ_OVERALL; cascade_request(&cmd); // cmd.cmd = CASCADE_CMD_BREAKER_QUERY; // cmd.obj = OBJ_OVERALL; // cascade_request(&cmd); ack_str=ctrl_sts_ack_to_json(); // GlobalBreakerManager *temp = NULL; // GlobalDeviceManager *dm = &__globalDeviceManage2; // lock_s_hold(LOCK_ID_BREAKER); // list_for_each_entry(temp, &dm->g_new_global_breaker.list, list) // { // char buff[120]; // printf("get listSwitchtatusQuery infomation!!!\n"); // _OverBreakerSwitchInfo *info = (_OverBreakerSwitchInfo *) // malloc(sizeof(_OverBreakerSwitchInfo)); // memset(info,0,sizeof(_OverBreakerSwitchInfo)); // info->product_id = temp->product_id; // sprintf(buff,"Breaker %d",temp->breaker_id); // strcpy(info->product_ch_name,buff); // sprintf(buff,"%s %d",__globalDeviceManage._globalDevInfo.product.name,temp->breaker_id); // strcpy(info->productName,buff); // strcpy(info->product_number,__globalDeviceManage._globalDevInfo.product.number); // strcpy(info->productChids,temp->breaker_chns_name); // info->switch_id = temp->breaker_id; // info->status = temp->breaker_status; // strcpy(info->cjfs,temp->breaker_gather_type); // strcpy(info->switch_name,temp->breaker_switch_name); // strcpy(info->comkh,temp->breaker_com); // sprintf(buff,"%d",temp->breaker_gather_addr); // strcpy(info->cjdz,buff); // sprintf(buff,"%d",temp->breaker_chn); // strcpy(info->jdh,buff); // printf("%s %s %s %s %d %d %s %s %s %s\n", // info->product_ch_name,info->productName,info->product_number,info->productChids,info->switch_id, // info->status,info->cjfs,info->comkh,info->cjdz,info->jdh); // list_add_tail(&info->list,&_over_breaker_switch_info.list); // } // lock_s_release(LOCK_ID_BREAKER); // ack_str = over_all_breaker_switch_info_to_json(&_over_breaker_switch_info,0); // _OverBreakerSwitchInfo* node; // _OverBreakerSwitchInfo* next; // list_for_each_entry_safe(node, next, &_over_breaker_switch_info.list, list) // { // list_del(&node->list); // free(node); //} }else //current { GlobalBreakerManager *temp = NULL; lock_s_hold(LOCK_ID_BREAKER); list_for_each_entry(temp, &__globalDeviceManage.g_new_global_breaker.list, list) { char buff[20]; //printf("get listSwitchtatusQuery infomation!!!\n"); _OverBreakerSwitchInfo *info = (_OverBreakerSwitchInfo *) malloc(sizeof(_OverBreakerSwitchInfo)); memset(info,0,sizeof(_OverBreakerSwitchInfo)); info->product_id = temp->product_id; sprintf(buff,"Breaker %d",temp->breaker_id); strcpy(info->product_ch_name,buff); strcpy(info->productName,__globalDeviceManage._globalDevInfo.product.name); strcpy(info->product_number,__globalDeviceManage._globalDevInfo.product.number); strcpy(info->productChids,temp->breaker_chns_name); info->switch_id = temp->breaker_id; info->status = temp->breaker_status; strcpy(info->cjfs,temp->breaker_gather_type); strcpy(info->switch_name,temp->breaker_switch_name); strcpy(info->comkh,temp->breaker_com); sprintf(buff,"%d",temp->breaker_gather_addr); strcpy(info->cjdz,buff); sprintf(buff,"%d",temp->breaker_chn); strcpy(info->jdh,buff); // printf("%s %s %s %s %d %d %s %s %s %s\n", // info->product_ch_name,info->productName,info->product_number,info->productChids,info->switch_id, // info->status,info->cjfs,info->comkh,info->cjdz,info->jdh); list_add_tail(&info->list,&_over_breaker_switch_info.list); } lock_s_release(LOCK_ID_BREAKER); printf("_glos_asdsd addr=0x%x\n",(uint32_t)(&__globalDeviceManage)); ack_str = over_all_breaker_switch_info_to_json(&_over_breaker_switch_info,0); //释放资源 _OverBreakerSwitchInfo* node; _OverBreakerSwitchInfo* next; list_for_each_entry_safe(node, next, &_over_breaker_switch_info.list, list) { list_del(&node->list); free(node); } } }else if(strcmp(_Over_equipment_mintenance.type,"switchSave") == 0) { if(_Over_equipment_mintenance.product_id) cur_dev_addr = atoi(_Over_equipment_mintenance.product_id); if(cur_dev_addr) //slave { cmd_data_t cmd; cmd.datas.data.cjdz = atoi(_Over_equipment_mintenance.cjdz); cmd.datas.data.jdh = atoi(_Over_equipment_mintenance.jdh); strcpy(cmd.datas.data.breaker_chns,_Over_equipment_mintenance.productChids); strcpy(cmd.datas.data.cjfs,_Over_equipment_mintenance.cjfs); strcpy(cmd.datas.data.com,_Over_equipment_mintenance.comkh); cmd.cmd = CASCADE_CMD_BREAKER_SAVE_ADD; cmd.obj = OBJ_OVERALL; cascade_request(&cmd); ack_str=ctrl_sts_ack_to_json(); }else { char buff[124] = {0}; char id[MAX_BREAKER_ID] = {0}; //bianli shujujiegou GlobalBreakerManager *temp = NULL; int i = 1; lock_s_hold(LOCK_ID_BREAKER); list_for_each_entry(temp, &__globalDeviceManage.g_new_global_breaker.list, list) { id[temp->breaker_id] = 1; } lock_s_release(LOCK_ID_BREAKER); for(;i < MAX_BREAKER_ID;i++) { if(id[i] == 0) break; } if(i != MAX_BREAKER_ID) { GlobalBreakerManager *breakerManager = (GlobalBreakerManager*) malloc(sizeof(GlobalBreakerManager)); memset(breakerManager,0,sizeof(GlobalBreakerManager)); breakerManager->product_id = __globalDeviceManage._globalDevInfo.product.id; breakerManager->breaker_gather_addr = atoi(_Over_equipment_mintenance.cjdz); strcpy(breakerManager->breaker_com,_Over_equipment_mintenance.comkh); strcpy(breakerManager->breaker_gather_type,_Over_equipment_mintenance.cjfs); strcpy(breakerManager->breaker_chns_name,_Over_equipment_mintenance.productChids); sprintf(buff,"Breadker_%d",breakerManager->breaker_id); strcpy(breakerManager->breaker_switch_name,buff); breakerManager->breaker_id = i; uint32_t jdh = atoi(_Over_equipment_mintenance.jdh); if(breakerManager->breaker_gather_addr >= BREADER_485_ADDR && breakerManager->breaker_gather_addr <= (BREADER_485_ADDR + BREAKER_BOARD_MAX)) { if(jdh <= MAX_BREAKER_CHN && jdh >0) { char jdh_flag = 0; char chn[MAX_BREAKER_CHN] = {0}; lock_s_hold(LOCK_ID_BREAKER); list_for_each_entry(temp, &__globalDeviceManage.g_new_global_breaker.list, list) { if(temp->breaker_gather_addr == breakerManager->breaker_gather_addr) { chn[temp->breaker_chn-1] = 1; } } lock_s_release(LOCK_ID_BREAKER); if(chn[jdh-1] != 1) { breakerManager->breaker_chn = jdh; }else { jdh_flag = 1; } if(jdh_flag == 1) { free(breakerManager); breakerManager = NULL; ack_str = ctrl_breaker_err_ack_to_json("channel or id is existing!!!!"); }else{ dev_insert_breaker_genera_manage(__globalDeviceManage.db,breakerManager); lock_s_hold(LOCK_ID_BREAKER); list_add_tail(&breakerManager->list,&__globalDeviceManage.g_new_global_breaker.list); lock_s_release(LOCK_ID_BREAKER); ack_str=ctrl_sts_ack_to_json(); } }else { free(breakerManager); breakerManager = NULL; ack_str = ctrl_breaker_err_ack_to_json("jdh error!!!!"); } }else if(breakerManager->breaker_gather_addr >= 1 && breakerManager->breaker_gather_addr <=30) //controller { if(jdh <= 2 && jdh > 0) { char jdh_flag = 0; char chn[2] = {0}; lock_s_hold(LOCK_ID_BREAKER); list_for_each_entry(temp, &__globalDeviceManage.g_new_global_breaker.list, list) { if(temp->breaker_gather_addr == breakerManager->breaker_gather_addr) { chn[temp->breaker_chn-1] = 1; } } lock_s_release(LOCK_ID_BREAKER); if(chn[jdh-1] != 1) { breakerManager->breaker_chn = jdh; }else { jdh_flag = 1; } if(jdh_flag == 1) { free(breakerManager); breakerManager = NULL; ack_str = ctrl_breaker_err_ack_to_json("channel or id is existing!!!!"); }else{ dev_insert_breaker_genera_manage(__globalDeviceManage.db,breakerManager); lock_s_hold(LOCK_ID_BREAKER); list_add_tail(&breakerManager->list,&__globalDeviceManage.g_new_global_breaker.list); lock_s_release(LOCK_ID_BREAKER); ack_str=ctrl_sts_ack_to_json(); } }else { free(breakerManager); breakerManager = NULL; ack_str = ctrl_breaker_err_ack_to_json("jdh error!!!!"); } }else if(breakerManager->breaker_gather_addr == 0) //current support one breaker { if(jdh == 1) { char jdh_flag = 0; lock_s_hold(LOCK_ID_BREAKER); list_for_each_entry(temp, &__globalDeviceManage.g_new_global_breaker.list, list) { if(temp->breaker_gather_addr == breakerManager->breaker_gather_addr) { jdh_flag = 1; } } lock_s_release(LOCK_ID_BREAKER); if(jdh_flag == 1) { free(breakerManager); breakerManager = NULL; ack_str = ctrl_breaker_err_ack_to_json("channel or id is existing!!!!"); }else{ breakerManager->breaker_chn = jdh; dev_insert_breaker_genera_manage(__globalDeviceManage.db,breakerManager); lock_s_hold(LOCK_ID_BREAKER); list_add_tail(&breakerManager->list,&__globalDeviceManage.g_new_global_breaker.list); lock_s_release(LOCK_ID_BREAKER); ack_str=ctrl_sts_ack_to_json(); } }else { free(breakerManager); breakerManager = NULL; ack_str = ctrl_breaker_err_ack_to_json("jdh error!!!!"); } }else { free(breakerManager); breakerManager = NULL; ack_str = ctrl_breaker_err_ack_to_json("not surpport base addr !!"); } }else { ack_str = ctrl_breaker_err_ack_to_json("ID More 48 !!!!"); } } }else if(strcmp(_Over_equipment_mintenance.type,"switchUpdate") == 0) { if(_Over_equipment_mintenance.product_id) cur_dev_addr = atoi(_Over_equipment_mintenance.product_id); if(cur_dev_addr) ///slave { cmd_data_t cmd; cmd.datas.data1.switch_id = _Over_equipment_mintenance.switchId; strcpy(cmd.datas.data1.breaker_chns,_Over_equipment_mintenance.productChids); strcpy(cmd.datas.data1.switch_name,_Over_equipment_mintenance.switchName); cmd.cmd = CASCADE_CMD_BREAKER_SAVE_UPDATE; cmd.obj = OBJ_OVERALL; cascade_request(&cmd); ack_str=ctrl_sts_ack_to_json(); }else { GlobalBreakerManager *temp = NULL; int switch_id = _Over_equipment_mintenance.switchId; lock_s_hold(LOCK_ID_BREAKER); list_for_each_entry(temp, &__globalDeviceManage.g_new_global_breaker.list, list) { if(temp->breaker_id == switch_id) { strcpy(temp->breaker_switch_name,_Over_equipment_mintenance.switchName); strcpy(temp->breaker_chns_name,_Over_equipment_mintenance.productChids); dev_update_breaker_genera_manage(__globalDeviceManage.db, __globalDeviceManage._globalDevInfo.product.id,switch_id,temp); break; } } lock_s_release(LOCK_ID_BREAKER); ack_str=ctrl_sts_ack_to_json(); } }else if(strcmp(_Over_equipment_mintenance.type,"switchDelete") == 0) { if(_Over_equipment_mintenance.product_id) cur_dev_addr = atoi(_Over_equipment_mintenance.product_id); if(cur_dev_addr) ///slave { cmd_data_t cmd; cmd.datas.data2.switch_id = _Over_equipment_mintenance.switchId; cmd.cmd = CASCADE_CMD_BREAKER_SAVE_DELETE; cmd.obj = OBJ_OVERALL; cascade_request(&cmd); GlobalBreakerManager* node = NULL; GlobalBreakerManager* next = NULL; lock_s_hold(LOCK_ID_BREAKER); list_for_each_entry_safe(node,next,&__globalDeviceManage2.g_new_global_breaker.list, list) { if(node->breaker_id == _Over_equipment_mintenance.switchId) { // dev_delete_breaker_manage(__globalDeviceManage2.db,__globalDeviceManage._globalDevInfo.product.id, // _Over_equipment_mintenance.switchId); list_del(&node->list); free(node); break; } } lock_s_release(LOCK_ID_BREAKER); ack_str=ctrl_sts_ack_to_json(); }else { int switch_id = _Over_equipment_mintenance.switchId; //GlobalBreakerManager *temp = NULL; GlobalBreakerManager* node; GlobalBreakerManager* next; lock_s_hold(LOCK_ID_BREAKER); list_for_each_entry_safe(node,next,&__globalDeviceManage.g_new_global_breaker.list, list) { if(node->breaker_id == switch_id) { dev_delete_breaker_manage(__globalDeviceManage.db,__globalDeviceManage._globalDevInfo.product.id,switch_id); list_del(&node->list); free(node); node = NULL; break; } } lock_s_release(LOCK_ID_BREAKER); ack_str=ctrl_sts_ack_to_json(); } } else if(strcmp(_Over_equipment_mintenance.type,"restoreFactorySettings")==0) { //restore to factory char temp[100]; GlobalDeviceManager *dm=&__globalDeviceManage; PowerTotal_t *ptotal=&dm->_globalDevInfo.ptotal; //sprintf(temp, "$系统$|$恢复出厂设置$"); sprintf(temp, "System Reset!"); dev_insert_alarm_ctrl(dm->db, dm->_globalDevInfo.product.id, ALARM_TYPE_OPRATION, temp); for (size_t i = 0; i <= ptotal->brdMax; i++) { if (dm->pCtrlBoard[i].product_saddr <= 0) { continue; } g_switch_get_all_reset(&dm->_globalRelaySampManger,dm->pCtrlBoard[i].product_type,__globalDeviceManage.pCtrlBoard[i].product_saddr); } sys_set_factory(); } else if (strcmp(_Over_equipment_mintenance.type,"resetChannel") == 0) { http_reply(conn, 200, ack_str); //__globalDeviceManage._ReloadChm_flag=true; lock_s_hold(LOCK_ID_POWER_UPDATE); ResetChmData(1); lock_s_release(LOCK_ID_POWER_UPDATE); char log_buff[256]; sprintf(log_buff, "Rescan channel!"); dev_insert_alarm_ctrl(__globalDeviceManage.db, __globalDeviceManage._globalDevInfo.product.id, ALARM_TYPE_OPRATION, log_buff); //__globalDeviceManage._ReloadChm_flag=false; upg_board_all_update(); } else if (strcmp(_Over_equipment_mintenance.type,"cleanUp") == 0) { if (_Over_equipment_mintenance.cleanSelectItem!=NULL) { char *pItemlist; char *pItemListSave; pItemlist = strtok_r(_Over_equipment_mintenance.cleanSelectItem, ",", &pItemListSave); while (pItemlist != NULL) { int ItemID=atoi(pItemlist) ; if (1==ItemID) { log_i("CleanUp all power history Information!\n"); dev_delete_ac_power_info_all(__globalDeviceManage.db); dev_delete_power_info_all(__globalDeviceManage.db); } else if (2==ItemID) { log_i("CleanUp all sensor history Information!\n"); dev_delete_sensor_info_all(__globalDeviceManage.db); } else if (3==ItemID) { log_i("CleanUp all alarm log Information!\n"); dev_delete_alarm_info_all(__globalDeviceManage.db,ALARM_TYPE_POWER); dev_delete_alarm_info_all(__globalDeviceManage.db,ALARM_TYPE_SENSOR); dev_delete_alarm_info_all(__globalDeviceManage.db,ALARM_TYPE_NETWORK); } else if (4==ItemID) { log_i("CleanUp all operation log Information!\n"); dev_delete_alarm_info_all(__globalDeviceManage.db,ALARM_TYPE_OPRATION); } else if (5==ItemID) { log_i("CleanUp all system log Information!\n"); dev_delete_alarm_info_all(__globalDeviceManage.db,ALARM_TYPE_RUNNING); } pItemlist = strtok_r(NULL, ",", &pItemListSave); } } dev_sql_VACCUM(__globalDeviceManage.db); log_i("Database SQLite VACCUM!\n"); ack_str=ctrl_sts_ack_to_json(); } else if (strcmp(_Over_equipment_mintenance.type,"listRtHisQuery") == 0) { ack_str = upgrade_to_json(); } cJSON_Delete(cjson); http_reply(conn, 200, ack_str); cJSON_free((void*)ack_str); } static void equipmentMintenanceUpload(void *conn) { int r = -1 ; char* ack_str=NULL ; mg_stream_t *s=(mg_stream_t*)conn; struct mg_http_message *hm=s->ev_data; char path[200],tmp[60]; if(strstr(hm->uri.buf, "uploadType=gjsj")) { //firmware upload file_io(conn, FILE_HOST_FW, FILE_IMPORT, NULL); } else if(strstr(hm->uri.buf, "uploadType=shfw")) { //logo upload file_io(conn, FILE_LOGO, FILE_IMPORT, NULL); } else if(strstr(hm->uri.buf, "uploadType=0")) { file_io(conn, FILE_ALARM_CFG, FILE_IMPORT, NULL); } else if(strstr(hm->uri.buf, "uploadType=1")) { file_io(conn, FILE_SERV_CFG, FILE_IMPORT, NULL); } else if(strstr(hm->uri.buf, "uploadType=2")) { file_io(conn, FILE_SENSOR_CFG, FILE_IMPORT, NULL); } else if(strstr(hm->uri.buf, "uploadType=3")) { file_io(conn, FILE_SYS_CFG, FILE_IMPORT, NULL); } ack_str = ctrl_sts_ack_to_json(); http_reply(conn, 200, ack_str); cJSON_free(ack_str); } static void equipmentMintenanceExport(void *conn) { int r = -1 ; char* ack_str=NULL ; mg_stream_t *s=(mg_stream_t*)conn; struct mg_http_message *hm=s->ev_data; if(strstr(hm->uri.buf, "export=0")) { file_io(conn, FILE_ALARM_CFG, FILE_EXPORT, NULL); } else if(strstr(hm->uri.buf, "export=1")) { file_io(conn, FILE_SERV_CFG, FILE_EXPORT, NULL); } else if(strstr(hm->uri.buf, "export=2")) { file_io(conn, FILE_SENSOR_CFG, FILE_EXPORT, NULL); } else if(strstr(hm->uri.buf, "export=3")) { file_io(conn, FILE_SYS_CFG, FILE_EXPORT, NULL); } } static void controlBoardUpgrade(void *conn) { int r = -1 ; char* ack_str=NULL ; mg_stream_t *s=(mg_stream_t*)conn; struct mg_http_message *hm=s->ev_data; if(strstr(hm->uri.buf, "listCbQuery")) { handle_t l=upg_board_all_get(); ack_str = board_to_json(l, 0); http_reply(conn, 200, ack_str); cJSON_free(ack_str); } } static void controlBoardUpgradeUpload(void *conn) { int r=-1,code; char* ack_str=NULL ; mg_stream_t *s=(mg_stream_t*)conn; struct mg_http_message *hm=s->ev_data; if(strstr(hm->uri.buf, "type=importData")) { char path[100]; sprintf(path, "%s/%s", DOWN_FOLDER, "fw.upg"); r = upload_file(conn, path); if(r==0) { upg_board_list_set(hm->uri.buf); printf("_____ board upgrade now ...\n"); r = upg_board_file_check(path); if(r!=UPG_OK) { ack_str = upg_chk_to_json(r); http_reply(conn, 200, ack_str); cJSON_free(ack_str); } else { upg_board_start(path); } } } } static int webSetCallback(void) { httpAddCallback("/login", loginFunc);//登录 httpAddCallback("/logout", loginOutFunc);//登出 httpAddCallback("/getInfo", getUserInfo);//获取用户信息 httpAddCallback("/pdu/changeLanguages", changeLanguages);//切换语言 httpAddCallback("/pdu/systemConfiguration", systemConfiguration);//登录 httpAddCallback("/getRouters", getUserRouters);//获取菜单接口 httpAddCallback("/pdu/overallStatusMonitoring", overallStatusMonitoring);//设备电源监控信息 httpAddCallback("/pdu/channelStatusMonitoring", channelStatusMonitoring);//设备通道电源监控信息 httpAddCallback("/pdu/sensorStatusMonitoring", sensorStatusMonitoring);//传感器总体请求信息 httpAddCallback("/pdu/alarmProtect", alarmProtect);//告警历史信息 httpAddCallback("/pdu/logInformation", logInformation);//日志 httpAddCallback("/pdu/communicationManagement", communicationManagement);//通信设置 httpAddCallback("/pdu/serviceManagement", serviceManagement);//服务管理 httpAddCallback("/pdu/serviceManagementUpload", serviceManagementUpload);//服务管理 httpAddCallback("/pdu/system", systemManagent);//用户管理 httpAddCallback("/pdu/equipmentMintenance", equipmentMintenance);//设备维护 httpAddCallback("/pdu/equipmentMintenanceUpload", equipmentMintenanceUpload); //固件升级 httpAddCallback("/pdu/equipmentMintenanceExport", equipmentMintenanceExport); httpAddCallback("/pdu/controlBoardUpgradeUpload", controlBoardUpgradeUpload); httpAddCallback("/pdu/controlBoardUpgrade", controlBoardUpgrade); return 0; } int appweb_init(void) { thread_start(THREAD_ID_WEB, web_thread, &__globalDeviceManage); return 0; }