From f937b18517c3e2e184c9ab37eb64edd375251331 Mon Sep 17 00:00:00 2001 From: zhangsheng Date: Thu, 9 Jan 2025 20:00:34 +0800 Subject: [PATCH] add manger code --- common/common_func.cpp | 51 +++++++++ common/common_func.hpp | 2 +- jsonparse/cmt_parse.cpp | 182 ++++++++++++++++++++++++++++++++ jsonparse/communication_cmd.hpp | 7 ++ jsonparse/web_cmd_parse3.cpp | 9 +- localserver/cmt_cmd.cpp | 45 ++++++++ localserver/cmt_protocol.h | 76 +++++++++++++ localserver/local_server.hpp | 15 ++- localserver/web_cmd.cpp | 2 +- main.cpp | 4 + threadfunc/thread_func.cpp | 10 ++ threadfunc/thread_func.hpp | 1 + uart/uart.cpp | 7 +- uart/uart_feature_parse.cpp | 18 +++- utility/tcp_cgi.cpp | 102 ++++++++++++++++++ utility/tcp_cgi.hpp | 1 + 16 files changed, 518 insertions(+), 14 deletions(-) create mode 100644 jsonparse/cmt_parse.cpp create mode 100644 localserver/cmt_cmd.cpp create mode 100644 localserver/cmt_protocol.h diff --git a/common/common_func.cpp b/common/common_func.cpp index 770557b..56c7024 100644 --- a/common/common_func.cpp +++ b/common/common_func.cpp @@ -1118,7 +1118,58 @@ 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) +{ + long mem_used = -1; + long mem_free = -1; + long mem_total = -1; + long mem_cached = -1; + char name1[20]; + std::string strMemTotal = GetFileContent("/proc/meminfo", 1); + std::string strMemFree = GetFileContent("/proc/meminfo", 2); + std::string strMemCache = GetFileContent("/proc/meminfo", 5); + sscanf(strMemTotal.c_str(), "%s%ld", name1, &mem_total); + sscanf(strMemFree.c_str(), "%s%ld", name1, &mem_free); + sscanf(strMemCache.c_str(), "%s%ld", name1, &mem_cached); + mem_used = mem_total - mem_free; + float fMemRate = 1.0 * mem_used / mem_total; + + char name[8]; + double cpu_sys = -1; + double cpu_user = -1; + double cpu_total = -1; + long int user, nice, sys, idle, iowait, irq, softirq; + std::string strCpu1 = GetFileContent("/proc/stat", 1); + sscanf(strCpu1.c_str(), "%s%ld%ld%ld%ld%ld%ld%ld", name, &user, &nice, &sys, &idle, &iowait, &irq, &softirq); + sleep(1); + long int userNext, niceNext, sysNext, idleNext, iowaitNext, irqNext, softirqNext; + std::string strCpu2 = GetFileContent("/proc/stat", 1); + sscanf(strCpu2.c_str(), "%s%ld%ld%ld%ld%ld%ld%ld", name, &userNext, &niceNext, &sysNext, &idleNext, &iowaitNext, &irqNext, &softirqNext); + cpu_total = (userNext + niceNext + sysNext + idleNext + iowaitNext + irqNext + softirqNext) - (user + nice + sys + idle + iowait + irq + softirq); + cpu_user = userNext - user; + cpu_sys = sysNext - sys; + float rateUser = cpu_user * 100.0 / cpu_total; + float rateSys = cpu_sys * 100.0 / cpu_total; + if (rateUser > 95) { + rateUser = 92; + } + char hardTotal[32]; + char hardFree[32]; + char rateHardUse[32]; + char chRes[100]; + memset(chRes, 0, 100); + getDiskInfo(hardTotal, hardFree); + std::string strhardFree(hardFree); + char key[128] = {0}; + memset(key, 0, sizeof(key)); + sprintf(key, "/sys/class/thermal/thermal_zone0/temp"); + int temp = getSysIntValue(key); + cpu_use = rateUser; + mem_use = fMemRate * 100; + harddisk_remain = atof(strhardFree.substr(0, strhardFree.length() - 1).c_str()); + cpu_temp = temp / 1000.0; +} // 闁诲繐绻愬Λ妤€鐣烽悢鍝モ枖闁跨噦鎷�16闁哄鏅滅粙鎴﹀春濡ゅ啠鍋撳☉娆樻畼妞ゆ垳鐒﹀顏堫敆娴ｇǹ绨ユ繛鎴炴尭閹碱偊顢氶鑺ュ劅闁哄啫鍊归悾閬嶆倵濞戞瑯娈欏┑鈽嗗弮瀹曟劙鏁撻敓锟� unsigned char hexCharToByte(char c) { if (c >= '0' && c <= '9') return c - '0'; diff --git a/common/common_func.hpp b/common/common_func.hpp index 1b95984..cb08b43 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); bool CheckIP(const char* ip); bool IsValidMask(std::string mask); diff --git a/jsonparse/cmt_parse.cpp b/jsonparse/cmt_parse.cpp new file mode 100644 index 0000000..508f78e --- /dev/null +++ b/jsonparse/cmt_parse.cpp @@ -0,0 +1,182 @@ +#include "communication_cmd.hpp" +#include "localserver/local_server.hpp" +#include "common/common_func.hpp" +#include "common/global.hpp" +#include +#include "dbaccess/sql_db.hpp" +#include "scheduler/schedule.hpp" +#include "zlog.h" + +extern zlog_category_t *zct; + +char *JsonData::CmtCmd_80(int& return_length) +{ + zlog_info(zct,"CmtCmd_80"); + GatewayVersion gateway_ver; + 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.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)); +#ifdef NR5G_MODULE + memcpy(gateway_ver.comm_mode,"5G",sizeof(gateway_ver.comm_mode)); +#endif +#ifdef Q4G_MODULE + memcpy(gateway_ver.comm_mode,"4G",sizeof(gateway_ver.comm_mode)); +#endif +#ifdef WIFI_MODULE + 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; +} + +char *JsonData::CmtCmd_81(int& return_length) +{ + int featureInterVal; + int featureInterTime; + int waveInterVal; + 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(); + size_t j = 0; + if (iResult > 0) { + 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].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)); + } 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)); + } + 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); + } else { + sprintf(sensor_info[j].battry ,"0.99",sizeof(sensor_info[j].battry)); + } + std::vector vParam; + boost::split(vParam, arrRes[j][42], boost::is_any_of(","), boost::token_compress_on); + if (vParam.size() > 1){ + if (vParam[1] != "0"){ + sensor_info[j].loose_status = 1; + }else{ + sensor_info[j].loose_status = 0; + } + } + char whereCon[256]={0x00}; + sprintf(whereCon,"dataNodeNo = '%s'",arrRes[j][44].c_str()); + vec_t vecRes = sqlite_db_ctrl::instance().GetDataSingleLine(T_DATASTATIC_INFO(TNAME), "temTop,temBot",whereCon); + if (vecRes.size() > 0) + { + sensor_info[j].temperature_top = atoi(vecRes[0].c_str()); + sensor_info[j].temperature_bot = atoi(vecRes[1].c_str()); + }else{ + sensor_info[j].temperature_top = 200; + sensor_info[j].temperature_bot = 200; + } + + memcpy(sensor_info[j].product_no,arrRes[j][17].c_str(),sizeof(sensor_info[j].product_no)); + sensor_info[j].status = atoi(arrRes[j][37].c_str()); + + char szTableName[100] = {0x00}; + memset(whereCon,0,sizeof(whereCon)); + sprintf(szTableName, " t_data_waveSend "); + const char *sql = + " timestamp >= strftime('%s', 'now', '-1 day', 'start of day','utc') " + "AND timestamp < strftime('%s', 'now', '-1 day','start of day','utc','+24 hours') "; + sprintf(whereCon," and channelID = '%s-X'",arrRes[j][44].c_str()); + std::string strsql = std::string(sql) + std::string(whereCon); + int waveX_Count = sqlite_db_ctrl::instance().GetTableRows(szTableName,strsql.c_str()); + + memset(whereCon,0,sizeof(whereCon)); + sprintf(whereCon," and channelID = '%s-Y'",arrRes[j][44].c_str()); + strsql = std::string(sql) + std::string(whereCon); + int waveY_Count = sqlite_db_ctrl::instance().GetTableRows(szTableName,strsql.c_str()); + + memset(whereCon,0,sizeof(whereCon)); + sprintf(whereCon," and channelID = '%s-Z'",arrRes[j][44].c_str()); + strsql = std::string(sql) + std::string(whereCon); + int waveZ_Count = sqlite_db_ctrl::instance().GetTableRows(szTableName,strsql.c_str()); + + memset(whereCon,0,sizeof(whereCon)); + memset(szTableName,0,sizeof(szTableName)); + sprintf(szTableName, " t_dataStatic_%s ",arrRes[j][44].c_str()); + sprintf(whereCon," and channelID = '%s-S'",arrRes[j][44].c_str()); + strsql = std::string(sql) + std::string(whereCon); + 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); + + 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));; + sensor_info[j].upgrade_status = 0; + memcpy(sensor_info[j].upgrade_date,"2024-01-08 12:00:00",sizeof(sensor_info[j].upgrade_date)); + } + retData = (char*)malloc(sizeof(SensorInfo) * j); + memcpy(retData,&sensor_info,sizeof(SensorInfo) * j); + return_length = sizeof(SensorInfo) * j; + } + return retData; + +} + +char *JsonData::CmtCmd_82(char* MeasurementID,char* channel,int& return_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); + zlog_info(zct, "strFileName = %s", data_file.c_str()); + pFile = fopen(data_file.c_str(), "rb"); + if (pFile != NULL) { + while (fgetc(pFile) != EOF) { + ++thisSize; + } + rewind(pFile); + buffer = (char*)malloc(thisSize); + fread(buffer, sizeof(char), thisSize, pFile); + fclose(pFile); + } + wave.sampling_rate = atoi(vecRes[0].c_str()); + 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); + free(buffer); + return retData; +} \ No newline at end of file diff --git a/jsonparse/communication_cmd.hpp b/jsonparse/communication_cmd.hpp index 80a6198..f1907cf 100644 --- a/jsonparse/communication_cmd.hpp +++ b/jsonparse/communication_cmd.hpp @@ -5,6 +5,7 @@ #include #include #include "common/parameter_defination.hpp" +#include "localserver/cmt_protocol.h" class JsonData { public: @@ -75,6 +76,12 @@ public: std::string JsonCmd_Cgi_64(Param_64 ¶m); std::string JsonCmd_Cgi_default(); + + //CMT tcp + char* CmtCmd_80(int& return_length); + char* CmtCmd_81(int& return_length); + char* CmtCmd_82(char* MeasurementID,char* channel,int& return_length); + private: Json::FastWriter show_value_; }; diff --git a/jsonparse/web_cmd_parse3.cpp b/jsonparse/web_cmd_parse3.cpp index cf749bf..e749ec5 100644 --- a/jsonparse/web_cmd_parse3.cpp +++ b/jsonparse/web_cmd_parse3.cpp @@ -106,11 +106,6 @@ std::string JsonData::JsonCmd_Cgi_50() { std::vector value; std::vector vecDataNodeUpdate; DataNodeUpdate datanodeUpdate; - std::fstream is; - is.open("/opt/DataNode/config.json", std::ios::in); - if (reader.parse(is, root)) { - jsBody["sensor"] = root; - } jsBody["GateWayVersion"] = GlobalConfig::Version; jsBody["SystemVersion"] = ReadStrByOpt(SYSTEMINFOFILE, "Version", "SystemVersion"); jsBody["WebVersion"] = ReadStrByOpt(SYSTEMINFOFILE, "Version", "WebVersion"); @@ -892,7 +887,7 @@ std::string JsonData::JsonCmd_Cgi_62(Param_62 ¶m){ char szTableName[100] = {0x00}, whereCon[256] = {0x00}; sprintf(szTableName, " receive_wave_status "); - sprintf(whereCon, " data_nodeno = '%s' and timeStamp < '%s' and timeStamp > '%s' ", param.MeasurementID.c_str(), param.timeEnd.c_str(), param.timeStart.c_str()); + sprintf(whereCon, " data_nodeno like '%%%s%%' and timeStamp < '%s' and timeStamp > '%s' ", param.MeasurementID.c_str(), param.timeEnd.c_str(), param.timeStart.c_str()); int rows = sqlite_db_ctrl::instance().GetTableRows(szTableName, whereCon); @@ -922,7 +917,7 @@ std::string JsonData::JsonCmd_Cgi_62(Param_62 ¶m){ } memset(whereCon, 0x00, sizeof(whereCon)); - sprintf(whereCon, "data_nodeno = '%s' and timeStamp < '%s' and timeStamp > '%s' order by timeStamp asc LIMIT %d OFFSET %d", param.MeasurementID.c_str(), param.timeEnd.c_str(), param.timeStart.c_str(), 550, packgeNum); + sprintf(whereCon, "data_nodeno like '%%%s%%' and timeStamp < '%s' and timeStamp > '%s' order by timeStamp asc LIMIT %d OFFSET %d", param.MeasurementID.c_str(), param.timeEnd.c_str(), param.timeStart.c_str(), 550, packgeNum); array_t vecRes; vecRes = sqlite_db_ctrl::instance().GetDataMultiLine(szTableName, "*", whereCon); diff --git a/localserver/cmt_cmd.cpp b/localserver/cmt_cmd.cpp new file mode 100644 index 0000000..62d6613 --- /dev/null +++ b/localserver/cmt_cmd.cpp @@ -0,0 +1,45 @@ +#include "local_server.hpp" +#include "jsonparse/communication_cmd.hpp" +#include "common/global.hpp" +#include +#include "zlog.h" + +extern zlog_category_t *zct; + +char* LocalServer::HandleTcp_cmd(const char* recvData,uint8_t& rescmd,int& reslength) +{ + zlog_info(zct,"HandleTcp_cmd"); + PackgeHead head; + memcpy(&head,recvData,sizeof(PackgeHead)); + uint8_t cmd = head.cmd; + rescmd = head.cmd; + JsonData jd; + switch (cmd) + { + case 1:{ + Search search; + memcpy(search.mac,GlobalConfig::MacAddr_G.c_str(),sizeof(search.mac)); + search.gw_type = kGWTDG102; + reslength = sizeof(Search); + return (char*)&search; + }break; + case kGateWayVersion: { + char* retData = jd.CmtCmd_80(reslength); + return retData; + }break; + case kSensorInfo:{ + char* retData = jd.CmtCmd_81(reslength); + return retData; + }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; + break; + default: + return NULL; + break; + } + +} \ No newline at end of file diff --git a/localserver/cmt_protocol.h b/localserver/cmt_protocol.h new file mode 100644 index 0000000..71ca89d --- /dev/null +++ b/localserver/cmt_protocol.h @@ -0,0 +1,76 @@ +#ifndef CMT_PROTOCOL_HPP_ +#define CMT_PROTOCOL_HPP_ +#include +//1 tcp server可以参考本安有线中的代码，侦听端口10000 +//2 定义无线网关与传感器用到的结构 +//3 包头为 +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{ + char web_ver[12]; + char system_ver[12]; + char gateway_ver[12]; + char localIP[16]; + char gateway_type[12]; + char geteway_hw_ver[12]; + char comm_mode[12]; + int cpu_use; + int memory_use; + int harddisk_remain; + int temperature; + char mac[20]; +}; + +//传感器信息cmd 81 +struct SensorInfo{ + char mac[20]; + char short_addr[8]; + char hw_ver[12]; + char soft_ver[12]; + char gateway_rssi[16]; + char sensor_rssi[16]; + char battry[12]; + int loose_status; + 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]; +}; + +//波形cmd 82 +struct WaveReq{ + char mac[20]; + char channel[2]; +}; + +struct WaveRes{ + int sampling_rate; + int sampling_time; + char wave[0]; +}; + +// 搜索应答 cmd 1 +struct Search { + char mac[20]; + int gw_type; // GatewayType +}; + +#endif diff --git a/localserver/local_server.hpp b/localserver/local_server.hpp index 82d19f4..fa604e7 100644 --- a/localserver/local_server.hpp +++ b/localserver/local_server.hpp @@ -53,8 +53,20 @@ enum WebCommand { kWaveRecords = 61, kWaveReceive = 62, kWaveSend = 63, - kFeatureSend = 64 + kFeatureSend = 64, + + //CMT TCP + kGateWayVersion = 80, + kSensorInfo = 81, + kSensorWave = 82, }; +enum GatewayType{ + kGWTDW2700 = 1, + + kGWTDG101 = 10, + kGWTDG102 = 11 +}; + class LocalServer { public: @@ -62,6 +74,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); }; #endif // LOCAL_SERVER_HPP_ diff --git a/localserver/web_cmd.cpp b/localserver/web_cmd.cpp index 60e551c..ecdbdcc 100644 --- a/localserver/web_cmd.cpp +++ b/localserver/web_cmd.cpp @@ -520,7 +520,7 @@ std::string LocalServer::HandleCgi_cmd(std::string &pData) { } catch (...) { Json::Value jsVal; jsVal["success"] = false; - jsVal["message"] = "未知错误"; + jsVal["message"] = "unknow错误"; Json::FastWriter fw; return fw.write(jsVal); } diff --git a/main.cpp b/main.cpp index 61bf74f..3c51654 100644 --- a/main.cpp +++ b/main.cpp @@ -115,6 +115,10 @@ int main(int argc, char *argv[]) { boost::thread startTcpCgi(attrs, StartCgiServer); startTcpCgi.detach(); + //启动CMT server + boost::thread startTcpCmt(attrs, StartTCPServer); + startTcpCmt.detach(); + sleep(5); uart_inst::instance().ZigbeeParameterConfig(); sleep(1); diff --git a/threadfunc/thread_func.cpp b/threadfunc/thread_func.cpp index 41c0b70..8ac8ba1 100644 --- a/threadfunc/thread_func.cpp +++ b/threadfunc/thread_func.cpp @@ -37,6 +37,16 @@ void StartCgiServer() { } } +void StartTCPServer() { + zlog_info(zbt, "start deal TCP"); + + while (1) { + TcpCgi::startTCPServer(); + sleep(10); + } +} + + void RunLED() { while (1) { gpio_set(GlobalConfig::GPIO_G.runLed, 1); diff --git a/threadfunc/thread_func.hpp b/threadfunc/thread_func.hpp index d4e9454..5052a1f 100644 --- a/threadfunc/thread_func.hpp +++ b/threadfunc/thread_func.hpp @@ -17,6 +17,7 @@ void CheckThread(); //循环检测线程 void StartMqttClient(); //启动mqtt服务 void SearchThread(); //组播功能, 提供发现设备功能 void StartCgiServer(); //启动cgi处理服务端 +void StartTCPServer(); void HeartRep(); void UartStart(); // void TestUart(); diff --git a/uart/uart.cpp b/uart/uart.cpp index c984ae1..3d27682 100644 --- a/uart/uart.cpp +++ b/uart/uart.cpp @@ -1096,7 +1096,7 @@ int Uart::FindRecvPackage(int bytesRead, char *mUartRecvBuf, char *head) { strChannelID = strMeasurementID + "-Z"; } - sprintf(insertSql, "'%s','%s','%s',%d,'%d','%s' ", strMeasurementID.c_str(),strShortAddr.c_str(),localtimestamp,bytesRead,0,error_msg.c_str()); + sprintf(insertSql, "'%s','%s','%s',%d,'%d','%s' ", strChannelID.c_str(),strShortAddr.c_str(),localtimestamp,bytesRead,0,error_msg.c_str()); sqlite_db_ctrl::instance().InsertData(" receive_wave_status ", insertSql); JsonData jd; jd.JsonCmd_32(strMeasurementID,1,1,strChannelID,error_msg); @@ -1130,12 +1130,15 @@ int Uart::FindRecvPackage(int bytesRead, char *mUartRecvBuf, char *head) { memset(whereCon, 0x00, sizeof(whereCon)); if (command == WAVE_X){ error_msg = "Crc error,wave X"; + strChannelID = strMeasurementID + "-X"; }else if (command == WAVE_Y){ error_msg = "Crc error,wave Y"; + strChannelID = strMeasurementID + "-Y"; }else if (command == WAVE_Z){ error_msg = "Crc error,wave Z"; + strChannelID = strMeasurementID + "-Z"; } - sprintf(insertSql, "'%s','%s','%s',%d,'%d','%s' ", strMeasurementID.c_str(),strShortAddr.c_str(),localtimestamp,bytesRead,0,error_msg.c_str()); + sprintf(insertSql, "'%s','%s','%s',%d,'%d','%s' ", strChannelID.c_str(),strShortAddr.c_str(),localtimestamp,bytesRead,0,error_msg.c_str()); sqlite_db_ctrl::instance().InsertData(" receive_wave_status ", insertSql); JsonData jd; jd.JsonCmd_32(strMeasurementID,1,1,strChannelID,error_msg); diff --git a/uart/uart_feature_parse.cpp b/uart/uart_feature_parse.cpp index 4ff6593..f05889e 100644 --- a/uart/uart_feature_parse.cpp +++ b/uart/uart_feature_parse.cpp @@ -789,8 +789,22 @@ void Uart::DealWave() { char whereCon[50] = {0x00}; sprintf(whereCon, "MeasurementID='%s'",strMeasurementID.c_str()); memset(whereCon, 0x00, sizeof(whereCon)); - sprintf(insertSql, "'%s','%02x%02x','%s',0,'1','%s' ", strMeasurementID.c_str(),(wave_shortAddr >> 8) & 0xFF,wave_shortAddr & 0xFF,localtimestamp,""); - sqlite_db_ctrl::instance().InsertData(" receive_wave_status ", insertSql); + if (m_waveCountX > 0) + { + sprintf(insertSql, "'%s-X','%02x%02x','%s',0,'1','%s' ", strMeasurementID.c_str(),(wave_shortAddr >> 8) & 0xFF,wave_shortAddr & 0xFF,localtimestamp,""); + sqlite_db_ctrl::instance().InsertData(" receive_wave_status ", insertSql); + } + if (m_waveCountY > 0) + { + sprintf(insertSql, "'%s-Y','%02x%02x','%s',0,'1','%s' ", strMeasurementID.c_str(),(wave_shortAddr >> 8) & 0xFF,wave_shortAddr & 0xFF,localtimestamp,""); + sqlite_db_ctrl::instance().InsertData(" receive_wave_status ", insertSql); + } + if (m_waveCountZ > 0) + { + sprintf(insertSql, "'%s-Z','%02x%02x','%s',0,'1','%s' ", strMeasurementID.c_str(),(wave_shortAddr >> 8) & 0xFF,wave_shortAddr & 0xFF,localtimestamp,""); + sqlite_db_ctrl::instance().InsertData(" receive_wave_status ", insertSql); + } + } std::string ran = ""; diff --git a/utility/tcp_cgi.cpp b/utility/tcp_cgi.cpp index 3ac92e6..a9a30e6 100644 --- a/utility/tcp_cgi.cpp +++ b/utility/tcp_cgi.cpp @@ -1,5 +1,6 @@ #include "tcp_cgi.hpp" #include "localserver/local_server.hpp" +#include "localserver/cmt_protocol.h" #include extern zlog_category_t *zct; @@ -59,4 +60,105 @@ void TcpCgi::startCgiServer() { return; } +void TcpCgi::startTCPServer() { + int listenfd, connfd; + int mw_optval = 1; + + struct sockaddr_in servaddr; + char buff[40960]; + int n; + if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) { + zlog_error(zbt, "create socket error: %s(errno: %d)", strerror(errno), errno); + return; + } + setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, (char *)&mw_optval, sizeof(mw_optval)); + + memset(&servaddr, 0, sizeof(servaddr)); + servaddr.sin_family = AF_INET; + servaddr.sin_addr.s_addr = htonl(INADDR_ANY); + servaddr.sin_port = htons(10000); + + if (bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) == -1) { + zlog_error(zbt, "bind socket error: %s(errno: %d)", strerror(errno), errno); + return; + } + + if (listen(listenfd, 10) == -1) { + 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"); + } + + while (1) { + if ((connfd = accept(listenfd, (struct sockaddr *)NULL, NULL)) == -1) { + zlog_error(zct, "accept socket error: %s(errno: %d)", strerror(errno), errno); + continue; + } + n = recv(connfd, buff, 40960, 0); + if (n <= 0) { + zlog_info(zct, "recv 0 and will close"); + close(connfd); + } else { + 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); + 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; + int PKG_HEADER_LEN = sizeof(PackgeHead); + printf("response len = %d\n", recv_data_len); + 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); + } 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 + } + } + } 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); + 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) + { + free(recv_data); + recv_data = NULL; + } + + return; +} + TcpCgi::~TcpCgi() {} diff --git a/utility/tcp_cgi.hpp b/utility/tcp_cgi.hpp index 573a2a4..2989919 100644 --- a/utility/tcp_cgi.hpp +++ b/utility/tcp_cgi.hpp @@ -18,6 +18,7 @@ public: ~TcpCgi(); static void startCgiServer(); + static void startTCPServer(); }; #endif