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 \
-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( \

4
common/common_func.cpp
View File

@ -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;
}
// 闁诲繐绻愬Λ妤€鐣烽悢鍝モ枖闁跨噦鎷<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
*/
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);

244
jsonparse/cmt_parse.cpp
View File

@ -6,20 +6,22 @@
#include "dbaccess/sql_db.hpp"
#include "scheduler/schedule.hpp"
#include "zlog.h"
#include <fstream>
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<std::string> 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<std::string> 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<std::string> 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<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
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_;

8
jsonparse/web_cmd_parse3.cpp
View File

@ -614,6 +614,14 @@ std::string JsonData::JsonCmd_Cgi_59(Param_59 &param) {
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;

70
localserver/cmt_cmd.cpp
View File

@ -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;

134
localserver/cmt_protocol.h
View File

@ -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
};

8
localserver/local_server.hpp
View File

@ -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_

68
utility/tcp_cgi.cpp
View File

@ -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;