zhangsheng/WLG
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

add manger code

Browse Source
This commit is contained in:
zhangsheng 2025-01-13 20:11:40 +08:00
parent f937b18517
commit c81f579692
10 changed files with 427 additions and 122 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Makefile
View File

@ -20,7 +20,7 @@ LIBS = -L../Tools/renesas_thirdparty/lib \
-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 -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 = LINKFLAGS =
AllDirs :=$(shell ls -R | grep '^\./.*:' | awk '{if( \ AllDirs :=$(shell ls -R | grep '^\./.*:' | awk '{if( \

4
common/common_func.cpp
View File

@ -1118,7 +1118,7 @@ std::string GetSysStatus(Json::Value &jsData) {
std::string strJson = fw.write(jsData); std::string strJson = fw.write(jsData);
return strJson; 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_used = -1;
long mem_free = -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); int temp = getSysIntValue(key);
cpu_use = rateUser; cpu_use = rateUser;
mem_use = fMemRate * 100; 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; cpu_temp = temp / 1000.0;
} }
// 闁诲繐绻愬Λ妤€鐣烽悢鍝モ枖闁跨噦鎷<E599A6>16闁哄鏅滅粙鎴﹀春濡ゅ啠鍋撳☉娆樻畼妞ゆ垳鐒﹀顏堫敆娴ｇǹ绨ユ繛鎴炴尭閹碱偊顢氶鑺ュ劅闁哄啫鍊归悾閬嶆倵濞戞瑯娈欏┑鈽嗗弮瀹曟劙鏁撻敓锟<E69593> // 闁诲繐绻愬Λ妤€鐣烽悢鍝モ枖闁跨噦鎷<E599A6>16闁哄鏅滅粙鎴﹀春濡ゅ啠鍋撳☉娆樻畼妞ゆ垳鐒﹀顏堫敆娴ｇǹ绨ユ繛鎴炴尭閹碱偊顢氶鑺ュ劅闁哄啫鍊归悾閬嶆倵濞戞瑯娈欏┑鈽嗗弮瀹曟劙鏁撻敓锟<E69593>

2
common/common_func.hpp
View File

@ -380,7 +380,7 @@ void ZoneConfig(std::string zoneid);
* @return std::string CPU MEM DISK info * @return std::string CPU MEM DISK info
*/ */
std::string GetSysStatus(Json::Value &jsData); 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 CheckIP(const char* ip);
bool IsValidMask(std::string mask); bool IsValidMask(std::string mask);

244
jsonparse/cmt_parse.cpp
View File

@ -6,20 +6,22 @@
#include "dbaccess/sql_db.hpp" #include "dbaccess/sql_db.hpp"
#include "scheduler/schedule.hpp" #include "scheduler/schedule.hpp"
#include "zlog.h" #include "zlog.h"
#include <fstream>
extern zlog_category_t *zct; 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"); zlog_info(zct,"CmtCmd_80");
GatewayVersion gateway_ver; GatewayVersion gateway_ver;
gateway_ver.version = 1;
memcpy(gateway_ver.mac,GlobalConfig::MacAddr_G.c_str(),sizeof(gateway_ver.mac)); 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.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.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.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.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 #ifdef NR5G_MODULE
memcpy(gateway_ver.comm_mode,"5G",sizeof(gateway_ver.comm_mode)); memcpy(gateway_ver.comm_mode,"5G",sizeof(gateway_ver.comm_mode));
#endif #endif
@ -30,15 +32,12 @@ char *JsonData::CmtCmd_80(int& return_length)
memcpy(gateway_ver.comm_mode,"WiFi",sizeof(gateway_ver.comm_mode)); memcpy(gateway_ver.comm_mode,"WiFi",sizeof(gateway_ver.comm_mode));
#endif #endif
memcpy(gateway_ver.comm_mode,"有线",sizeof(gateway_ver.comm_mode)); 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); GetSysStatusCMT(gateway_ver.cpu_use,gateway_ver.memory_use,gateway_ver.disk_remain,gateway_ver.temperature);
char *retData = NULL; memcpy(send_data,&gateway_ver,sizeof(GatewayVersion));
retData = (char*)malloc(sizeof(GatewayVersion)); send_length = sizeof(GatewayVersion);
memcpy(retData,&gateway_ver,sizeof(GatewayVersion));
return_length = sizeof(GatewayVersion);
return retData;
} }
char *JsonData::CmtCmd_81(int& return_length) void JsonData::CmtCmd_81(char* send_data,int& send_length)
{ {
int featureInterVal; int featureInterVal;
int featureInterTime; int featureInterTime;
@ -46,7 +45,6 @@ char *JsonData::CmtCmd_81(int& return_length)
int waveInterTime; int waveInterTime;
int maxSensorNum; int maxSensorNum;
int sensorCount; int sensorCount;
char *retData = NULL;
array_t arrRes; array_t arrRes;
arrRes = sqlite_db_ctrl::instance().GetDataMultiLineTransaction(T_SENSOR_INFO(TNAME), "*", NULL); arrRes = sqlite_db_ctrl::instance().GetDataMultiLineTransaction(T_SENSOR_INFO(TNAME), "*", NULL);
int iResult = arrRes.size(); int iResult = arrRes.size();
@ -55,26 +53,25 @@ char *JsonData::CmtCmd_81(int& return_length)
SensorInfo sensor_info[iResult]; SensorInfo sensor_info[iResult];
for (; j < iResult; j++) for (; j < iResult; j++)
{ {
memcpy(sensor_info[j].mac,arrRes[j][44].c_str(),sizeof(sensor_info[j].mac)); memcpy(sensor_info[j].measurement_id,arrRes[j][44].c_str(),sizeof(sensor_info[j].measurement_id));
memcpy(sensor_info[j].short_addr,arrRes[j][30].c_str(),sizeof(sensor_info[j].short_addr)); 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].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)); memcpy(sensor_info[j].soft_ver,arrRes[j][9].c_str(),sizeof(sensor_info[j].soft_ver));
std::vector<std::string> vParamRSSI; std::vector<std::string> vParamRSSI;
boost::split(vParamRSSI, arrRes[j][40], boost::is_any_of(","), boost::token_compress_on); boost::split(vParamRSSI, arrRes[j][40], boost::is_any_of(","), boost::token_compress_on);
if (vParamRSSI.size() > 1) { if (vParamRSSI.size() > 1) {
memcpy(sensor_info[j].sensor_rssi,vParamRSSI[0].c_str(),sizeof(sensor_info[j].sensor_rssi)); sensor_info[j].gateway_rssi = (atof(vParamRSSI[0].c_str())/255) * 100;
memcpy(sensor_info[j].gateway_rssi,vParamRSSI[1].c_str(),sizeof(sensor_info[j].gateway_rssi)); sensor_info[j].sensor_rssi = (atof(vParamRSSI[1].c_str())/255) * 100;
} else { } else {
memcpy(sensor_info[j].sensor_rssi,vParamRSSI[0].c_str(),sizeof(sensor_info[j].sensor_rssi)); sensor_info[j].gateway_rssi = (atof(vParamRSSI[0].c_str())/255) * 100;
memcpy(sensor_info[j].gateway_rssi,"80",sizeof(sensor_info[j].gateway_rssi)); sensor_info[j].sensor_rssi = 99;
} }
std::vector<std::string> vParambattery; std::vector<std::string> vParambattery;
boost::split(vParambattery, arrRes[j][43], boost::is_any_of(","), boost::token_compress_on); boost::split(vParambattery, arrRes[j][43], boost::is_any_of(","), boost::token_compress_on);
if (vParambattery.size() > 1) { if (vParambattery.size() > 1) {
float battery = float(atof(vParambattery[1].c_str())/atof(vParambattery[0].c_str())); sensor_info[j].battry = (atof(vParambattery[1].c_str())/atof(vParambattery[0].c_str())) * 100;
sprintf(sensor_info[j].battry,"%f",battery);
} else { } else {
sprintf(sensor_info[j].battry ,"0.99",sizeof(sensor_info[j].battry)); sensor_info[j].battry = 99;
} }
std::vector<std::string> vParam; std::vector<std::string> vParam;
boost::split(vParam, arrRes[j][42], boost::is_any_of(","), boost::token_compress_on); 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; 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()); sensor_info[j].status = atoi(arrRes[j][37].c_str());
char szTableName[100] = {0x00}; 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()); int static_Count = sqlite_db_ctrl::instance().GetTableRows(szTableName,strsql.c_str());
scheduler::instance().GetScheduleConfig(featureInterVal,waveInterVal,featureInterTime,waveInterTime,maxSensorNum); scheduler::instance().GetScheduleConfig(featureInterVal,waveInterVal,featureInterTime,waveInterTime,maxSensorNum);
sensor_info[j].waveX_reportingrate = waveX_Count/(86400/waveInterVal); zlog_info(zct,"wavex = %d,featureInterVal = %d,waveInterVal",waveX_Count,featureInterVal);
sensor_info[j].waveY_reportingrate = waveY_Count/(86400/waveInterVal); sensor_info[j].wave_x_reporting_rate = (float(waveX_Count)/(86400/(float)waveInterVal)) * 100;
sensor_info[j].waveZ_reportingrate = waveZ_Count/(86400/waveInterVal); sensor_info[j].wave_y_reporting_rate = (float(waveY_Count)/(86400/(float)waveInterVal)) * 100;
sensor_info[j].eigenvalue_reportingrate = static_Count/(86400/featureInterVal); 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)); memset(whereCon,0,sizeof(whereCon));
sprintf(whereCon,"channelID = '%s-Z'",arrRes[j][44].c_str()); sprintf(whereCon,"channelID = '%s-Z'",arrRes[j][44].c_str());
std::string integratRMS = sqlite_db_ctrl::instance().GetData(T_DATA_INFO(TNAME), "integratRMS",whereCon); 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; 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(send_data,&sensor_info,sizeof(SensorInfo) * j);
memcpy(retData,&sensor_info,sizeof(SensorInfo) * j); memcpy(send_data + sizeof(SensorInfo) * j,&sensor_info,sizeof(SensorInfo) * j);
return_length = 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; FILE* pFile = NULL;
char* buffer = NULL; char* buffer = NULL;
char* retData = NULL;
int thisSize = 0; int thisSize = 0;
WaveRes wave; WaveRes wave;
char whereCon[32]={0}; char whereCon[32]={0};
sprintf(whereCon,"MeasurementID = '%s'",MeasurementID); sprintf(whereCon,"MeasurementID = '%s'",MeasurementID);
vec_t vecRes = sqlite_db_ctrl::instance().GetDataSingleLine(T_SENSOR_INFO(TNAME), "samplingRate,ACCSampleTime",whereCon); 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()); zlog_info(zct, "strFileName = %s", data_file.c_str());
pFile = fopen(data_file.c_str(), "rb"); pFile = fopen(data_file.c_str(), "rb");
if (pFile != NULL) { if (pFile != NULL) {
@ -171,12 +187,160 @@ char *JsonData::CmtCmd_82(char* MeasurementID,char* channel,int& return_length)
fread(buffer, sizeof(char), thisSize, pFile); fread(buffer, sizeof(char), thisSize, pFile);
fclose(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()); wave.sampling_time = atoi(vecRes[1].c_str());
return_length = sizeof(WaveRes) + thisSize; wave.version = 1;
retData = (char*)malloc(return_length); send_length = sizeof(WaveRes) + 51200;
memcpy(retData,(char*)&wave,sizeof(WaveRes)); memcpy(send_data,(char*)&wave,sizeof(WaveRes));
memcpy(retData + sizeof(WaveRes) ,&buffer,thisSize); memcpy(send_data + sizeof(WaveRes) ,test_buf,51200);
free(buffer); 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<std::string> 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<DataNodeInfo> 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<std::string> 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)
{
} }

