From c81f5796927e36c2205c42ee38439de7d362b362 Mon Sep 17 00:00:00 2001 From: zhangsheng Date: Mon, 13 Jan 2025 20:11:40 +0800 Subject: [PATCH] add manger code --- Makefile | 2 +- common/common_func.cpp | 4 +- common/common_func.hpp | 2 +- jsonparse/cmt_parse.cpp | 244 ++++++++++++++++++++++++++------ jsonparse/communication_cmd.hpp | 9 +- jsonparse/web_cmd_parse3.cpp | 8 ++ localserver/cmt_cmd.cpp | 70 ++++++--- localserver/cmt_protocol.h | 134 ++++++++++++++---- localserver/local_server.hpp | 8 +- utility/tcp_cgi.cpp | 68 +++++---- 10 files changed, 427 insertions(+), 122 deletions(-) diff --git a/Makefile b/Makefile index dbcadc6..23ab0d4 100644 --- a/Makefile +++ b/Makefile @@ -20,7 +20,7 @@ LIBS = -L../Tools/renesas_thirdparty/lib \ -L../Tools/renesas_thirdparty/lib \ -lsqlite3 -lboost_system -lpthread -lboost_thread -lboost_date_time -lboost_filesystem -lfftw3 -ljsoncpp -lmosquitto -lcurl -lzlog -CFLAGS = -O0 -fpermissive #-Wall -Werror +CFLAGS = -O0 -fpermissive -fstack-protector-all #-Wall -Werror LINKFLAGS = AllDirs :=$(shell ls -R | grep '^\./.*:' | awk '{if( \ diff --git a/common/common_func.cpp b/common/common_func.cpp index 56c7024..2d46fbc 100644 --- a/common/common_func.cpp +++ b/common/common_func.cpp @@ -1118,7 +1118,7 @@ std::string GetSysStatus(Json::Value &jsData) { std::string strJson = fw.write(jsData); return strJson; } -int GetSysStatusCMT(int cpu_use,int mem_use,int harddisk_remain,int cpu_temp) +int GetSysStatusCMT(int& cpu_use,int& mem_use,int& disk_remain,int& cpu_temp) { long mem_used = -1; long mem_free = -1; @@ -1167,7 +1167,7 @@ int GetSysStatusCMT(int cpu_use,int mem_use,int harddisk_remain,int cpu_temp) int temp = getSysIntValue(key); cpu_use = rateUser; mem_use = fMemRate * 100; - harddisk_remain = atof(strhardFree.substr(0, strhardFree.length() - 1).c_str()); + disk_remain = atoi(strhardFree.substr(0, strhardFree.length() - 1).c_str()); cpu_temp = temp / 1000.0; } // 闁诲繐绻愬Λ妤€鐣烽悢鍝モ枖闁跨噦鎷�16闁哄鏅滅粙鎴﹀春濡ゅ啠鍋撳☉娆樻畼妞ゆ垳鐒﹀顏堫敆娴ｇǹ绨ユ繛鎴炴尭閹碱偊顢氶鑺ュ劅闁哄啫鍊归悾閬嶆倵濞戞瑯娈欏┑鈽嗗弮瀹曟劙鏁撻敓锟� diff --git a/common/common_func.hpp b/common/common_func.hpp index cb08b43..97457e2 100644 --- a/common/common_func.hpp +++ b/common/common_func.hpp @@ -380,7 +380,7 @@ void ZoneConfig(std::string zoneid); * @return std::string CPU MEM DISK info */ std::string GetSysStatus(Json::Value &jsData); -int GetSysStatusCMT(int cpu_use,int mem_use,int harddisk_remain,int cpu_temp); +int GetSysStatusCMT(int& cpu_use,int& mem_use,int& disk_remain,int& cpu_temp); bool CheckIP(const char* ip); bool IsValidMask(std::string mask); diff --git a/jsonparse/cmt_parse.cpp b/jsonparse/cmt_parse.cpp index 508f78e..4a6d3f6 100644 --- a/jsonparse/cmt_parse.cpp +++ b/jsonparse/cmt_parse.cpp @@ -6,20 +6,22 @@ #include "dbaccess/sql_db.hpp" #include "scheduler/schedule.hpp" #include "zlog.h" +#include extern zlog_category_t *zct; -char *JsonData::CmtCmd_80(int& return_length) +void JsonData::CmtCmd_80(char* send_data,int& send_length) { zlog_info(zct,"CmtCmd_80"); GatewayVersion gateway_ver; + gateway_ver.version = 1; memcpy(gateway_ver.mac,GlobalConfig::MacAddr_G.c_str(),sizeof(gateway_ver.mac)); memcpy(gateway_ver.web_ver,ReadStrByOpt(SYSTEMINFOFILE, "Version", "WebVersion").c_str(),sizeof(gateway_ver.web_ver)); memcpy(gateway_ver.system_ver,ReadStrByOpt(SYSTEMINFOFILE, "Version", "SystemVersion").c_str(),sizeof(gateway_ver.system_ver)); memcpy(gateway_ver.gateway_ver,ReadStrByOpt(SYSTEMINFOFILE, "Version", "GateWayVersion").c_str(),sizeof(gateway_ver.gateway_ver)); - memcpy(gateway_ver.localIP,GlobalConfig::IpAddr_G.c_str(),sizeof(gateway_ver.localIP)); + memcpy(gateway_ver.ip,GlobalConfig::IpAddr_G.c_str(),sizeof(gateway_ver.ip)); memcpy(gateway_ver.gateway_type,ReadStrByOpt(SYSTEMINFOFILE, "Version", "GateWayProduct").c_str(),sizeof(gateway_ver.gateway_type)); - memcpy(gateway_ver.geteway_hw_ver,ReadStrByOpt(SYSTEMINFOFILE, "Version", "GateWayHwVesion").c_str(),sizeof(gateway_ver.geteway_hw_ver)); + memcpy(gateway_ver.gateway_hw_ver,ReadStrByOpt(SYSTEMINFOFILE, "Version", "GateWayHwVesion").c_str(),sizeof(gateway_ver.gateway_hw_ver)); #ifdef NR5G_MODULE memcpy(gateway_ver.comm_mode,"5G",sizeof(gateway_ver.comm_mode)); #endif @@ -30,15 +32,12 @@ char *JsonData::CmtCmd_80(int& return_length) memcpy(gateway_ver.comm_mode,"WiFi",sizeof(gateway_ver.comm_mode)); #endif memcpy(gateway_ver.comm_mode,"有线",sizeof(gateway_ver.comm_mode)); - GetSysStatusCMT(gateway_ver.cpu_use,gateway_ver.memory_use,gateway_ver.harddisk_remain,gateway_ver.temperature); - char *retData = NULL; - retData = (char*)malloc(sizeof(GatewayVersion)); - memcpy(retData,&gateway_ver,sizeof(GatewayVersion)); - return_length = sizeof(GatewayVersion); - return retData; + GetSysStatusCMT(gateway_ver.cpu_use,gateway_ver.memory_use,gateway_ver.disk_remain,gateway_ver.temperature); + memcpy(send_data,&gateway_ver,sizeof(GatewayVersion)); + send_length = sizeof(GatewayVersion); } -char *JsonData::CmtCmd_81(int& return_length) +void JsonData::CmtCmd_81(char* send_data,int& send_length) { int featureInterVal; int featureInterTime; @@ -46,7 +45,6 @@ char *JsonData::CmtCmd_81(int& return_length) int waveInterTime; int maxSensorNum; int sensorCount; - char *retData = NULL; array_t arrRes; arrRes = sqlite_db_ctrl::instance().GetDataMultiLineTransaction(T_SENSOR_INFO(TNAME), "*", NULL); int iResult = arrRes.size(); @@ -55,26 +53,25 @@ char *JsonData::CmtCmd_81(int& return_length) SensorInfo sensor_info[iResult]; for (; j < iResult; j++) { - memcpy(sensor_info[j].mac,arrRes[j][44].c_str(),sizeof(sensor_info[j].mac)); - memcpy(sensor_info[j].short_addr,arrRes[j][30].c_str(),sizeof(sensor_info[j].short_addr)); + memcpy(sensor_info[j].measurement_id,arrRes[j][44].c_str(),sizeof(sensor_info[j].measurement_id)); + sensor_info[j].short_addr = atoi(arrRes[j][30].c_str()); memcpy(sensor_info[j].hw_ver,arrRes[j][8].c_str(),sizeof(sensor_info[j].hw_ver)); memcpy(sensor_info[j].soft_ver,arrRes[j][9].c_str(),sizeof(sensor_info[j].soft_ver)); std::vector vParamRSSI; boost::split(vParamRSSI, arrRes[j][40], boost::is_any_of(","), boost::token_compress_on); if (vParamRSSI.size() > 1) { - memcpy(sensor_info[j].sensor_rssi,vParamRSSI[0].c_str(),sizeof(sensor_info[j].sensor_rssi)); - memcpy(sensor_info[j].gateway_rssi,vParamRSSI[1].c_str(),sizeof(sensor_info[j].gateway_rssi)); + sensor_info[j].gateway_rssi = (atof(vParamRSSI[0].c_str())/255) * 100; + sensor_info[j].sensor_rssi = (atof(vParamRSSI[1].c_str())/255) * 100; } else { - memcpy(sensor_info[j].sensor_rssi,vParamRSSI[0].c_str(),sizeof(sensor_info[j].sensor_rssi)); - memcpy(sensor_info[j].gateway_rssi,"80",sizeof(sensor_info[j].gateway_rssi)); + sensor_info[j].gateway_rssi = (atof(vParamRSSI[0].c_str())/255) * 100; + sensor_info[j].sensor_rssi = 99; } std::vector vParambattery; boost::split(vParambattery, arrRes[j][43], boost::is_any_of(","), boost::token_compress_on); if (vParambattery.size() > 1) { - float battery = float(atof(vParambattery[1].c_str())/atof(vParambattery[0].c_str())); - sprintf(sensor_info[j].battry,"%f",battery); + sensor_info[j].battry = (atof(vParambattery[1].c_str())/atof(vParambattery[0].c_str())) * 100; } else { - sprintf(sensor_info[j].battry ,"0.99",sizeof(sensor_info[j].battry)); + sensor_info[j].battry = 99; } std::vector vParam; boost::split(vParam, arrRes[j][42], boost::is_any_of(","), boost::token_compress_on); @@ -97,7 +94,12 @@ char *JsonData::CmtCmd_81(int& return_length) sensor_info[j].temperature_bot = 200; } - memcpy(sensor_info[j].product_no,arrRes[j][17].c_str(),sizeof(sensor_info[j].product_no)); + memcpy(sensor_info[j].product,arrRes[j][17].c_str(),sizeof(sensor_info[j].product)); + if (arrRes[j][17] == "01"){ + memcpy(sensor_info[j].product,"DN101",sizeof(sensor_info[j].product)); + }else if (arrRes[j][17] == "02"){ + memcpy(sensor_info[j].product,"DN102",sizeof(sensor_info[j].product)); + } sensor_info[j].status = atoi(arrRes[j][37].c_str()); char szTableName[100] = {0x00}; @@ -128,38 +130,52 @@ char *JsonData::CmtCmd_81(int& return_length) int static_Count = sqlite_db_ctrl::instance().GetTableRows(szTableName,strsql.c_str()); scheduler::instance().GetScheduleConfig(featureInterVal,waveInterVal,featureInterTime,waveInterTime,maxSensorNum); - sensor_info[j].waveX_reportingrate = waveX_Count/(86400/waveInterVal); - sensor_info[j].waveY_reportingrate = waveY_Count/(86400/waveInterVal); - sensor_info[j].waveZ_reportingrate = waveZ_Count/(86400/waveInterVal); - sensor_info[j].eigenvalue_reportingrate = static_Count/(86400/featureInterVal); + zlog_info(zct,"wavex = %d,featureInterVal = %d,waveInterVal",waveX_Count,featureInterVal); + sensor_info[j].wave_x_reporting_rate = (float(waveX_Count)/(86400/(float)waveInterVal)) * 100; + sensor_info[j].wave_y_reporting_rate = (float(waveY_Count)/(86400/(float)waveInterVal)) * 100; + sensor_info[j].wave_z_reporting_rate = (float(waveZ_Count)/(86400/(float)waveInterVal)) * 100; + sensor_info[j].eigen_value_reporting_rate = (float(static_Count)/(86400/(float)featureInterVal)) *100; memset(whereCon,0,sizeof(whereCon)); sprintf(whereCon,"channelID = '%s-Z'",arrRes[j][44].c_str()); std::string integratRMS = sqlite_db_ctrl::instance().GetData(T_DATA_INFO(TNAME), "integratRMS",whereCon); - memcpy(sensor_info[j].integratRMS , integratRMS.c_str(),sizeof(sensor_info[j].integratRMS));; + memcpy(sensor_info[j].velocity_rms , integratRMS.c_str(),sizeof(sensor_info[j].velocity_rms));; sensor_info[j].upgrade_status = 0; - memcpy(sensor_info[j].upgrade_date,"2024-01-08 12:00:00",sizeof(sensor_info[j].upgrade_date)); + memcpy(sensor_info[j].upgrade_time,"2024-01-08 12:00:00",sizeof(sensor_info[j].upgrade_time)); + sensor_info[j].version = 1; } - retData = (char*)malloc(sizeof(SensorInfo) * j); - memcpy(retData,&sensor_info,sizeof(SensorInfo) * j); - return_length = sizeof(SensorInfo) * j; + memcpy(send_data,&sensor_info,sizeof(SensorInfo) * j); + memcpy(send_data + sizeof(SensorInfo) * j,&sensor_info,sizeof(SensorInfo) * j); + memcpy(send_data + sizeof(SensorInfo) * j * 2,&sensor_info,sizeof(SensorInfo) * j); + memcpy(send_data + sizeof(SensorInfo) * j * 3,&sensor_info,sizeof(SensorInfo) * j); + memcpy(send_data + sizeof(SensorInfo) * j * 4,&sensor_info,sizeof(SensorInfo) * j); + send_length = sizeof(SensorInfo) * j * 5; + zlog_info(zct,"sizeof(SensorInfo) = %d",sizeof(SensorInfo)*j); + zlog_info(zct,"send_length = %d",send_length); } - return retData; } -char *JsonData::CmtCmd_82(char* MeasurementID,char* channel,int& return_length) +void JsonData::CmtCmd_82(char* MeasurementID,char* send_data,int& channel,int& send_length) { FILE* pFile = NULL; char* buffer = NULL; - char* retData = NULL; int thisSize = 0; WaveRes wave; char whereCon[32]={0}; sprintf(whereCon,"MeasurementID = '%s'",MeasurementID); vec_t vecRes = sqlite_db_ctrl::instance().GetDataSingleLine(T_SENSOR_INFO(TNAME), "samplingRate,ACCSampleTime",whereCon); - std::string data_file = "/opt/data/" + std::string(MeasurementID) + "-" + std::string(channel); + std::string strChannel = ""; + + if (channel == 1){ + strChannel = "X"; + }else if(channel == 2){ + strChannel = "Y"; + }else if (channel == 3){ + strChannel = "Z"; + } + std::string data_file = "/opt/data/" + std::string(MeasurementID) + "-" + strChannel; zlog_info(zct, "strFileName = %s", data_file.c_str()); pFile = fopen(data_file.c_str(), "rb"); if (pFile != NULL) { @@ -171,12 +187,160 @@ char *JsonData::CmtCmd_82(char* MeasurementID,char* channel,int& return_length) fread(buffer, sizeof(char), thisSize, pFile); fclose(pFile); } - wave.sampling_rate = atoi(vecRes[0].c_str()); + char test_buf[12800 * 4 + 1]={0}; + for (int i = 0; i < 12800; i++) + { + char temp[5]={0}; + sprintf(temp,"%d",i); + memcpy(test_buf + i * 4, temp, 4); + } + + //wave.sampling_rate = atoi(vecRes[0].c_str()); + wave.sampling_rate = 12800; wave.sampling_time = atoi(vecRes[1].c_str()); - return_length = sizeof(WaveRes) + thisSize; - retData = (char*)malloc(return_length); - memcpy(retData,(char*)&wave,sizeof(WaveRes)); - memcpy(retData + sizeof(WaveRes) ,&buffer,thisSize); + wave.version = 1; + send_length = sizeof(WaveRes) + 51200; + memcpy(send_data,(char*)&wave,sizeof(WaveRes)); + memcpy(send_data + sizeof(WaveRes) ,test_buf,51200); free(buffer); - return retData; +} + +void JsonData::CmtCmd_83(char* MeasurementID,char* send_data,int& send_length) +{ + vec_t vecRes; + std::string filename = ""; + char whereCon[128]={0}; + sprintf(whereCon,"MeasurementID = '%s'",MeasurementID); + vecRes = sqlite_db_ctrl::instance().GetDataSingleLine(T_SENSOR_INFO(TNAME), "*", whereCon); + if (vecRes.size() > 0){ + DownloadConfig download_config; + download_config.version = 1; + memcpy(download_config.gw_mac,GlobalConfig::MacAddr_G.c_str(),sizeof(download_config.gw_mac)); + if (vecRes[17] == "01"){ + memcpy(download_config.product,"DN101",sizeof(download_config.product)); + }else if (vecRes[17] == "02"){ + memcpy(download_config.product,"DN102",sizeof(download_config.product)); + } + memcpy(download_config.ip,GlobalConfig::IpAddr_G.c_str(),sizeof(download_config.ip)); + download_config.panid = atoi(vecRes[28].c_str()); + download_config.signal_channle = atoi(vecRes[29].c_str()); + memcpy(download_config.terminal_name,"",sizeof(download_config.terminal_name)); + memcpy(download_config.sn,vecRes[11].c_str(),sizeof(download_config.sn)); + memcpy(download_config.sensor_mac,vecRes[0].c_str(),sizeof(download_config.sensor_mac)); + memcpy(download_config.measurement_id,vecRes[44].c_str(),sizeof(download_config.measurement_id)); + download_config.short_addr = atoi(vecRes[30].c_str()); + memcpy(download_config.sensor_name,vecRes[1].c_str(),sizeof(download_config.sensor_name)); + memcpy(download_config.update_date,vecRes[38].c_str(),sizeof(download_config.update_date)); + std::vector vParamRSSI; + boost::split(vParamRSSI, vecRes[40], boost::is_any_of(","), boost::token_compress_on); + if (vParamRSSI.size() > 1) { + download_config.gateway_rssi = (atof(vParamRSSI[0].c_str())/255) * 100; + download_config.sensor_rssi = (atof(vParamRSSI[1].c_str())/255) * 100; + } else { + download_config.gateway_rssi = (atof(vParamRSSI[0].c_str())/255) * 100; + download_config.sensor_rssi = 99; + } + memcpy(download_config.hw_ver,vecRes[8].c_str(),sizeof(download_config.hw_ver)); + memcpy(download_config.soft_ver,vecRes[9].c_str(),sizeof(download_config.soft_ver)); + download_config.sampling_rate = atoi(vecRes[23].c_str()); + download_config.range = atoi(vecRes[25].c_str()); + download_config.sampling_time = atoi(vecRes[36].c_str()); + download_config.viff = atoi(vecRes[39].c_str()); + download_config.power = atoi(vecRes[33].c_str()); + download_config.retry_time = atoi(vecRes[34].c_str()); + + char localtimestamp[32] = {0}; + GetTimeNet(localtimestamp, 1); + filename = "config_" + std::string(localtimestamp); + std::ofstream csvFile(filename); + if (!csvFile.is_open()) { + std::cerr << "Error: Could not open file " << filename << std::endl; + return; + } + + // 写入 CSV 标题行 + csvFile << "GW MAC,Product,IP,PanID,Signal Channel,Terminal Name,SN,Sensor MAC,Measurement ID," + "Short Addr,Sensor Name,Update Date,Gateway RSSI,Sensor RSSI,HW Ver,Soft Ver,Sampling Rate," + "Range,Sampling Time,VIFF,Power,Retry Time\n"; + csvFile << download_config.gw_mac << ',' << download_config.product << ','<< download_config.ip << ',' << download_config.panid << ',' + << download_config.signal_channle << ','<< download_config.terminal_name << ','<< download_config.sn << ','<< download_config.sensor_mac << ',' + << download_config.measurement_id << ','<< download_config.short_addr << ','<< download_config.sensor_name << ','<< download_config.update_date << ',' + << download_config.gateway_rssi << ','<< download_config.sensor_rssi << ','<< download_config.hw_ver << ','<< download_config.soft_ver << ',' + << download_config.sampling_rate << ','<< download_config.range << ','<< download_config.sampling_time << ','<< download_config.viff << ',' + << download_config.power << ','<< download_config.retry_time ; + csvFile.close(); + std::cout << "CSV file written to " << filename << std::endl; + } + send_length = sizeof(DownloadConfigRes); + DownloadConfigRes download_condfig_res; + memcpy(download_condfig_res.filename,filename.c_str(),sizeof(download_condfig_res)); + memcpy(send_data,(char*)&download_condfig_res,sizeof(DownloadConfigRes)); + zlog_info(zct, "cmd 83 send_length = %d",send_length); + +} + +void JsonData::CmtCmd_84(char* filename) +{ + std::vector vecDataNode; + std::ifstream csv_data(filename, std::ios::in); + int iRet = 0; + if (!csv_data.is_open()) { + zlog_error(zct, "UpdataDataNodeConfig fail to open:%s", filename); + } + std::string line; + std::vector words; + std::string word; + + DataNodeInfo dataNode; + getline(csv_data, line); + + std::istringstream sin; + while (getline(csv_data, line)) { + words.clear(); + sin.clear(); + sin.str(line); + while (getline(sin, word, ',')) { + words.push_back(word); + } + std::string mac = words[1]; + if (mac != GlobalConfig::MacAddr_G) { + iRet = -2; + break; + } + dataNode.ZigbeeLongAddr = words[7]; + dataNode.FeatureInterVal = atoi(words[16].c_str()); + dataNode.WaveInterVal = atoi(words[17].c_str()); + dataNode.SamplingRate = atoi(words[18].c_str()); + dataNode.Range = atoi(words[19].c_str()); + dataNode.ACCSampleTime = atoi(words[20].c_str()); + dataNode.VIntegralFilterFrequency = atoi(words[21].c_str()); + dataNode.ZigbeePower = atoi(words[22].c_str()); + dataNode.ZigbeeRetry = atoi(words[23].c_str()); + vecDataNode.push_back(dataNode); + } + csv_data.close(); + if (vecDataNode.size() == 0) { + zlog_error(zct, "UpdataDataNodeConfig vecDataNode is 0"); + } + + char whereCon[1024] = {0}; + char updateSql[1024] = {0}; + for (size_t i = 0; i < vecDataNode.size(); i++) { + sprintf(updateSql, "featureInterVal='%d',waveInterVal='%d',range='%d',samplingRate='%d',AccSampleTime = '%d',viff ='%d' ,ZigbeePower = '%d',ZigbeeRetry = '%d',UpdateFlag = 0", vecDataNode[i].FeatureInterVal, vecDataNode[i].WaveInterVal, vecDataNode[i].Range, + vecDataNode[i].SamplingRate, vecDataNode[i].ACCSampleTime, vecDataNode[i].VIntegralFilterFrequency, vecDataNode[i].ZigbeePower, vecDataNode[i].ZigbeeRetry); + sprintf(whereCon, "dataNodeNo='%s'", vecDataNode[i].ZigbeeLongAddr.c_str()); + + iRet = sqlite_db_ctrl::instance().UpdateTableData(T_SENSOR_INFO(TNAME), updateSql, whereCon); + if (iRet != 0) { + zlog_error(zct, "UpdataDataNodeConfig UpdateTableData fail"); + } + memset(whereCon, 0x00, sizeof(whereCon)); + memset(updateSql, 0x00, sizeof(updateSql)); + } + +} + +void JsonData::CmtCmd_85(char* filename) +{ + } \ No newline at end of file diff --git a/jsonparse/communication_cmd.hpp b/jsonparse/communication_cmd.hpp index f1907cf..dac5904 100644 --- a/jsonparse/communication_cmd.hpp +++ b/jsonparse/communication_cmd.hpp @@ -78,9 +78,12 @@ public: //CMT tcp - char* CmtCmd_80(int& return_length); - char* CmtCmd_81(int& return_length); - char* CmtCmd_82(char* MeasurementID,char* channel,int& return_length); + void CmtCmd_80(char* send_data,int& return_length); + void CmtCmd_81(char* send_data,int& return_length); + void CmtCmd_82(char* MeasurementID,char* send_data,int& channel,int& return_length); + void CmtCmd_83(char* MeasurementID,char* send_data,int& return_length); + void CmtCmd_84(char* filename); + void CmtCmd_85(char* filename); private: Json::FastWriter show_value_; diff --git a/jsonparse/web_cmd_parse3.cpp b/jsonparse/web_cmd_parse3.cpp index e749ec5..b8648be 100644 --- a/jsonparse/web_cmd_parse3.cpp +++ b/jsonparse/web_cmd_parse3.cpp @@ -614,6 +614,14 @@ std::string JsonData::JsonCmd_Cgi_59(Param_59 ¶m) { Json::Value iTem; iTem.append(arrResult[i][1]); iTem.append(arrResult[i][0]); + int time = 0; + int lost_data_time = atol(arrResult[i][1].c_str()) - atol(arrResult[i][1].c_str()); + if (param.mMode == 1){ + time = abs(lost_data_time/featureInterVal); + }else if(param.mMode == 2){ + time = abs(lost_data_time/waveInterVal); + } + iTem.append(time); valData.append(iTem); } jsonVal["content"] = valData; diff --git a/localserver/cmt_cmd.cpp b/localserver/cmt_cmd.cpp index 62d6613..f24f73f 100644 --- a/localserver/cmt_cmd.cpp +++ b/localserver/cmt_cmd.cpp @@ -6,36 +6,74 @@ extern zlog_category_t *zct; -char* LocalServer::HandleTcp_cmd(const char* recvData,uint8_t& rescmd,int& reslength) +void LocalServer::HandleTcp_cmd(const char* recv_data,char* send_data,uint8_t& rescmd,int& send_length) { zlog_info(zct,"HandleTcp_cmd"); PackgeHead head; - memcpy(&head,recvData,sizeof(PackgeHead)); + memcpy(&head,recv_data,sizeof(PackgeHead)); uint8_t cmd = head.cmd; rescmd = head.cmd; + printf("cmd = %d\n",cmd); JsonData jd; switch (cmd) { - case 1:{ + case 1:{ Search search; + search.version = 1; memcpy(search.mac,GlobalConfig::MacAddr_G.c_str(),sizeof(search.mac)); search.gw_type = kGWTDG102; - reslength = sizeof(Search); - return (char*)&search; - }break; + send_length = sizeof(Search); + printf("send length = %d\n",send_length); + memcpy(send_data,&search,sizeof(Search)); + }break; case kGateWayVersion: { - char* retData = jd.CmtCmd_80(reslength); - return retData; - }break; + jd.CmtCmd_80(send_data,send_length); + // memcpy(send_data,&send_data_,sizeof(send_length)); + // if (send_data_){ + // free(send_data_); + // } + }break; case kSensorInfo:{ - char* retData = jd.CmtCmd_81(reslength); - return retData; - }break; - case kSensorWave: + jd.CmtCmd_81(send_data,send_length); + + }break; + case kSensorWave:{ WaveReq wave_req; - memcpy(&wave_req,recvData + sizeof(PackgeHead),sizeof(WaveReq)); - char* retData = jd.CmtCmd_82(wave_req.mac,wave_req.channel,reslength); - return retData; + memcpy(&wave_req,recv_data + sizeof(PackgeHead),sizeof(WaveReq)); + jd.CmtCmd_82(wave_req.measurement_id,send_data,wave_req.channel,send_length); + + }break; + case KDownloadConfig:{ + DownloadConfigReq download_config; + memcpy(&download_config,recv_data + sizeof(PackgeHead),sizeof(DownloadConfigReq)); + jd.CmtCmd_83(download_config.measurement_id,send_data,send_length); + zlog_info(zct, "CmtCmd_83 = %d",send_length); + }break; + case KUploadConfig:{ + UpgradeSensorReq upgrade_sensor; + memcpy(&upgrade_sensor,recv_data + sizeof(PackgeHead),sizeof(UpgradeSensorReq)); + jd.CmtCmd_84(upgrade_sensor.filename); + + }break; + case KUpgadeGateway:{ + sleep(3); + int iRet = system("/opt/opt.sh"); + zlog_info(zct, "iRet = %d", iRet); + if (iRet == -1) { + zlog_error(zct, "system() error"); + } + }break; + case KUpgradeSensor:{ + + } + break; + case KEigenvalue:{ + + } + break; + case KUpgradeSensorStop:{ + + } break; default: return NULL; diff --git a/localserver/cmt_protocol.h b/localserver/cmt_protocol.h index 71ca89d..56a401e 100644 --- a/localserver/cmt_protocol.h +++ b/localserver/cmt_protocol.h @@ -4,71 +4,151 @@ //1 tcp server可以参考本安有线中的代码，侦听端口10000 //2 定义无线网关与传感器用到的结构 //3 包头为 + +#pragma pack(1) struct PackgeHead{ uint8_t head[3]; // 固定值：0xAA55AA uint8_t cmd; - uint16_t total_pkg_count; - uint16_t current_pkg_id; uint16_t len; char data[0]; }; -#pragma pack(1) - - //网关版本和状态信息cmd 80 struct GatewayVersion{ + int version; // 写1 char web_ver[12]; char system_ver[12]; char gateway_ver[12]; - char localIP[16]; + char ip[16]; char gateway_type[12]; - char geteway_hw_ver[12]; - char comm_mode[12]; + char gateway_hw_ver[12]; + char terminal_name[32]; // 终端名称，如果为空，填写Default int cpu_use; int memory_use; - int harddisk_remain; + int disk_remain; int temperature; + char comm_mode[10]; char mac[20]; }; - +enum SensorStatus{ + OFFLINE = 0, + ONLINE = 1 +}; +enum SensorUpgradeStatus{ + UPGRADE_NORMAL = 0, + UPGRADING = 1, + UPGRADE_SUCCESS = 2, + UPGRADE_FALIED = 3 +}; +enum LooseStatus{ + NORMAL = 0, + LOOSE = 1 +}; //传感器信息cmd 81 struct SensorInfo{ - char mac[20]; - char short_addr[8]; + int version; + char measurement_id[20]; + int short_addr; char hw_ver[12]; char soft_ver[12]; - char gateway_rssi[16]; - char sensor_rssi[16]; - char battry[12]; - int loose_status; + int gateway_rssi; + int sensor_rssi; + int battry; + int loose_status; //参考 LooseStatus int temperature_bot; int temperature_top; - char product_no[4]; - int status; - int eigenvalue_reportingrate; - int waveX_reportingrate; - int waveY_reportingrate; - int waveZ_reportingrate; - char integratRMS[10]; - int upgrade_status; - char upgrade_date[20]; + char product[6]; // DN101；DN102 + int status; // 参考 SensorStatus + int eigen_value_reporting_rate; + int wave_x_reporting_rate; + int wave_y_reporting_rate; + int wave_z_reporting_rate; + char velocity_rms[10]; + int upgrade_status; // 参考 SensorUpgradeStatus + char upgrade_time[20]; }; +enum ChannelType{ + X = 1, + Y = 2, + Z = 3 +}; //波形cmd 82 struct WaveReq{ - char mac[20]; - char channel[2]; + char measurement_id[20]; + int channel;//参考 ChannelType }; struct WaveRes{ + int version; int sampling_rate; int sampling_time; char wave[0]; }; +//下载配置 cmd 83 +struct DownloadConfigReq{ + char measurement_id[20]; +}; +enum Range{ + RANGE_8G = 0, + RANGE_16G = 1, + RANGE_32G = 2, + RANGE_64G = 3, + RANGE_50G = 4 +}; +struct DownloadConfigRes{ + char filename[32]; +}; +struct DownloadConfig{ + int version; + char gw_mac[20]; + char product[6]; // DN101；DN102 + char ip[16]; + int panid; + int signal_channle; + char terminal_name[32]; + char sn[10]; + char sensor_mac[20]; + char measurement_id[20]; + int short_addr; + char sensor_name[64]; + char update_date[20]; + int gateway_rssi; + int sensor_rssi; + char hw_ver[12]; + char soft_ver[12]; + int sampling_rate; + int range; //量程 参考 Range + int sampling_time; + int viff; //速度积分起始频率 + int power; //zigbee发射功率 + int retry_time; //zigbee重发次数 +}; + +//上传配置 cmd 84 +struct UploadConfig{ + char filename[32]; +}; +//网关更新 cmd 85 + +//传感器更新 cmd 86 +struct UpgradeSensorReq{ + char filename[32]; + int upgrade_short_addr[32]; +}; + +//获取特征值 cmd 87 + + +//停止更新传感器 cmd 88 +struct UpgradeStopReq{ + int short_addr; +}; + // 搜索应答 cmd 1 struct Search { + int version; char mac[20]; int gw_type; // GatewayType }; diff --git a/localserver/local_server.hpp b/localserver/local_server.hpp index fa604e7..d08842c 100644 --- a/localserver/local_server.hpp +++ b/localserver/local_server.hpp @@ -59,6 +59,12 @@ enum WebCommand { kGateWayVersion = 80, kSensorInfo = 81, kSensorWave = 82, + KDownloadConfig = 83, + KUploadConfig = 84, + KUpgadeGateway = 85, + KUpgradeSensor = 86, + KEigenvalue = 87, + KUpgradeSensorStop = 88 }; enum GatewayType{ kGWTDW2700 = 1, @@ -74,7 +80,7 @@ public: virtual ~LocalServer(); static void HandleFromServer(const char *pData, int pLen, const char *topic); static std::string HandleCgi_cmd(std::string &pData); - static char* HandleTcp_cmd(const char* recvData,uint8_t& rescmd,int& reslength); + static void HandleTcp_cmd(const char* recvData,char* send_data,uint8_t& rescmd,int& reslength); }; #endif // LOCAL_SERVER_HPP_ diff --git a/utility/tcp_cgi.cpp b/utility/tcp_cgi.cpp index a9a30e6..3a4a814 100644 --- a/utility/tcp_cgi.cpp +++ b/utility/tcp_cgi.cpp @@ -49,8 +49,8 @@ void TcpCgi::startCgiServer() { buff[n] = '\0'; std::string recvData = std::string(buff); - std::string reqData = LocalServer::HandleCgi_cmd(recvData); - if (send(connfd, reqData.c_str(), reqData.length(), 0) < 0) { + std::string send_data = LocalServer::HandleCgi_cmd(recvData); + if (send(connfd, send_data.c_str(), send_data.length(), 0) < 0) { zlog_error(zct, "send msg error: %s(errno: %d)", strerror(errno), errno); } close(connfd); @@ -87,10 +87,10 @@ void TcpCgi::startTCPServer() { zlog_error(zbt, "listen socket error: %s(errno: %d)", strerror(errno), errno); return; } - char *recv_data = NULL; - recv_data = (char*)malloc(384000); // 96000*4 = 384000 - if (recv_data == NULL) { - zlog_error(zct,"recv_data Memory error"); + char *send_all_data = NULL; + send_all_data = (char*)malloc(384000); // 96000*4 = 384000 + if (send_all_data == NULL) { + zlog_error(zct,"send_all_data Memory error"); } while (1) { @@ -103,59 +103,65 @@ void TcpCgi::startTCPServer() { zlog_info(zct, "recv 0 and will close"); close(connfd); } else { + printf("recv len = %d\n", n); buff[n] = '\0'; PackgeHead pkg; pkg.head[0] = 0xAA; pkg.head[1] = 0x55; pkg.head[2] = 0xAA; int recv_data_len = 0; - char *reqData = LocalServer::HandleTcp_cmd(buff,pkg.cmd,recv_data_len); + char send_data[96100] = {0}; + LocalServer::HandleTcp_cmd(buff,send_data,pkg.cmd,recv_data_len); + printf("response len = %d\n", recv_data_len); int PKG_ONCE_SIZE = 1300; int package_num = recv_data_len / PKG_ONCE_SIZE + 1; if (recv_data_len % PKG_ONCE_SIZE == 0) { package_num -= 1; } - pkg.total_pkg_count = package_num; + Search search; int PKG_HEADER_LEN = sizeof(PackgeHead); - printf("response len = %d\n", recv_data_len); + printf("package_num = %d\n", package_num); if (recv_data_len > PKG_ONCE_SIZE) { for (int i = 0; i < package_num; ++i) { - pkg.current_pkg_id = i+1; if (package_num - 1 == i) { - pkg.len = recv_data_len - i*PKG_ONCE_SIZE; - memcpy(recv_data, &pkg, PKG_HEADER_LEN); - memcpy(recv_data + PKG_HEADER_LEN, reqData + i*PKG_ONCE_SIZE, recv_data_len - i*PKG_ONCE_SIZE); - send(connfd, recv_data, recv_data_len - i*PKG_ONCE_SIZE + PKG_HEADER_LEN,0); + memcpy(send_all_data , send_data + i * PKG_ONCE_SIZE, recv_data_len - i * PKG_ONCE_SIZE); + send(connfd, send_all_data, recv_data_len - i * PKG_ONCE_SIZE,0); + printf("i = %d,send size = %d\n",i,recv_data_len - i * PKG_ONCE_SIZE + PKG_HEADER_LEN); + }else if(i == 0){ + printf("i = %d,head size = %d,total size = %d\n",i,PKG_HEADER_LEN, PKG_ONCE_SIZE + PKG_HEADER_LEN); + pkg.len = recv_data_len; + memcpy(send_all_data, &pkg, PKG_HEADER_LEN); + memcpy(send_all_data + PKG_HEADER_LEN, send_data + i * PKG_ONCE_SIZE, PKG_ONCE_SIZE); + send(connfd, send_all_data, PKG_ONCE_SIZE + PKG_HEADER_LEN,0); + printf("i = %d,send size = %d\n",i,PKG_ONCE_SIZE + PKG_HEADER_LEN); + memset(send_all_data,0,38400); } else { - pkg.len = PKG_ONCE_SIZE; - memcpy(recv_data, &pkg, PKG_HEADER_LEN); - memcpy(recv_data + PKG_HEADER_LEN, reqData + i*PKG_ONCE_SIZE, PKG_ONCE_SIZE); - send(connfd, recv_data, PKG_ONCE_SIZE + PKG_HEADER_LEN,0); - mssleep(10); // ms + printf("i = %d,package_num = %d\n",i, package_num); + memcpy(send_all_data, send_data + i * PKG_ONCE_SIZE, PKG_ONCE_SIZE); + send(connfd, send_all_data, PKG_ONCE_SIZE,0); + printf("i = %d,send size = %d\n",i,PKG_ONCE_SIZE); + memset(send_all_data,0,38400); + mssleep(50); } } } else { - pkg.current_pkg_id = 1; pkg.len = recv_data_len; - memcpy(recv_data, &pkg, PKG_HEADER_LEN); - memcpy(recv_data + PKG_HEADER_LEN, &reqData, recv_data_len); - send(connfd, recv_data, recv_data_len + PKG_HEADER_LEN,0); + memcpy(send_all_data, &pkg, PKG_HEADER_LEN); + memcpy(send_all_data + PKG_HEADER_LEN, &send_data, recv_data_len); + send(connfd, send_all_data, recv_data_len + PKG_HEADER_LEN,0); printf("only one pkg, send data len:%d\n", recv_data_len + PKG_HEADER_LEN); + } - if (reqData) - { - free(reqData); - reqData = NULL; - } + close(connfd); } } close(listenfd); - if (recv_data) + if (send_all_data) { - free(recv_data); - recv_data = NULL; + free(send_all_data); + send_all_data = NULL; } return;