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-09 20:00:34 +08:00
parent 087c260942
commit f937b18517
16 changed files with 518 additions and 14 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

51
common/common_func.cpp
View File

@ -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;
}
// 闁诲繐绻愬Λ妤€鐣烽悢鍝モ枖闁跨噦鎷<E599A6>16闁哄鏅滅粙鎴﹀春濡ゅ啠鍋撳☉娆樻畼妞ゆ垳鐒﹀顏堫敆娴ｇǹ绨ユ繛鎴炴尭閹碱偊顢氶鑺ュ劅闁哄啫鍊归悾閬嶆倵濞戞瑯娈欏┑鈽嗗弮瀹曟劙鏁撻敓锟<E69593>
unsigned char hexCharToByte(char c) {
if (c >= '0' && c <= '9') return c - '0';

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);
bool CheckIP(const char* ip);
bool IsValidMask(std::string mask);

182
jsonparse/cmt_parse.cpp Normal file
View File

@ -0,0 +1,182 @@
#include "communication_cmd.hpp"
#include "localserver/local_server.hpp"
#include "common/common_func.hpp"
#include "common/global.hpp"
#include <boost/algorithm/string.hpp>
#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<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));
} 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<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);
} else {
sprintf(sensor_info[j].battry ,"0.99",sizeof(sensor_info[j].battry));
}
std::vector<std::string> 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;
}

7
jsonparse/communication_cmd.hpp
View File

@ -5,6 +5,7 @@
#include <iostream>
#include <json/json.h>
#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 &param);
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_;
};

9
jsonparse/web_cmd_parse3.cpp
View File

@ -106,11 +106,6 @@ std::string JsonData::JsonCmd_Cgi_50() {
std::vector<std::string> value;
std::vector<DataNodeUpdate> 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 &param){
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 &param){
}
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);

45
localserver/cmt_cmd.cpp Normal file
View File

@ -0,0 +1,45 @@
#include "local_server.hpp"
#include "jsonparse/communication_cmd.hpp"
#include "common/global.hpp"
#include <string.h>
#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;
}
}

76
localserver/cmt_protocol.h Normal file
View File

@ -0,0 +1,76 @@
#ifndef CMT_PROTOCOL_HPP_
#define CMT_PROTOCOL_HPP_
#include <iostream>
//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

15
localserver/local_server.hpp
View File

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

2
localserver/web_cmd.cpp
View File

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

4
main.cpp
View File

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

10
threadfunc/thread_func.cpp
View File

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

1
threadfunc/thread_func.hpp
View File

@ -17,6 +17,7 @@ void CheckThread(); //循环检测线程
void StartMqttClient(); //启动mqtt服务
void SearchThread(); //组播功能, 提供发现设备功能
void StartCgiServer(); //启动cgi处理服务端
void StartTCPServer();
void HeartRep();
void UartStart(); //
void TestUart();

7
uart/uart.cpp
View File

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

16
uart/uart_feature_parse.cpp
View File

@ -789,9 +789,23 @@ 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,"");
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 = "";
int n = 0;

102
utility/tcp_cgi.cpp
View File

@ -1,5 +1,6 @@
#include "tcp_cgi.hpp"
#include "localserver/local_server.hpp"
#include "localserver/cmt_protocol.h"
#include <zlog.h>
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() {}

1
utility/tcp_cgi.hpp
View File

@ -18,6 +18,7 @@ public:
~TcpCgi();
static void startCgiServer();
static void startTCPServer();
};
#endif