9
jsonparse/communication_cmd.hpp
View File

@ -78,9 +78,12 @@ public:
//CMT tcp //CMT tcp
char* CmtCmd_80(int& return_length); void CmtCmd_80(char* send_data,int& return_length);
char* CmtCmd_81(int& return_length); void CmtCmd_81(char* send_data,int& return_length);
char* CmtCmd_82(char* MeasurementID,char* channel,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: private:
Json::FastWriter show_value_; Json::FastWriter show_value_;

8
jsonparse/web_cmd_parse3.cpp
View File

@ -614,6 +614,14 @@ std::string JsonData::JsonCmd_Cgi_59(Param_59 &param) {
Json::Value iTem; Json::Value iTem;
iTem.append(arrResult[i][1]); iTem.append(arrResult[i][1]);
iTem.append(arrResult[i][0]); 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); valData.append(iTem);
} }
jsonVal["content"] = valData; jsonVal["content"] = valData;

70
localserver/cmt_cmd.cpp
View File

@ -6,36 +6,74 @@
extern zlog_category_t *zct; 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"); zlog_info(zct,"HandleTcp_cmd");
PackgeHead head; PackgeHead head;
memcpy(&head,recvData,sizeof(PackgeHead)); memcpy(&head,recv_data,sizeof(PackgeHead));
uint8_t cmd = head.cmd; uint8_t cmd = head.cmd;
rescmd = head.cmd; rescmd = head.cmd;
printf("cmd = %d\n",cmd);
JsonData jd; JsonData jd;
switch (cmd) switch (cmd)
{ {
case 1:{ case 1:{
Search search; Search search;
search.version = 1;
memcpy(search.mac,GlobalConfig::MacAddr_G.c_str(),sizeof(search.mac)); memcpy(search.mac,GlobalConfig::MacAddr_G.c_str(),sizeof(search.mac));
search.gw_type = kGWTDG102; search.gw_type = kGWTDG102;
reslength = sizeof(Search); send_length = sizeof(Search);
return (char*)&search; printf("send length = %d\n",send_length);
}break; memcpy(send_data,&search,sizeof(Search));
}break;
case kGateWayVersion: { case kGateWayVersion: {
char* retData = jd.CmtCmd_80(reslength); jd.CmtCmd_80(send_data,send_length);
return retData; // memcpy(send_data,&send_data_,sizeof(send_length));
}break; // if (send_data_){
// free(send_data_);
// }
}break;
case kSensorInfo:{ case kSensorInfo:{
char* retData = jd.CmtCmd_81(reslength); jd.CmtCmd_81(send_data,send_length);
return retData;
}break; }break;
case kSensorWave: case kSensorWave:{
WaveReq wave_req; WaveReq wave_req;
memcpy(&wave_req,recvData + sizeof(PackgeHead),sizeof(WaveReq)); memcpy(&wave_req,recv_data + sizeof(PackgeHead),sizeof(WaveReq));
char* retData = jd.CmtCmd_82(wave_req.mac,wave_req.channel,reslength); jd.CmtCmd_82(wave_req.measurement_id,send_data,wave_req.channel,send_length);
return retData;
}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; break;
default: default:
return NULL; return NULL;

134
localserver/cmt_protocol.h
View File

@ -4,71 +4,151 @@
//1 tcp server可以参考本安有线中的代码，侦听端口10000 //1 tcp server可以参考本安有线中的代码，侦听端口10000
//2 定义无线网关与传感器用到的结构 //2 定义无线网关与传感器用到的结构
//3 包头为 //3 包头为
#pragma pack(1)
struct PackgeHead{ struct PackgeHead{
uint8_t head[3]; // 固定值：0xAA55AA uint8_t head[3]; // 固定值：0xAA55AA
uint8_t cmd; uint8_t cmd;
uint16_t total_pkg_count;
uint16_t current_pkg_id;
uint16_t len; uint16_t len;
char data[0]; char data[0];
}; };
#pragma pack(1)
//网关版本和状态信息cmd 80 //网关版本和状态信息cmd 80
struct GatewayVersion{ struct GatewayVersion{
int version; // 写1
char web_ver[12]; char web_ver[12];
char system_ver[12]; char system_ver[12];
char gateway_ver[12]; char gateway_ver[12];
char localIP[16]; char ip[16];
char gateway_type[12]; char gateway_type[12];
char geteway_hw_ver[12]; char gateway_hw_ver[12];
char comm_mode[12]; char terminal_name[32]; // 终端名称，如果为空，填写Default
int cpu_use; int cpu_use;
int memory_use; int memory_use;
int harddisk_remain; int disk_remain;
int temperature; int temperature;
char comm_mode[10];
char mac[20]; 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 //传感器信息cmd 81
struct SensorInfo{ struct SensorInfo{
char mac[20]; int version;
char short_addr[8]; char measurement_id[20];
int short_addr;
char hw_ver[12]; char hw_ver[12];
char soft_ver[12]; char soft_ver[12];
char gateway_rssi[16]; int gateway_rssi;
char sensor_rssi[16]; int sensor_rssi;
char battry[12]; int battry;
int loose_status; int loose_status; //参考 LooseStatus
int temperature_bot; int temperature_bot;
int temperature_top; int temperature_top;
char product_no[4]; char product[6]; // DN101；DN102
int status; int status; // 参考 SensorStatus
int eigenvalue_reportingrate; int eigen_value_reporting_rate;
int waveX_reportingrate; int wave_x_reporting_rate;
int waveY_reportingrate; int wave_y_reporting_rate;
int waveZ_reportingrate; int wave_z_reporting_rate;
char integratRMS[10]; char velocity_rms[10];
int upgrade_status; int upgrade_status; // 参考 SensorUpgradeStatus
char upgrade_date[20]; char upgrade_time[20];
}; };
enum ChannelType{
X = 1,
Y = 2,
Z = 3
};
//波形cmd 82 //波形cmd 82
struct WaveReq{ struct WaveReq{
char mac[20]; char measurement_id[20];
char channel[2]; int channel;//参考 ChannelType
}; };
struct WaveRes{ struct WaveRes{
int version;
int sampling_rate; int sampling_rate;
int sampling_time; int sampling_time;
char wave[0]; 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 // 搜索应答 cmd 1
struct Search { struct Search {
int version;
char mac[20]; char mac[20];
int gw_type; // GatewayType int gw_type; // GatewayType
}; };

8
localserver/local_server.hpp
View File

@ -59,6 +59,12 @@ enum WebCommand {
kGateWayVersion = 80, kGateWayVersion = 80,
kSensorInfo = 81, kSensorInfo = 81,
kSensorWave = 82, kSensorWave = 82,
KDownloadConfig = 83,
KUploadConfig = 84,
KUpgadeGateway = 85,
KUpgradeSensor = 86,
KEigenvalue = 87,
KUpgradeSensorStop = 88
}; };
enum GatewayType{ enum GatewayType{
kGWTDW2700 = 1, kGWTDW2700 = 1,
@ -74,7 +80,7 @@ public:
virtual ~LocalServer(); virtual ~LocalServer();
static void HandleFromServer(const char *pData, int pLen, const char *topic); static void HandleFromServer(const char *pData, int pLen, const char *topic);
static std::string HandleCgi_cmd(std::string &pData); 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_ #endif // LOCAL_SERVER_HPP_

68
utility/tcp_cgi.cpp
View File

@ -49,8 +49,8 @@ void TcpCgi::startCgiServer() {
buff[n] = '\0'; buff[n] = '\0';
std::string recvData = std::string(buff); std::string recvData = std::string(buff);
std::string reqData = LocalServer::HandleCgi_cmd(recvData); std::string send_data = LocalServer::HandleCgi_cmd(recvData);
if (send(connfd, reqData.c_str(), reqData.length(), 0) < 0) { if (send(connfd, send_data.c_str(), send_data.length(), 0) < 0) {
zlog_error(zct, "send msg error: %s(errno: %d)", strerror(errno), errno); zlog_error(zct, "send msg error: %s(errno: %d)", strerror(errno), errno);
} }
close(connfd); close(connfd);
@ -87,10 +87,10 @@ void TcpCgi::startTCPServer() {
zlog_error(zbt, "listen socket error: %s(errno: %d)", strerror(errno), errno); zlog_error(zbt, "listen socket error: %s(errno: %d)", strerror(errno), errno);
return; return;
} }
char *recv_data = NULL; char *send_all_data = NULL;
recv_data = (char*)malloc(384000); // 96000*4 = 384000 send_all_data = (char*)malloc(384000); // 96000*4 = 384000
if (recv_data == NULL) { if (send_all_data == NULL) {
zlog_error(zct,"recv_data Memory error"); zlog_error(zct,"send_all_data Memory error");
} }
while (1) { while (1) {
@ -103,59 +103,65 @@ void TcpCgi::startTCPServer() {
zlog_info(zct, "recv 0 and will close"); zlog_info(zct, "recv 0 and will close");
close(connfd); close(connfd);
} else { } else {
printf("recv len = %d\n", n);
buff[n] = '\0'; buff[n] = '\0';
PackgeHead pkg; PackgeHead pkg;
pkg.head[0] = 0xAA; pkg.head[0] = 0xAA;
pkg.head[1] = 0x55; pkg.head[1] = 0x55;
pkg.head[2] = 0xAA; pkg.head[2] = 0xAA;
int recv_data_len = 0; 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 PKG_ONCE_SIZE = 1300;
int package_num = recv_data_len / PKG_ONCE_SIZE + 1; int package_num = recv_data_len / PKG_ONCE_SIZE + 1;
if (recv_data_len % PKG_ONCE_SIZE == 0) { if (recv_data_len % PKG_ONCE_SIZE == 0) {
package_num -= 1; package_num -= 1;
} }
pkg.total_pkg_count = package_num; Search search;
int PKG_HEADER_LEN = sizeof(PackgeHead); 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) { if (recv_data_len > PKG_ONCE_SIZE) {
for (int i = 0; i < package_num; ++i) { for (int i = 0; i < package_num; ++i) {
pkg.current_pkg_id = i+1;
if (package_num - 1 == i) { if (package_num - 1 == i) {
pkg.len = recv_data_len - i*PKG_ONCE_SIZE; memcpy(send_all_data , send_data + i * PKG_ONCE_SIZE, recv_data_len - i * PKG_ONCE_SIZE);
memcpy(recv_data, &pkg, PKG_HEADER_LEN); send(connfd, send_all_data, recv_data_len - i * PKG_ONCE_SIZE,0);
memcpy(recv_data + PKG_HEADER_LEN, reqData + i*PKG_ONCE_SIZE, recv_data_len - i*PKG_ONCE_SIZE); printf("i = %d,send size = %d\n",i,recv_data_len - i * PKG_ONCE_SIZE + PKG_HEADER_LEN);
send(connfd, recv_data, recv_data_len - i*PKG_ONCE_SIZE + PKG_HEADER_LEN,0); }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 { } else {
pkg.len = PKG_ONCE_SIZE; printf("i = %d,package_num = %d\n",i, package_num);
memcpy(recv_data, &pkg, PKG_HEADER_LEN); memcpy(send_all_data, send_data + i * PKG_ONCE_SIZE, PKG_ONCE_SIZE);
memcpy(recv_data + PKG_HEADER_LEN, reqData + i*PKG_ONCE_SIZE, PKG_ONCE_SIZE); send(connfd, send_all_data, PKG_ONCE_SIZE,0);
send(connfd, recv_data, PKG_ONCE_SIZE + PKG_HEADER_LEN,0); printf("i = %d,send size = %d\n",i,PKG_ONCE_SIZE);
mssleep(10); // ms memset(send_all_data,0,38400);
mssleep(50);
} }
} }
} else { } else {
pkg.current_pkg_id = 1;
pkg.len = recv_data_len; pkg.len = recv_data_len;
memcpy(recv_data, &pkg, PKG_HEADER_LEN); memcpy(send_all_data, &pkg, PKG_HEADER_LEN);
memcpy(recv_data + PKG_HEADER_LEN, &reqData, recv_data_len); memcpy(send_all_data + PKG_HEADER_LEN, &send_data, recv_data_len);
send(connfd, recv_data, recv_data_len + PKG_HEADER_LEN,0); 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); printf("only one pkg, send data len:%d\n", recv_data_len + PKG_HEADER_LEN);
} }
if (reqData)
{
free(reqData);
reqData = NULL;
}
close(connfd); close(connfd);
} }
} }
close(listenfd); close(listenfd);
if (recv_data) if (send_all_data)
{ {
free(recv_data); free(send_all_data);
recv_data = NULL; send_all_data = NULL;
} }
return; return;