1159 lines
43 KiB
C++
1159 lines
43 KiB
C++
#include "SH_SqlDB.hpp"
|
|
#include "../API_log/SH_log.h"
|
|
#include "../common/SH_global.h"
|
|
#include <unistd.h>
|
|
#include "../calculation/Calculation.hpp"
|
|
|
|
bool SqlSwitch()
|
|
{
|
|
if (access("./sql", 0) >= 0) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
SqliteDB *sql_ctl = SqliteDB::instance();
|
|
Calculation *pCalculation = Calculation::instance();
|
|
|
|
SqliteDB::SqliteDB()
|
|
{
|
|
}
|
|
|
|
SqliteDB::~SqliteDB()
|
|
{
|
|
}
|
|
|
|
void SqliteDB::SqliteInit(const char *pDbName, bool isDB2)
|
|
{
|
|
char sql_exec[2048];
|
|
memset(sql_exec, 0, 2048);
|
|
|
|
//创建传感器信息存储表
|
|
memset(sql_exec, 0, 2048);
|
|
sprintf(sql_exec, "create table if not exists %s(%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s);",
|
|
T_SENSOR_INFO(TNAME),
|
|
T_SENSOR_INFO(DATANODENO),
|
|
T_SENSOR_INFO(DATANODENAME),
|
|
T_SENSOR_INFO(INITFLAG),
|
|
T_SENSOR_INFO(ACCFLAG),
|
|
T_SENSOR_INFO(ZIGBEEFLAG),
|
|
T_SENSOR_INFO(TEMTOPFLAG),
|
|
T_SENSOR_INFO(TEMBOTFLAG),
|
|
T_SENSOR_INFO(EQUIPSTA),
|
|
T_SENSOR_INFO(HARDVERSION),
|
|
T_SENSOR_INFO(SOFTVERSION),
|
|
T_SENSOR_INFO(BPNO),
|
|
T_SENSOR_INFO(SERIALNO),
|
|
T_SENSOR_INFO(FIRSTPOWERNO),
|
|
"WakeupTime",
|
|
"StaticTime",
|
|
"WaveTime",
|
|
"BateryV",
|
|
"ProductNo",
|
|
T_SENSOR_INFO(CONFIGFLAG),
|
|
T_SENSOR_INFO(STARTBRANDS),
|
|
T_SENSOR_INFO(STOPBRANDS),
|
|
T_SENSOR_INFO(FEATUREINTERVAL),
|
|
T_SENSOR_INFO(WAVEINTERVAL),
|
|
T_SENSOR_INFO(SAMPLINGRATE),
|
|
T_SENSOR_INFO(SCOPE),
|
|
T_SENSOR_INFO(RANGE),
|
|
T_SENSOR_INFO(ENVELOPEBANDPASS),
|
|
T_SENSOR_INFO(FAULTFREQUENCY),
|
|
T_SENSOR_INFO(ZIGBEEPANID),
|
|
T_SENSOR_INFO(ZIGBEECHANNEL),
|
|
T_SENSOR_INFO(ZIGBEESHORTADDR),
|
|
T_SENSOR_INFO(ZIGBEELONGADDR),
|
|
T_SENSOR_INFO(ZIGBEEDESADDR),
|
|
"ZigbeePower",
|
|
"ZigbeeRetry",
|
|
"ZigbeeRetryGap",
|
|
"ACCSampleTime",
|
|
T_SENSOR_INFO(STATUS),
|
|
T_SENSOR_INFO(TIMESTAMP),
|
|
T_SENSOR_INFO(VIFF),
|
|
T_SENSOR_INFO(RSSI),
|
|
"UpdateFlag",
|
|
"LooseValue",
|
|
"batteryPower"),
|
|
CreateTable(sql_exec, isDB2);
|
|
|
|
int iRet = GetTableRows(" sqlite_master "," name = 't_sensor_info' and sql LIKE '%LooseValue%' ");
|
|
if(iRet == 0){
|
|
CreateTable("ALTER TABLE t_sensor_info ADD COLUMN 'LooseValue'");
|
|
}
|
|
|
|
iRet = GetTableRows(" sqlite_master "," name = 't_sensor_info' and sql LIKE '%batteryPower%' ");
|
|
if(iRet == 0){
|
|
CreateTable("ALTER TABLE t_sensor_info ADD COLUMN 'batteryPower'");
|
|
}
|
|
|
|
//创建传感器数据存储表
|
|
memset(sql_exec, 0, 2048);
|
|
sprintf(sql_exec, "create table if not exists %s(%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s integer,%s,%s);",
|
|
T_DATA_INFO(TNAME),
|
|
T_DATA_INFO(DATANODENO),
|
|
T_DATA_INFO(CHANNELID),
|
|
T_DATA_INFO(DIAGNOSISEAK),
|
|
T_DATA_INFO(INTEGRATPK),
|
|
T_DATA_INFO(INTEGRATRMS),
|
|
T_DATA_INFO(RMSVALUES),
|
|
T_DATA_INFO(ENVELOPNERGY),
|
|
T_DATA_INFO(AMP1),
|
|
T_DATA_INFO(AMP2),
|
|
T_DATA_INFO(AMP3),
|
|
T_DATA_INFO(AMP4),
|
|
T_DATA_INFO(AMP5),
|
|
T_DATA_INFO(PHASE1),
|
|
T_DATA_INFO(PHASE2),
|
|
T_DATA_INFO(PHASE3),
|
|
T_DATA_INFO(PHASE4),
|
|
T_DATA_INFO(STATICINDEX),
|
|
T_DATA_INFO(TIMESTAMP),
|
|
T_DATA_INFO(SENDMSG),
|
|
T_DATA_INFO(NODERESEND));
|
|
CreateTable(sql_exec, isDB2);
|
|
|
|
iRet = GetTableRows(" sqlite_master "," name = 't_data_info' and sql LIKE '%nodeResend%' ");
|
|
if(iRet == 0){
|
|
CreateTable("ALTER TABLE t_data_info ADD COLUMN 'nodeResend'");
|
|
}
|
|
|
|
//创建传感器静态数据存储表
|
|
memset(sql_exec, 0, 2048);
|
|
sprintf(sql_exec, "create table if not exists %s(%s,%s,%s,%s,%s,%s,%s,%s integer,%s,%s);",
|
|
T_DATASTATIC_INFO(TNAME),
|
|
T_DATASTATIC_INFO(DATANODENO),
|
|
T_DATASTATIC_INFO(CHANNELID),
|
|
T_DATASTATIC_INFO(TEMTOP),
|
|
T_DATASTATIC_INFO(TEMBOT),
|
|
T_DATASTATIC_INFO(DIP),
|
|
T_DATASTATIC_INFO(VOLTAGE),
|
|
"Battery",
|
|
T_DATASTATIC_INFO(STATICINDEX),
|
|
T_DATASTATIC_INFO(TIMESTAMP),
|
|
T_DATASTATIC_INFO(SENDMSG),
|
|
T_DATASTATIC_INFO(NODERESEND));
|
|
CreateTable(sql_exec, isDB2);
|
|
iRet = GetTableRows(" sqlite_master "," name = 't_datastatic_info' and sql LIKE '%nodeResend%' ");
|
|
if(iRet == 0){
|
|
CreateTable("ALTER TABLE t_datastatic_info ADD COLUMN 'nodeResend'");
|
|
}
|
|
|
|
memset(sql_exec, 0, 2048);
|
|
sprintf(sql_exec, "create table if not exists %s(%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s);",
|
|
T_GATEWAY_INFO(TNAME),
|
|
T_GATEWAY_INFO(GATEWAYMAC),
|
|
T_GATEWAY_INFO(SENSORVER),
|
|
T_GATEWAY_INFO(GATEWAYLOCATION),
|
|
T_GATEWAY_INFO(ZIGBEEPANID),
|
|
T_GATEWAY_INFO(ZIGBEECHANNEL),
|
|
T_GATEWAY_INFO(COMMUNICATIONTYPE),
|
|
T_GATEWAY_INFO(SIGNAL),
|
|
T_GATEWAY_INFO(LOCALIP),
|
|
T_GATEWAY_INFO(SYSTEMVERSION),
|
|
T_GATEWAY_INFO(PROGRAMVERSION),
|
|
T_GATEWAY_INFO(WEBVERSION),
|
|
T_GATEWAY_INFO(SERVERIP),
|
|
T_GATEWAY_INFO(SERVERPORT),
|
|
T_GATEWAY_INFO(STATUS),
|
|
T_GATEWAY_INFO(GATEWAYUPDATE),
|
|
T_GATEWAY_INFO(MAC2));
|
|
CreateTable(sql_exec, isDB2);
|
|
|
|
memset(sql_exec, 0, 2048);
|
|
sprintf(sql_exec, "create table if not exists %s(%s,%s,%s,%s,%s);",
|
|
"t_data_waveSend","channelID","waveName","timeStamp","sendMsg","save");
|
|
CreateTable(sql_exec, isDB2);
|
|
|
|
iRet = GetTableRows(" sqlite_master "," name = 't_data_waveSend' and sql LIKE '%sendMsg%' ");
|
|
if(iRet == 0){
|
|
CreateTable("ALTER TABLE t_data_waveSend ADD COLUMN 'sendMsg'");
|
|
}
|
|
iRet = GetTableRows(" sqlite_master "," name = 't_data_waveSend' and sql LIKE '%save%' ");
|
|
if(iRet == 0){
|
|
CreateTable("ALTER TABLE t_data_waveSend ADD COLUMN 'save'");
|
|
}
|
|
/*memset(sql_exec, 0, 2048);
|
|
sprintf(sql_exec, "create table if not exists %s(%s,%s,%s,%s,%s integer,%s integer ,%s integer ,%s integer,%s integer);",
|
|
T_DATANODE_TIME(TNAME),
|
|
T_DATANODE_TIME(DATANODENO),
|
|
T_DATANODE_TIME(SHORTADDR),
|
|
T_DATANODE_TIME(STATICCYCLE),
|
|
T_DATANODE_TIME(WAVECYCLE),
|
|
T_DATANODE_TIME(NODEGROUP),
|
|
T_DATANODE_TIME(NODEINDEX),
|
|
T_DATANODE_TIME(NODEWAVEINDEX),
|
|
T_DATANODE_TIME(STATICTIME),
|
|
T_DATANODE_TIME(STATICSTARTTIME));
|
|
CreateTable(sql_exec, isDB2);*/
|
|
|
|
}
|
|
void SqliteDB::Createtable(const char *ptableName)
|
|
{
|
|
char sql_exec[2048];
|
|
//创建传感器数据存储表
|
|
memset(sql_exec, 0, 2048);
|
|
sprintf(sql_exec, "create table if not exists %s(%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s integer,%s,%s,%s);",
|
|
ptableName,
|
|
T_DATA_INFO(DATANODENO),
|
|
T_DATA_INFO(CHANNELID),
|
|
T_DATA_INFO(DIAGNOSISEAK),
|
|
T_DATA_INFO(INTEGRATPK),
|
|
T_DATA_INFO(INTEGRATRMS),
|
|
T_DATA_INFO(RMSVALUES),
|
|
T_DATA_INFO(ENVELOPNERGY),
|
|
T_DATA_INFO(AMP1),
|
|
T_DATA_INFO(AMP2),
|
|
T_DATA_INFO(AMP3),
|
|
T_DATA_INFO(AMP4),
|
|
T_DATA_INFO(AMP5),
|
|
T_DATA_INFO(PHASE1),
|
|
T_DATA_INFO(PHASE2),
|
|
T_DATA_INFO(PHASE3),
|
|
T_DATA_INFO(PHASE4),
|
|
"StaticIndex",
|
|
T_DATA_INFO(TIMESTAMP),
|
|
"sendMsg",
|
|
"nodeResend");
|
|
CreateTable(sql_exec, 0);
|
|
memset(sql_exec, 0, 2048);
|
|
sprintf(sql_exec,"CREATE INDEX %s_1 \
|
|
ON %s (%s)",ptableName,ptableName,T_DATA_INFO(DATANODENO));
|
|
CreateTable(sql_exec, 0);
|
|
}
|
|
|
|
void SqliteDB::SqliteInitDel(const char *pDbName)
|
|
{
|
|
Deletetable(T_DATA_INFO(TNAME));
|
|
Deletetable(T_DATASTATIC_INFO(TNAME));
|
|
vec_t vecResult = GetDataMultiLineOfOneColumn(T_SENSOR_INFO(TNAME),T_SENSOR_INFO(ZIGBEELONGADDR),NULL);
|
|
for(int i = 0; i < vecResult.size() && vecResult.size() > 0;i++)
|
|
{
|
|
char sztableName[100]={0x00};
|
|
sprintf(sztableName,"t_data_%s",vecResult[i].c_str());
|
|
Deletetable(sztableName);
|
|
sprintf(sztableName,"t_dataStatic_%s",vecResult[i].c_str());
|
|
Deletetable(sztableName);
|
|
}
|
|
}
|
|
void SqliteDB::Deletetable(const char *ptableName)
|
|
{
|
|
char sql_exec[2048];
|
|
//创建传感器数据存储表
|
|
memset(sql_exec, 0, 2048);
|
|
sprintf(sql_exec,"DROP TABLE %s ;",ptableName);
|
|
int iRet = sqlite3_exec(GetDbHandle(false), sql_exec, 0, 0, NULL);
|
|
if (iRet != SQLITE_OK) {
|
|
perror_info("sqlite3_exec");
|
|
}
|
|
|
|
}
|
|
void SqliteDB::CreatedataStatictable(const char *ptableName)
|
|
{
|
|
char sql_exec[2048];
|
|
//创建传感器数据存储表
|
|
memset(sql_exec, 0, 2048);
|
|
sprintf(sql_exec, "create table if not exists %s(%s,%s,%s,%s,%s,%s,%s,%s integer,%s,%s,%s);",
|
|
ptableName,
|
|
T_DATASTATIC_INFO(DATANODENO),
|
|
T_DATASTATIC_INFO(CHANNELID),
|
|
T_DATASTATIC_INFO(TEMTOP),
|
|
T_DATASTATIC_INFO(TEMBOT),
|
|
T_DATASTATIC_INFO(DIP),
|
|
T_DATASTATIC_INFO(VOLTAGE),
|
|
"zigbeeSignal",
|
|
"StaticIndex",
|
|
T_DATASTATIC_INFO(TIMESTAMP),
|
|
"sendMsg",
|
|
"nodeResend"
|
|
//"zigbeeRSSIType"
|
|
);
|
|
CreateTable(sql_exec, 0);
|
|
memset(sql_exec, 0, 2048);
|
|
sprintf(sql_exec,"CREATE INDEX %s_1 \
|
|
ON %s (%s)",ptableName,ptableName,T_DATA_INFO(DATANODENO));
|
|
CreateTable(sql_exec, 0);
|
|
}
|
|
bool SqliteDB::OpenDB(const char *pDbName, bool isDB2)
|
|
{
|
|
if (isDB2 == false) {
|
|
int ret = 0;
|
|
ret = sqlite3_open(pDbName, &mDBAcess);
|
|
if (ret == SQLITE_OK) {
|
|
sqlite3_exec(mDBAcess, "PRAGMA synchronous = NORMAL;", 0, 0, 0);
|
|
sqlite3_exec(mDBAcess, "PRAGMA cache_size=8000;", 0, 0, 0);
|
|
sqlite3_exec(mDBAcess, "PRAGMA temp_store = MEMORY;", 0, 0, 0);
|
|
sqlite3_exec(mDBAcess, "PRAGMA auto_vacuum = 1;", 0, 0, 0);
|
|
print_info("Success To Open DataBase!\n");
|
|
}
|
|
else {
|
|
print_error("Fail To Open DataBase!\n");
|
|
return false;
|
|
}
|
|
}
|
|
else {
|
|
int ret = 0;
|
|
ret = sqlite3_open(pDbName, &mDb2);
|
|
if (ret == SQLITE_OK) {
|
|
sqlite3_exec(mDb2, "PRAGMA synchronous = NORMAL;", 0, 0, 0);
|
|
sqlite3_exec(mDb2, "PRAGMA cache_size=8000;", 0, 0, 0);
|
|
sqlite3_exec(mDb2, "PRAGMA temp_store = MEMORY;", 0, 0, 0);
|
|
sqlite3_exec(mDb2, "PRAGMA auto_vacuum = 1;", 0, 0, 0);
|
|
print_info("Success To Open DataBase!\n");
|
|
}
|
|
else {
|
|
print_error("Fail To Open DataBase!\n");
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
int SqliteDB::CloseDB()
|
|
{
|
|
return sqlite3_close(mDBAcess);
|
|
}
|
|
|
|
sqlite3 *SqliteDB::GetDbHandle(bool isDB2)
|
|
{
|
|
if (isDB2 == false) {
|
|
return mDBAcess;
|
|
}
|
|
else {
|
|
return mDb2;
|
|
}
|
|
}
|
|
|
|
int SqliteDB::CreateTable(const char *sql, bool isDB2)
|
|
{
|
|
print_light_green("%s\n", sql);
|
|
// if (SqlSwitch()) log_system->log_write_system("[info]","%s\n", sql);
|
|
char *msg;
|
|
int iRet = sqlite3_exec(GetDbHandle(isDB2), sql, 0, 0, &msg);
|
|
if (iRet != SQLITE_OK) {
|
|
print_error("sqlite3 error: code=%d msg=%s\n", iRet, msg);
|
|
sqlite3_free(msg);
|
|
}
|
|
return iRet;
|
|
}
|
|
|
|
int SqliteDB::GetTableColumnCount(const char *tablename, bool isDB2)
|
|
{
|
|
std::string strSql = "select * from ";
|
|
int count = 0;
|
|
sqlite3_stmt *stmt;
|
|
strSql = strSql + tablename + ";";
|
|
print_light_green("%s\n", strSql.c_str());
|
|
// if (SqlSwitch()) log_system->log_write_system("[info]","%s\n", strSql.c_str());
|
|
sqlite3_prepare_v2(GetDbHandle(isDB2), strSql.c_str(), -1, &stmt, 0);
|
|
count = sqlite3_column_count(stmt);
|
|
sqlite3_finalize(stmt);
|
|
return count;
|
|
}
|
|
|
|
int SqliteDB::GetTableRows(const char *tablename, const char *whereCon)
|
|
{
|
|
int nRow = 0;
|
|
std::string strSql = "select count(*) from ";
|
|
if (whereCon != NULL) {
|
|
strSql = strSql + tablename + " where " + whereCon + ";";
|
|
}
|
|
else {
|
|
strSql = strSql + tablename + ";";
|
|
}
|
|
print_light_green("%s\n", strSql.c_str());
|
|
// if (SqlSwitch()) log_system->log_write_system("[info]","%s\n", strSql.c_str());
|
|
sqlite3_stmt *stmt;
|
|
if (sqlite3_prepare_v2(mDBAcess, strSql.c_str(), -1, &stmt, 0) != SQLITE_OK) {
|
|
print_error("sqlite3_prepare_v2:%s\n",sqlite3_errmsg(mDBAcess));
|
|
sqlite3_finalize(stmt);
|
|
return -1;
|
|
}
|
|
int retStep = sqlite3_step(stmt);
|
|
if (retStep == SQLITE_ROW) {
|
|
nRow = sqlite3_column_int(stmt, 0);
|
|
}
|
|
sqlite3_finalize(stmt);
|
|
return nRow;
|
|
}
|
|
|
|
int SqliteDB::AlterTable(const char *tablename, const char *column, bool isAdd, bool isDB2)
|
|
{
|
|
int iRet = SQLITE_ERROR;
|
|
if (isAdd) {
|
|
std::string strSql = "alter table ";
|
|
strSql = strSql + tablename + " add " + column + ";";
|
|
print_light_green("%s\n", strSql.c_str());
|
|
// if (SqlSwitch()) log_system->log_write_system("[info]","%s\n", strSql.c_str());
|
|
iRet = sqlite3_exec(GetDbHandle(isDB2), strSql.c_str(), 0, 0, NULL);
|
|
if (iRet != SQLITE_OK) {
|
|
perror_info("sqlite3_exec");
|
|
}
|
|
}
|
|
else {
|
|
}
|
|
return iRet;
|
|
}
|
|
|
|
vec_t SqliteDB::GetDataSingleLine(const char *tablename, const char *column, const char *whereCon)
|
|
{
|
|
vec_t vecResult;
|
|
std::string strSql = "select ";
|
|
if (whereCon != NULL) {
|
|
strSql = strSql + column + " from " + tablename + " where " + whereCon + ";";
|
|
}
|
|
else {
|
|
strSql = strSql + column + " from " + tablename + ";";
|
|
}
|
|
print_light_green("%s\n", strSql.c_str());
|
|
// if (SqlSwitch()) log_system->log_write_system("[info]","%s\n", strSql.c_str());
|
|
sqlite3_stmt *stmt;
|
|
if (sqlite3_prepare_v2(mDBAcess, strSql.c_str(), -1, &stmt, 0) != SQLITE_OK) {
|
|
print_error("sqlite3_prepare_v2:%s\n", sqlite3_errmsg(mDBAcess));
|
|
sqlite3_finalize(stmt);
|
|
return vecResult;
|
|
}
|
|
int retStep = sqlite3_step(stmt);
|
|
int column_count = sqlite3_column_count(stmt);
|
|
if (retStep == SQLITE_ROW) {
|
|
for (int iCol = 0; iCol < column_count; iCol++) {
|
|
char *columninfo = (char*)sqlite3_column_text(stmt, iCol);
|
|
std::string str = columninfo != NULL ? columninfo : "";
|
|
vecResult.push_back(str);
|
|
}
|
|
}
|
|
sqlite3_finalize(stmt);
|
|
return vecResult;
|
|
}
|
|
|
|
char* SqliteDB::GetDataChar(const char *tablename, const char *column, const char *whereCon)
|
|
{
|
|
char szRes[100]={0x00};
|
|
std::string strSql = "select ";
|
|
if (whereCon != NULL) {
|
|
strSql = strSql + column + " from " + tablename + " where " + whereCon + ";";
|
|
}
|
|
else {
|
|
strSql = strSql + column + " from " + tablename + ";";
|
|
}
|
|
print_light_green("%s\n", strSql.c_str());
|
|
// if (SqlSwitch()) log_system->log_write_system("[info]","%s\n", strSql.c_str());
|
|
sqlite3_stmt *stmt;
|
|
if (sqlite3_prepare_v2(mDBAcess, strSql.c_str(), -1, &stmt, 0) != SQLITE_OK) {
|
|
print_error("sqlite3_prepare_v2:%s\n", sqlite3_errmsg(mDBAcess));
|
|
sqlite3_finalize(stmt);
|
|
return NULL;
|
|
}
|
|
int retStep = sqlite3_step(stmt);
|
|
if (retStep == SQLITE_ROW) {
|
|
char *columninfo = (char*)sqlite3_column_text(stmt, 0);
|
|
memcpy(szRes,columninfo,sizeof(szRes));
|
|
}
|
|
sqlite3_finalize(stmt);
|
|
return szRes;
|
|
}
|
|
|
|
std::string SqliteDB::GetData(const char *tablename, const char *column, const char *whereCon)
|
|
{
|
|
std::string strRes = "";
|
|
std::string strSql = "select ";
|
|
if (whereCon != NULL) {
|
|
strSql = strSql + column + " from " + tablename + " where " + whereCon + ";";
|
|
}
|
|
else {
|
|
strSql = strSql + column + " from " + tablename + ";";
|
|
}
|
|
print_light_green("%s\n", strSql.c_str());
|
|
// if (SqlSwitch()) log_system->log_write_system("[info]","%s\n", strSql.c_str());
|
|
sqlite3_stmt *stmt;
|
|
g_tDbMutex.Lock();
|
|
if (sqlite3_prepare_v2(mDBAcess, strSql.c_str(), -1, &stmt, 0) != SQLITE_OK) {
|
|
print_error("sqlite3_prepare_v2:%s\n", sqlite3_errmsg(mDBAcess));
|
|
sqlite3_finalize(stmt);
|
|
g_tDbMutex.UnLock();
|
|
return strRes;
|
|
}
|
|
int retStep = sqlite3_step(stmt);
|
|
if (retStep == SQLITE_ROW) {
|
|
char *columninfo = (char*)sqlite3_column_text(stmt, 0);
|
|
strRes = columninfo != NULL ? columninfo : "";
|
|
}
|
|
sqlite3_finalize(stmt);
|
|
g_tDbMutex.UnLock();
|
|
return strRes;
|
|
}
|
|
|
|
array_t SqliteDB::GetDataMultiLine(const char *tablename, const char *column, const char *whereCon)
|
|
{
|
|
array_t arrResult;
|
|
std::string strSql = "select ";
|
|
if (whereCon != NULL) {
|
|
strSql = strSql + column + " from " + tablename + " where " + whereCon + ";";
|
|
}
|
|
else {
|
|
strSql = strSql + column + " from " + tablename + ";";
|
|
}
|
|
|
|
print_light_green("%s\n", strSql.c_str());
|
|
// if (SqlSwitch()) log_system->log_write_system("[info]","%s\n", strSql.c_str());
|
|
sqlite3_stmt *stmt;
|
|
g_tDbMutex.Lock();
|
|
if (sqlite3_prepare_v2(mDBAcess, strSql.c_str(), -1, &stmt, 0) != SQLITE_OK) {
|
|
print_error("sqlite3_prepare_v2:%s\n", sqlite3_errmsg(mDBAcess));
|
|
sqlite3_finalize(stmt);
|
|
g_tDbMutex.UnLock();
|
|
return arrResult;
|
|
}
|
|
int retStep = sqlite3_step(stmt);
|
|
int column_count = sqlite3_column_count(stmt);
|
|
while (retStep == SQLITE_ROW) {
|
|
vec_t vecResult;
|
|
for (int iCol = 0; iCol < column_count; iCol++) {
|
|
char *columninfo = (char*)sqlite3_column_text(stmt, iCol);
|
|
std::string str = columninfo != NULL ? columninfo : "";
|
|
vecResult.push_back(str);
|
|
}
|
|
arrResult.push_back(vecResult);
|
|
retStep = sqlite3_step(stmt);
|
|
}
|
|
sqlite3_finalize(stmt);
|
|
g_tDbMutex.UnLock();
|
|
return arrResult;
|
|
}
|
|
array_t SqliteDB::GetDataMultiLineTransaction(const char *tablename, const char *column, const char *whereCon)
|
|
{
|
|
array_t arrResult;
|
|
std::string strSql = "select ";
|
|
if (whereCon != NULL) {
|
|
strSql = strSql + column + " from " + tablename + " where " + whereCon + ";";
|
|
}
|
|
else {
|
|
strSql = strSql + column + " from " + tablename + ";";
|
|
}
|
|
print_light_green("%s\n", strSql.c_str());
|
|
// if (SqlSwitch()) log_system->log_write_system("[info]","%s\n", strSql.c_str());
|
|
|
|
sqlite3_exec(mDBAcess, "BEGIN", 0, 0, NULL);
|
|
sqlite3_stmt *stmt;
|
|
if (sqlite3_prepare_v2(mDBAcess, strSql.c_str(), -1, &stmt, 0) != SQLITE_OK) {
|
|
print_error("sqlite3_prepare_v2:%s\n", sqlite3_errmsg(mDBAcess));
|
|
sqlite3_finalize(stmt);
|
|
return arrResult;
|
|
}
|
|
sqlite3_reset(stmt);
|
|
sqlite3_bind_int(stmt, 1, 0);
|
|
int retStep = sqlite3_step(stmt);
|
|
int column_count = sqlite3_column_count(stmt);
|
|
while (retStep == SQLITE_ROW) {
|
|
vec_t vecResult;
|
|
for (int iCol = 0; iCol < column_count; iCol++) {
|
|
char *columninfo = (char*)sqlite3_column_text(stmt, iCol);
|
|
std::string str = columninfo != NULL ? columninfo : "";
|
|
vecResult.push_back(str);
|
|
}
|
|
arrResult.push_back(vecResult);
|
|
retStep = sqlite3_step(stmt);
|
|
}
|
|
sqlite3_finalize(stmt);
|
|
sqlite3_exec(mDBAcess, "COMMIT", 0, 0, NULL);
|
|
return arrResult;
|
|
}
|
|
vec_t SqliteDB::GetDataMultiLineOfOneColumn(const char *tablename, const char *column, const char *whereCon)
|
|
{
|
|
vec_t vecResult;
|
|
std::string strSql = "select ";
|
|
if (whereCon != NULL) {
|
|
strSql = strSql + column + " from " + tablename + " where " + whereCon + ";";
|
|
}
|
|
else {
|
|
strSql = strSql + column + " from " + tablename + ";";
|
|
}
|
|
print_light_green("%s\n", strSql.c_str());
|
|
// if (SqlSwitch()) log_system->log_write_system("[info]","%s\n", strSql.c_str());
|
|
sqlite3_stmt *stmt;
|
|
if (sqlite3_prepare_v2(mDBAcess, strSql.c_str(), -1, &stmt, 0) != SQLITE_OK) {
|
|
print_error("sqlite3_prepare_v2:%s\n", sqlite3_errmsg(mDBAcess));
|
|
sqlite3_finalize(stmt);
|
|
return vecResult;
|
|
}
|
|
int retStep = sqlite3_step(stmt);
|
|
while (retStep == SQLITE_ROW) {
|
|
char *columninfo = (char*)sqlite3_column_text(stmt, 0);
|
|
std::string str = columninfo != NULL ? columninfo : "";
|
|
vecResult.push_back(str);
|
|
retStep = sqlite3_step(stmt);
|
|
}
|
|
sqlite3_finalize(stmt);
|
|
return vecResult;
|
|
}
|
|
vec_Value SqliteDB::GetDataMultiLineOfOneColumnDouble(const char *tablename, const char *column, const char *whereCon)
|
|
{
|
|
vec_Value vecResult;
|
|
std::string strSql = "select ";
|
|
if (whereCon != NULL) {
|
|
strSql = strSql + column + " from " + tablename + " where " + whereCon + ";";
|
|
}
|
|
else {
|
|
strSql = strSql + column + " from " + tablename + ";";
|
|
}
|
|
print_light_green("%s\n", strSql.c_str());
|
|
// if (SqlSwitch()) log_system->log_write_system("[info]","%s\n", strSql.c_str());
|
|
sqlite3_stmt *stmt;
|
|
if (sqlite3_prepare_v2(mDBAcess, strSql.c_str(), -1, &stmt, 0) != SQLITE_OK) {
|
|
print_error("sqlite3_prepare_v2:%s\n", sqlite3_errmsg(mDBAcess));
|
|
sqlite3_finalize(stmt);
|
|
return vecResult;
|
|
}
|
|
int retStep = sqlite3_step(stmt);
|
|
while (retStep == SQLITE_ROW) {
|
|
double columninfo = sqlite3_column_double(stmt, 0);
|
|
vecResult.push_back(columninfo);
|
|
retStep = sqlite3_step(stmt);
|
|
}
|
|
sqlite3_finalize(stmt);
|
|
return vecResult;
|
|
}
|
|
|
|
|
|
int SqliteDB::DeleteTableData(const char* tablename, const char* whereCond, bool isDB2)
|
|
{
|
|
std::string strSql = "delete from ";
|
|
if (whereCond != NULL) {
|
|
strSql = strSql + tablename + " where " + whereCond + ";";
|
|
}
|
|
else {
|
|
strSql = strSql + tablename + ";";
|
|
}
|
|
// LOG_INFO("strSql = %s",strSql.c_str());
|
|
print_light_green("%s\n", strSql.c_str());
|
|
// if (SqlSwitch()) log_system->log_write_system("[info]","%s\n", strSql.c_str());
|
|
char *msg;
|
|
int iRet = sqlite3_exec(GetDbHandle(isDB2), strSql.c_str(), 0, 0, &msg);
|
|
|
|
if (iRet != SQLITE_OK) {
|
|
print_error("sqlite3 error: code=%d msg=%s\n", iRet, msg);
|
|
sqlite3_free(msg);
|
|
}
|
|
return iRet;
|
|
}
|
|
|
|
int SqliteDB::DeleteTableDataOneConditon(const char* tablename, const char* condColumnName, const char * condColumnValue, bool isDB2)
|
|
{
|
|
std::string strSql = "delete from ";
|
|
if (condColumnName != NULL) {
|
|
strSql = strSql + tablename + " where " + condColumnName + "='" + condColumnValue + "';";
|
|
}
|
|
else {
|
|
strSql = strSql + tablename + ";";
|
|
}
|
|
print_light_green("%s\n", strSql.c_str());
|
|
// if (SqlSwitch()) log_system->log_write_system("[info]","%s\n", strSql.c_str());
|
|
char *msg;
|
|
int iRet = sqlite3_exec(GetDbHandle(isDB2), strSql.c_str(), 0, 0, &msg);
|
|
|
|
if (iRet != SQLITE_OK) {
|
|
print_error("sqlite3 error: code=%d msg=%s\n", iRet, msg);
|
|
sqlite3_free(msg);
|
|
}
|
|
return iRet;
|
|
}
|
|
int SqliteDB::UpdateNodeNameData(const char* tablename, const char* updateColumn, const char* whereCond, bool isDB2)
|
|
{
|
|
std::string strSql = "update ";
|
|
char szSql[1024] = {0x00};
|
|
strcat(szSql,"update ");
|
|
if (whereCond != NULL) {
|
|
strcat(szSql,tablename);
|
|
strcat(szSql," set ");
|
|
strcat(szSql,updateColumn);
|
|
strcat(szSql," where ");
|
|
strcat(szSql,whereCond);
|
|
strcat(szSql,";");
|
|
strSql = strSql + tablename + " set " + updateColumn + " where " + whereCond + ";";
|
|
}
|
|
else {
|
|
strSql = strSql + tablename + " set " + updateColumn + ";";
|
|
}
|
|
print_light_green("%s\n", strSql.c_str());
|
|
// if (SqlSwitch()) log_system->log_write_system("[info]","%s\n", strSql.c_str());
|
|
char *msg;
|
|
int iRet = sqlite3_exec(GetDbHandle(isDB2), szSql, 0, 0, &msg);
|
|
|
|
if (iRet != SQLITE_OK) {
|
|
print_error("sqlite3 error: code=%d msg=%s\n", iRet, msg);
|
|
sqlite3_free(msg);
|
|
}
|
|
return iRet;
|
|
}
|
|
int SqliteDB::UpdateTableData(const char* tablename, const char* updateColumn, const char* whereCond, bool isDB2)
|
|
{
|
|
std::string strSql = "update ";
|
|
if (whereCond != NULL) {
|
|
strSql = strSql + tablename + " set " + updateColumn + " where " + whereCond + ";";
|
|
}
|
|
else {
|
|
strSql = strSql + tablename + " set " + updateColumn + ";";
|
|
}
|
|
print_light_green("%s\n", strSql.c_str());
|
|
// if (SqlSwitch()) log_system->log_write_system("[info]","%s\n", strSql.c_str());
|
|
char *msg;
|
|
g_tDbMutex.Lock();
|
|
int iRet = sqlite3_exec(GetDbHandle(isDB2), strSql.c_str(), 0, 0, &msg);
|
|
|
|
if (iRet != SQLITE_OK) {
|
|
print_error("sqlite3 error: code=%d msg=%s\n", iRet, msg);
|
|
sqlite3_free(msg);
|
|
}
|
|
g_tDbMutex.UnLock();
|
|
return iRet;
|
|
}
|
|
|
|
int SqliteDB::UpdateTableData(const char* directSql, bool isDB2)
|
|
{
|
|
print_light_green("%s\n", directSql);
|
|
// if (SqlSwitch()) log_system->log_write_system("[info]","%s\n", directSql);
|
|
char *msg;
|
|
int iRet = sqlite3_exec(GetDbHandle(isDB2), directSql, 0, 0, &msg);
|
|
|
|
if (iRet != SQLITE_OK) {
|
|
print_error("sqlite3 error: code=%d msg=%s\n", iRet, msg);
|
|
sqlite3_free(msg);
|
|
}
|
|
return iRet;
|
|
}
|
|
|
|
int SqliteDB::UpdateTableDataOneColumn(const char* tablename, const char* columnName, const char* columnValue, const char* whereColName, const char * whereColValue, bool isDB2)
|
|
{
|
|
std::string strSql = "update ";
|
|
if (whereColName != NULL) {
|
|
strSql = strSql + tablename + " set " + columnName + "='" + columnValue + "'" + " where " + whereColName + "='" + whereColValue + "';";
|
|
}
|
|
else {
|
|
strSql = strSql + tablename + " set " + columnName + "='" + columnValue + "';";
|
|
}
|
|
print_light_green("%s\n", strSql.c_str());
|
|
// if (SqlSwitch()) log_system->log_write_system("[info]","%s\n", strSql.c_str());
|
|
char *msg;
|
|
int iRet = sqlite3_exec(GetDbHandle(isDB2), strSql.c_str(), 0, 0, &msg);
|
|
|
|
if (iRet != SQLITE_OK) {
|
|
print_error("sqlite3 error: code=%d msg=%s\n", iRet, msg);
|
|
sqlite3_free(msg);
|
|
}
|
|
return iRet;
|
|
}
|
|
|
|
int SqliteDB::InsertData(const char* tablename, const char* insertValues, int replace, bool expandable, bool isDB2)
|
|
{
|
|
char *msg;
|
|
int iRet = 0;
|
|
if (expandable) {
|
|
char *strSql = (char *)malloc(4096);
|
|
if (strSql == NULL) {
|
|
print_error("malloc error\n");
|
|
abort();
|
|
}
|
|
char strReplace[] = "replace into ";
|
|
memset(strSql, 0, 4096);
|
|
if (replace == 0) {
|
|
memset(strReplace, 0, sizeof(strSql));
|
|
}
|
|
sprintf(strSql, "%s %s%s %s %s %s", "insert into", strReplace, tablename, "values(", insertValues, ");");
|
|
print_light_green("%s\n", strSql);
|
|
// if (SqlSwitch()) log_system->log_write_system("[info]","%s\n", strSql);
|
|
iRet = sqlite3_exec(GetDbHandle(isDB2), strSql, 0, 0, &msg);
|
|
|
|
free(strSql);
|
|
} else {
|
|
std::string strSql = "insert into ";
|
|
if (replace != 0) {
|
|
strSql = "replace into ";
|
|
}
|
|
strSql = strSql + tablename + " values(" + insertValues + ");";
|
|
print_light_green("%s\n", strSql.c_str());
|
|
// if (SqlSwitch()) log_system->log_write_system("[info]","%s\n", strSql.c_str());
|
|
iRet = sqlite3_exec(GetDbHandle(isDB2), strSql.c_str(), 0, 0, &msg);
|
|
}
|
|
if (iRet != SQLITE_OK) {
|
|
print_error("sqlite3 error: code=%d msg=%s\n", iRet, msg);
|
|
sqlite3_free(msg);
|
|
}
|
|
return iRet;
|
|
}
|
|
int SqliteDB::InsertData(const char* insertSql)
|
|
{
|
|
char *msg;
|
|
int iRet = sqlite3_exec(GetDbHandle(false), insertSql, 0, 0, &msg);
|
|
if (iRet != SQLITE_OK) {
|
|
print_error("sqlite3 error: code=%d msg=%s\n", iRet, msg);
|
|
sqlite3_free(msg);
|
|
}
|
|
return iRet;
|
|
}
|
|
int SqliteDB::CalculateBattery()
|
|
{
|
|
float dayStaticPower = 6.5,dayWavePower = 237;//
|
|
char whereCon[1024] = {0};
|
|
char selectSql[1024] = { 0 };
|
|
memset(whereCon,0x00,sizeof(whereCon));
|
|
memset(selectSql,0x00,sizeof(selectSql));
|
|
sprintf(selectSql," DataNodeNo,StaticTime,WaveTime,featureInterVal,waveInterVal,samplingRate ");
|
|
array_t vecRes ;
|
|
vecRes = GetDataMultiLine(T_SENSOR_INFO(TNAME), selectSql, NULL);
|
|
if(vecRes.size() > 0){
|
|
for(int i = 0; i < vecRes.size(); i++){
|
|
if(vecRes[i][5] == "12800"){
|
|
|
|
}else if(vecRes[i][5] == "3200"){
|
|
|
|
}
|
|
float dayStaticTime = 0.0;
|
|
float dayWaveTime = 0.0;
|
|
if(atoi(vecRes[i][3].c_str()) == 0){
|
|
dayStaticTime = 0;
|
|
}else{
|
|
dayStaticTime = 24*60/atoi(vecRes[i][3].c_str());
|
|
}
|
|
if(atoi(vecRes[i][4].c_str()) == 0){
|
|
dayWaveTime = 0;
|
|
}else{
|
|
dayWaveTime = 24*60/atoi(vecRes[i][4].c_str());
|
|
}
|
|
|
|
float dayPower = dayStaticTime * dayStaticPower + dayWaveTime * dayWavePower + 24*3.26;//static + wave + sleep
|
|
float usePower = atoi(vecRes[i][1].c_str()) * dayStaticPower + atoi(vecRes[i][2].c_str()) * dayWavePower;
|
|
if(dayPower == 0)
|
|
dayPower = 1;
|
|
float remainDay = (19000000*0.5 - usePower)/dayPower;
|
|
float bateryProportion = remainDay/(19000000*0.5/dayPower);
|
|
char updateSql[1024] = { 0x00 };
|
|
char tmpParam[1024] = {0x00};
|
|
memset(whereCon,0x00,sizeof(whereCon));
|
|
memset(updateSql,0x00,sizeof(updateSql));
|
|
sprintf(whereCon,"dataNodeNo = '%s' ",vecRes[i][0].c_str());
|
|
sprintf(updateSql,"batteryPower = '%f,%f' ",bateryProportion,remainDay);
|
|
int iRet = UpdateTableData(T_SENSOR_INFO(TNAME), updateSql, whereCon);
|
|
print_info("iRet = %d\n",iRet);
|
|
string strData = sql_ctl->GetNodeConfigureInfor(whereCon);
|
|
data_publish(strData.c_str(), GlobalConfig::Topic_G.mPubConfig.c_str());
|
|
}
|
|
}
|
|
|
|
print_info("CalculateBattery \n");
|
|
return 0;
|
|
}
|
|
int SqliteDB::CalculateDip()
|
|
{
|
|
char whereCon[1024] = {0};
|
|
char selectSql[1024] = { 0 };
|
|
char updateSql[1024] = { 0 };
|
|
memset(whereCon,0x00,sizeof(whereCon));
|
|
memset(selectSql,0x00,sizeof(selectSql));
|
|
sprintf(selectSql," DataNodeNo");
|
|
array_t vecRes ;
|
|
vecRes = GetDataMultiLine(T_SENSOR_INFO(TNAME), selectSql, NULL);
|
|
for(int i = 0 ; i < vecRes.size(); i++){
|
|
char szTablename[32]={0x00};
|
|
sprintf(szTablename,"t_dataStatic_%s",vecRes[i][0].c_str());
|
|
vec_Value vecResDip = GetDataMultiLineOfOneColumnDouble(szTablename," Dip ", NULL);
|
|
float sample_variance = pCalculation->getSample_variance(vecResDip);
|
|
print_info("sample_variance = %f\n",sample_variance);
|
|
memset(whereCon,0x00,sizeof(whereCon));
|
|
memset(updateSql,0x00,sizeof(updateSql));
|
|
sprintf(whereCon,"dataNodeNo = '%s' ",vecRes[i][0].c_str());
|
|
sprintf(updateSql,"LooseValue = '%f' ",sample_variance);
|
|
UpdateTableData(T_SENSOR_INFO(TNAME),updateSql,whereCon);
|
|
}
|
|
}
|
|
int SqliteDB::InintGateway()
|
|
{
|
|
//更新网关配置表
|
|
string strIP = GetGwIp_("eth0");
|
|
string strServerIP = ReadStrByOpt(SERVERCONFIG, "Server", "localServerIpAddress");
|
|
string strServerPort = ReadStrByOpt(SERVERCONFIG, "Server", "localServerPort");
|
|
string strwebVersion = ReadStrByOpt(SYSTEMINFOFILE, "Version", "WebVersion");
|
|
string strsystemVersion = ReadStrByOpt(SYSTEMINFOFILE, "Version", "SystemVersion");
|
|
string strGatewayVersion = ReadStrByOpt(SYSTEMINFOFILE, "Version", "GateWayVersion");
|
|
std::string strchan = ReadStrByOpt(ZIGBEECONFIG, "Zigbee", "channel");
|
|
if(0 == sql_ctl->GetTableRows(T_GATEWAY_INFO(TNAME), NULL)){
|
|
|
|
char strSql[1024] = { 0 };
|
|
sprintf(strSql,"insert into t_gateway_info(gatewayMAC,zigbeePanID,zigbeeChannel,\
|
|
localIP,systemVersion,programVersion,webVersion,serverIP,serverPort,MAC2)\
|
|
values('%s','%s','%s','%s','%s','%s','%s','%s','%s','%s');",GlobalConfig::MacAddr_G.c_str(),GlobalConfig::MacAddr_G.substr(8).c_str(),strchan.c_str(),strIP.c_str(),\
|
|
strsystemVersion.c_str(),strGatewayVersion.c_str(),strwebVersion.c_str(),strServerIP.c_str(),strServerPort.c_str(),GlobalConfig::MacAddr_G2.c_str());
|
|
sql_ctl->InsertData(strSql);
|
|
print_info("strSql = %s\n",strSql);
|
|
}else{
|
|
char whereCon[1024] = {0};
|
|
char updateSql[1024] = { 0 };
|
|
sprintf(updateSql, "zigbeePanID = '%s',zigbeeChannel = '%s',localIP = '%s',systemVersion='%s',programVersion='%s',webVersion='%s',serverIP='%s',serverPort='%s'",\
|
|
GlobalConfig::MacAddr_G.substr(8).c_str(),strchan.c_str(),strIP.c_str(),\
|
|
strsystemVersion.c_str(),strGatewayVersion.c_str(),strwebVersion.c_str(),strServerIP.c_str(),strServerPort.c_str());
|
|
sprintf(whereCon, "gatewayMAC='%s'", GlobalConfig::MacAddr_G.c_str());
|
|
sql_ctl->UpdateTableData(T_GATEWAY_INFO(TNAME), updateSql, whereCon);
|
|
}
|
|
|
|
//上传网关配置到MQTT
|
|
Json::Value jsSystemSetting;
|
|
Json::Value jsBody;
|
|
Json::FastWriter showValue;
|
|
Json::Value jsonVal;
|
|
jsonVal.clear();
|
|
|
|
jsonVal["cmd"] = "23";
|
|
jsonVal["dataNodeGatewayNo"] = GlobalConfig::MacAddr_G;
|
|
jsSystemSetting["WebVersion"] = strwebVersion;
|
|
jsSystemSetting["SystemVersion"] = strsystemVersion;
|
|
jsSystemSetting["GateWayVersion"] = strGatewayVersion;
|
|
jsBody["localServerIpAddress"] = ReadStrByOpt(SERVERCONFIG, "Server", "localServerIpAddress");
|
|
jsBody["localServerPort"] = atoi(ReadStrByOpt(SERVERCONFIG, "Server", "localServerPort").c_str());
|
|
jsBody["CommMode"] = atoi(ReadStrByOpt(SERVERCONFIG, "Server", "CommMode").c_str());
|
|
jsBody["Password"] = (ReadStrByOpt(SERVERCONFIG, "Server", "Password"));
|
|
jsBody["UserName"] = (ReadStrByOpt(SERVERCONFIG, "Server", "UserName"));
|
|
std::string dataBody = showValue.write(jsBody);
|
|
jsonVal["cmdBody"] = dataBody;
|
|
data_publish(showValue.write(jsonVal).c_str(), GlobalConfig::Topic_G.mPubConfig.c_str());
|
|
|
|
jsBody.clear();
|
|
jsonVal["cmd"] = "25";
|
|
jsBody["dnsName"] = ReadStrByOpt(NETWORKCONFIG, "Net", "dnsName");
|
|
jsBody["networkPortStatus"] = ReadStrByOpt(NETWORKCONFIG, "Net", "networkPortStatus");
|
|
jsBody["gateway"] = ReadStrByOpt(NETWORKCONFIG, "Net", "gateway");
|
|
jsBody["subnetMask"] = ReadStrByOpt(NETWORKCONFIG, "Net", "subnetMask");
|
|
jsBody["dataWatchIpAddress"] = ReadStrByOpt(NETWORKCONFIG, "Net", "ipAddress");
|
|
jsBody["hostName"] = ReadStrByOpt(NETWORKCONFIG, "Net", "hostName");
|
|
|
|
dataBody = showValue.write(jsBody);
|
|
jsonVal["cmdBody"] = dataBody;
|
|
data_publish(showValue.write(jsonVal).c_str(), GlobalConfig::Topic_G.mPubConfig.c_str());
|
|
}
|
|
|
|
std::string SqliteDB::GetNodeConfigureInfor(const char* whereCon)
|
|
{
|
|
vec_t vecRes = GetDataSingleLine(T_SENSOR_INFO(TNAME), "*", whereCon);
|
|
printf("vecRes = %d\n",vecRes.size());
|
|
if(vecRes.size() < 1)
|
|
return "";
|
|
Json::Value jsSensorData;
|
|
Json::Value jsonVal;
|
|
jsonVal.clear();
|
|
jsonVal["dataNodeGatewayNo"] = GlobalConfig::MacAddr_G;
|
|
jsonVal["cmd"] = "26";
|
|
jsSensorData["dataNodeNo"] = vecRes[0];
|
|
jsSensorData["dataNodeName"] = vecRes[1];
|
|
jsSensorData["initFlag"] = atoi(vecRes[2].c_str());
|
|
jsSensorData["accFlag"] = atoi(vecRes[3].c_str());
|
|
jsSensorData["zigbeeFlag"] = atoi(vecRes[4].c_str());
|
|
jsSensorData["temTopFlag"] = atoi(vecRes[5].c_str());
|
|
jsSensorData["temBotFlag"] = atoi(vecRes[6].c_str());
|
|
jsSensorData["hardVersion"] = vecRes[8];
|
|
jsSensorData["softVersion"] = vecRes[9];
|
|
jsSensorData["bpNo"] = vecRes[10];
|
|
jsSensorData["serialNo"] = vecRes[11];
|
|
jsSensorData["firstPowerTime"] = vecRes[12];
|
|
jsSensorData["WakeupTime"] = atoi(vecRes[13].c_str());
|
|
jsSensorData["StaticTime"] = atoi(vecRes[14].c_str());
|
|
jsSensorData["WaveTime"] = atoi(vecRes[15].c_str());
|
|
jsSensorData["BateryV"] = vecRes[16];
|
|
jsSensorData["ProductNo"] = vecRes[17];
|
|
jsSensorData["configFlag"] = atoi(vecRes[18].c_str());
|
|
jsSensorData["startBrands"] = vecRes[19];
|
|
jsSensorData["stopBrands"] = vecRes[20];
|
|
jsSensorData["featureInterVal"] = (vecRes[21]);
|
|
jsSensorData["waveInterVal"] = atoi(vecRes[22].c_str());
|
|
jsSensorData["samplingRate"] = atoi(vecRes[23].c_str());
|
|
jsSensorData["range"] = atoi(vecRes[25].c_str());
|
|
jsSensorData["envelopeBandPass"] = vecRes[26];
|
|
jsSensorData["faultFrequency"] = vecRes[27];
|
|
jsSensorData["zigbeePanId"] = vecRes[28];
|
|
jsSensorData["zigbeeChannel"] = (vecRes[29]);
|
|
jsSensorData["zigbeeAddr"] = vecRes[30];
|
|
jsSensorData["zigbeeLongAddr"] = vecRes[31];
|
|
jsSensorData["zigbeeDesAddr"] = vecRes[32];
|
|
jsSensorData["ZigbeePower"] = atoi(vecRes[33].c_str());
|
|
jsSensorData["ZigbeeRetry"] = atoi(vecRes[34].c_str());
|
|
jsSensorData["ZigbeeRetryGap"] = atoi(vecRes[35].c_str());
|
|
jsSensorData["ACCSampleTime"] = atoi(vecRes[36].c_str());
|
|
jsSensorData["status"] = atoi(vecRes[37].c_str());
|
|
jsSensorData["timeStamp"] = vecRes[38];
|
|
jsSensorData["viff"] = atoi(vecRes[39].c_str());
|
|
jsSensorData["RSSI"] = atoi(vecRes[40].c_str());
|
|
jsSensorData["Update"] = atoi(vecRes[41].c_str());
|
|
jsSensorData["LooseValue"] = (vecRes[42].c_str());
|
|
jsSensorData["batteryPower"] = (vecRes[43].c_str());
|
|
|
|
Json::FastWriter showValue;
|
|
Json::Value jsBody;
|
|
jsBody["dataNodeGatewayNo"] = GlobalConfig::MacAddr_G;
|
|
jsBody["dataNodeData"] = jsSensorData;
|
|
std::string dataBody = showValue.write(jsBody);
|
|
jsonVal["cmdBody"] = dataBody;
|
|
return showValue.write(jsonVal);
|
|
}
|
|
|
|
int SqliteDB::QueryofflineData()
|
|
{
|
|
vec_t vecRet = GetDataMultiLineOfOneColumn(T_SENSOR_INFO(TNAME),T_SENSOR_INFO(DATANODENO),NULL);
|
|
for(int i = 0; i < vecRet.size();i++){
|
|
char StaticTableName[50]={0x00};
|
|
sprintf(StaticTableName,"t_dataStatic_%s",vecRet[i].c_str());
|
|
|
|
array_t arrRetData = GetDataMultiLine(StaticTableName, "*","sendMsg = '0' order by timeStamp asc");
|
|
LOG_INFO("mqttresend check datanodeNo %s,data count %d\n",vecRet[i].c_str(),arrRetData.size());
|
|
if(arrRetData.size() < 1)
|
|
continue;
|
|
for(int j = 0; j < arrRetData.size();j++){
|
|
char dataTableName[50]={0x00};
|
|
sprintf(dataTableName,"t_data_%s",vecRet[i].c_str());
|
|
char tmpWhere[128]={0x00};
|
|
sprintf(tmpWhere,"sendMsg = '0' and timeStamp = '%s'",arrRetData[j][8].c_str());
|
|
array_t arrRet = GetDataMultiLine(dataTableName, "*","sendMsg = '0'");
|
|
if(arrRet.size() > 0){
|
|
Json::Value valNodeData;
|
|
Json::Value valNodeFeature;
|
|
for(int k = 0; k < arrRet.size();k++){
|
|
|
|
valNodeFeature["dataNodeNo"] = arrRet[k][0].c_str();
|
|
valNodeFeature["ChannelId"] = arrRet[k][1].c_str();
|
|
valNodeFeature["diagnosisPk"] = atof(arrRet[k][2].c_str());
|
|
valNodeFeature["integratPk"] = atof(arrRet[k][3].c_str());
|
|
valNodeFeature["integratRMS"] = atof(arrRet[k][4].c_str());
|
|
valNodeFeature["rmsValues"] = atof(arrRet[k][5].c_str());
|
|
valNodeFeature["envelopEnergy"] = atof(arrRet[k][6].c_str());
|
|
valNodeFeature["Amp1"] = atof(arrRet[k][7].c_str());
|
|
valNodeFeature["Amp2"] = atof(arrRet[k][8].c_str());
|
|
valNodeFeature["Amp3"] = atof(arrRet[k][9].c_str());
|
|
valNodeFeature["Amp4"] = atof(arrRet[k][10].c_str());
|
|
valNodeFeature["Amp5"] = atof(arrRet[k][1].c_str());
|
|
valNodeFeature["Phase1"] = atof(arrRet[k][12].c_str());
|
|
valNodeFeature["Phase2"] = atof(arrRet[k][13].c_str());
|
|
valNodeFeature["Phase3"] = atof(arrRet[k][14].c_str());
|
|
valNodeFeature["Phase4"] = atof(arrRet[k][15].c_str());
|
|
valNodeFeature["timeStamp"] = atoi(arrRet[k][17].c_str());
|
|
valNodeData.append(valNodeFeature);
|
|
}
|
|
}
|
|
//无线传感器信息
|
|
Json::Value root;
|
|
Json::Value valdatastatic;
|
|
Json::Value valNodeData;
|
|
valdatastatic["TemperatureTop"] = atof(arrRetData[j][2].c_str());
|
|
valdatastatic["TemperatureBot"] = atof(arrRetData[j][3].c_str());
|
|
valdatastatic["Dip"] = atof(arrRetData[j][4].c_str());
|
|
valdatastatic["Voltage"] = atof(arrRetData[j][5].c_str());
|
|
valdatastatic["ChannelType"] = "STATUS";
|
|
valdatastatic["ChannelId"] = (arrRetData[j][1].c_str());
|
|
valdatastatic["TimeStamp"] = atoi(arrRetData[j][8].c_str());
|
|
|
|
valdatastatic["dataNodeNo"] = arrRetData[j][0].c_str();
|
|
valNodeData.append(valdatastatic);
|
|
|
|
root["data"] = valNodeData;
|
|
root["TimeStamp"] = atoi(arrRetData[j][8].c_str());
|
|
root["dataNodeNo"] = arrRetData[j][0].c_str();
|
|
root["dataNodeGatewayNo"] = GlobalConfig::MacAddr_G;
|
|
root["status"] = "resend";
|
|
Json::FastWriter featureValue;
|
|
std::string strstatisticData = featureValue.write(root);
|
|
|
|
int iRet = data_publish(strstatisticData.c_str(), GlobalConfig::Topic_G.mPubData.c_str());
|
|
//print_info("dataNodeNo = '%s' and TimeStamp = '%s',MQTT ret = %d\n",arrRetData[j][0].c_str(),nowTimetamp.c_str(),iRet);
|
|
if(iRet == 0){
|
|
char updateSql[1024] = { 0 };
|
|
char whereCon[64] = { 0 };
|
|
memset(whereCon, 0, 64);
|
|
sprintf(whereCon, "dataNodeNo = '%s' and TimeStamp = '%s'", arrRetData[j][0].c_str(),arrRetData[j][8].c_str());
|
|
memcpy(updateSql, "sendMsg='1'",sizeof(updateSql));
|
|
sql_ctl->UpdateTableData(StaticTableName, updateSql, whereCon);
|
|
sql_ctl->UpdateTableData(dataTableName, updateSql, whereCon);
|
|
LOG_INFO("resend success dataNodeNo = %s,TimeStamp = '%s'\n",arrRetData[j][0].c_str(),arrRetData[j][8].c_str());
|
|
}
|
|
sleep(1);
|
|
}
|
|
}
|
|
char whereCon[1024] = {0x00};
|
|
sprintf(whereCon, " SendMsg = 0 ");
|
|
array_t arrRetData = GetDataMultiLine("t_data_waveSend", "*",whereCon);
|
|
LOG_INFO("mqttresend check wave count %d\n",arrRetData.size());
|
|
if(arrRetData.size() > 0){
|
|
for(int i = 0; i < arrRetData.size();i++){
|
|
std::string strWaveData = "";
|
|
if (access(arrRetData[i][1].c_str(), 0) >= 0)
|
|
{
|
|
std::vector<float> vecWave;
|
|
char localtimestamp[32] = { 0 };
|
|
float fTemp = 0;
|
|
std::ifstream inFile(arrRetData[i][1].c_str(),ios::in|ios::binary);
|
|
inFile.read((char *)localtimestamp,sizeof(localtimestamp));
|
|
while(inFile.read((char *)&fTemp,sizeof(fTemp))){
|
|
vecWave.push_back(fTemp);
|
|
}
|
|
|
|
for (int i = 0; i < vecWave.size(); i++) {
|
|
char buf[33]={0x00};
|
|
memset(buf,0x00,sizeof(buf));
|
|
sprintf(buf, "%.2f", vecWave[i]);
|
|
std::string waveTemp(buf);
|
|
if(i == 0){
|
|
strWaveData = waveTemp;
|
|
}
|
|
strWaveData = strWaveData + "," + waveTemp;
|
|
}
|
|
inFile.close();
|
|
}
|
|
Json::Value valWaveData;
|
|
int length = strWaveData.length();
|
|
valWaveData["number"] = length;
|
|
valWaveData["channelId"] = arrRetData[i][0];
|
|
valWaveData["dataNodeNo"] = arrRetData[i][0];
|
|
valWaveData["dataNodeGatewayNo"] = GlobalConfig::MacAddr_G;
|
|
valWaveData["SensorEngineeringUnit"] = "";
|
|
valWaveData["timeStamp"] = arrRetData[i][2];
|
|
valWaveData["waveData"] = strWaveData;
|
|
Json::FastWriter WaveValue;
|
|
std::string WaveData = WaveValue.write(valWaveData);
|
|
int iRet = data_publish(WaveData.c_str(), GlobalConfig::Topic_G.mPubWaveData.c_str());
|
|
if(iRet == 0){
|
|
char whereCon[1024] = {0x00};
|
|
char updateSql[1024] = {0x00};
|
|
sprintf(whereCon, "channelID='%s' and timeStamp = '%s' ", arrRetData[i][0].c_str(),arrRetData[i][2].c_str());
|
|
sprintf(updateSql, "SendMsg = 1");
|
|
sql_ctl->UpdateTableData("t_data_waveSend", updateSql, whereCon);
|
|
//char whereCon[64]={0x00};
|
|
//sprintf(whereCon,"waveName = '%s'",arrRetData[i][1].c_str());
|
|
//DeleteTableData("t_data_waveSend", whereCon);
|
|
std::string strCmd = "rm " + arrRetData[i][1];
|
|
system(strCmd.c_str());
|
|
LOG_INFO("resend success waveName = %s\n",arrRetData[i][1].c_str());
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
int SqliteDB::TransBegin()
|
|
{
|
|
return sqlite3_exec(mDBAcess, "begin;", 0, 0, 0);
|
|
}
|
|
|
|
int SqliteDB::TransRollback()
|
|
{
|
|
return sqlite3_exec(mDBAcess, "rollback;", 0, 0, 0);
|
|
}
|
|
|
|
int SqliteDB::TransCommit()
|
|
{
|
|
return sqlite3_exec(mDBAcess, "commit;", 0, 0, 0);
|
|
}
|
|
|
|
void SqliteDB::HandError(int code)
|
|
{
|
|
if (code == SQLITE_CORRUPT) {
|
|
/*
|
|
* 用system 删除数据库
|
|
*/
|
|
exit(1);
|
|
}
|
|
}
|