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

1484 lines
69 KiB
C++
Raw Normal View History

add manager codes,again
2025-01-23 11:13:58 +08:00
#include "uart.hpp"
#include <signal.h>
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <termios.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <boost/thread/thread.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/algorithm/string.hpp>
#include <boost/bind.hpp>
#include <boost/timer/timer.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <zlog.h>
#include <json/json.h>
#include "mqttclient/mqtt_client.h"
#include "utility/serial.h"
#include "scheduler/schedule.hpp"
#include "jsonparse/communication_cmd.hpp"
extern zlog_category_t *zct;
extern zlog_category_t *zbt;
extern std::map<std::string, compressWaveChannel> g_mapCompress;
int offSize = 0;
pTestRecvCallBack pTestRecv;
extern std::vector<RecvData> g_VecWaveDataX;
extern std::vector<RecvData> g_VecWaveDataY;
extern std::vector<RecvData> g_VecWaveDataZ;
int Uart::UartRecv(int fd, char srcshow, char *buffer) {
char buff[BUF_LENGTH];
int ret = 0;
int maxSize = 0;
int offSize = 0;
int timeoutflag = 0;
char head[] = {0xAA, 0x55, 0xAA};
char szbuffer[BUF_LENGTH] = {0x00};
while (1) {
if (now_task == WAVE_CMD) {
memset(buff, 0, sizeof(buff));
ret = read_data(fd, buff, BUF_LENGTH, 10);
if (ret <= 0) {
timeoutflag++;
优化调度和协议交互，增加web统计成功率
2025-05-10 11:43:05 +08:00
if (timeoutflag > 200) {
add manager codes,again
2025-01-23 11:13:58 +08:00
DealReviveDuration(wave_shortAddr);
zlog_warn(zct, "===============0x9999 timeout= %d offSize = %d===============shortAddr = %02x%02x", timeoutflag, offSize,UINT16_HIGH(wave_shortAddr),UINT16_LOW(wave_shortAddr));
zlog_warn(zct, "0x9999 timeout %d===============Size = %d", timeoutflag, offSize);
// printf("=============offSize = %d\n",offSize);
// for (size_t i = 0; i < offSize; i++)
// {
// printf("%02x ",mUartRecvTmpBuf[i]);
// }
// printf("=============\n");
FindRecvPackage(offSize, mUartRecvTmpBuf, head);
now_task = -1;
timeoutflag = 0;
offSize = 0;
maxSize = 0;
tcflush(fd, TCIFLUSH);
mssleep(10000);
wave_trans_ = true;
memset(mUartRecvTmpBuf, 0, BUF_LENGTH);
添加波形接收时重发条件，添加可以解析xyz任一波形，添加可以统计特征值次数
2025-04-08 14:24:50 +08:00
zlog_warn(zct, "wave end,now_task = %d", now_task);
add manager codes,again
2025-01-23 11:13:58 +08:00
}
mssleep(10000);
} else if (ret > 0) {
maxSize += ret;
timeoutflag = 0;
m_TimeStamp = 0;
memcpy(mUartRecvTmpBuf + offSize, buff, ret);
offSize = offSize + ret;
if (offSize > BUF_LENGTH * 15) {
优化调度和协议交互，增加web统计成功率
2025-05-10 11:43:05 +08:00
zlog_info(zct, "maxSize = %d", offSize);
add manager codes,again
2025-01-23 11:13:58 +08:00
memset(mUartRecvTmpBuf, 0, BUF_LENGTH);
timeoutflag = 0;
offSize = 0;
maxSize = 0;
tcflush(fd, TCIOFLUSH);
}
}
} else {
优化调度和协议交互，增加web统计成功率
2025-05-10 11:43:05 +08:00
memset(buff, 0, sizeof(buff));
ret = read_data(fd, buff, BUF_LENGTH, 10);
add manager codes,again
2025-01-23 11:13:58 +08:00
if (ret <= 0) {
timeoutflag++;
if (timeoutflag > 5) {
FindRecvPackage(offSize, szbuffer, (char *)head);
memset(szbuffer, 0x00, sizeof(szbuffer));
timeoutflag = 0;
offSize = 0;
maxSize = 0;
mssleep(10000);
}
} else if (ret > 0) {
maxSize += ret;
zlog_info(zct, "0x8888==str_recv===,ret = %d offSize = %d\n", ret, maxSize);
for (int i = 0; i < ret; i++) {
printf( "%02x ", buff[i] & 0xff);
}
zlog_info(zct, "\n");
timeoutflag = 0;
m_TimeStamp = 0;
if (offSize > sizeof(szbuffer)) {
zlog_warn(zct, "maxSize = %d", offSize);
memset(szbuffer, 0, sizeof(szbuffer));
timeoutflag = 0;
offSize = 0;
maxSize = 0;
tcflush(fd, TCIOFLUSH);
}
memcpy(szbuffer + offSize, buff, ret);
offSize = offSize + ret;
}
}
}
}
Uart::Uart() : mUart(mIoSev), mStrand(mIoSev) {
mRdLength = 0;
m_TimeStamp = 0;
mlastSize = 0;
fd = 0;
waittime = 0;
mPackgeIndex = -1;
bUpdate = false;
m_strDestShortAddr = "";
memset(mUartRecvBuf, 0, BUF_LENGTH);
memset(mUartRecvTmpBuf, 0, BUF_LENGTH);
bTest = false;
TestFd = 0;
wave_shortAddr = 0;
DataNodeUpdateFile = "";
strTimetamp = "";
bZigbeeSinal = false;
m_waveCountX = 0;
m_waveCountY = 0;
m_waveCountZ = 0;
VecWaveDataX.reserve(1000);
VecWaveDataY.reserve(1000);
VecWaveDataZ.reserve(1500);
优化调度和协议交互，增加web统计成功率
2025-05-10 11:43:05 +08:00
memset(send_data, 0, sizeof(send_data));
last_short_addr = 0;
last_time = 0;
add manager codes,again
2025-01-23 11:13:58 +08:00
}
Uart::~Uart() {
close(fd);
close(TestFd);
if (mUart.is_open()) mUart.close();
}
void Uart::InitUart(speed_t speed) {
fd = config_uart("/dev/ttySC2", speed);
zlog_info(zct, "InitUart fd = %d", fd);
if (fd < 0) {
zlog_error(zct, "config_uart error");
}
}
void Uart::Close() {
close(fd);
fd = 0;
}
void Uart::InitZigbeeHW() {
InitUart(B115200);
UpdateZigbeeInfoCtrl();
sleep(2);
int iRet = ReadFromUart();
if (iRet <= 0) {
Close();
sleep(2);
zlog_info(zct, "Speed error");
InitUart(B57600);
UpdateZigbeeInfoCtrl();
sleep(2);
ReadFromUart();
zlog_info(zct, "modify speed");
WriteSpeed2Zigbee();
ReadFromUart();
}
Close();
sleep(1);
}
void TestRecv(int status) {
char szStatus[10] = {0x00};
sprintf(szStatus, "%d", status);
write_data(uart_inst::instance().TestFd, (char *)szStatus, strlen(szStatus));
}
void Regist(pTestRecvCallBack pTestRecv1) { pTestRecv = pTestRecv1; }
void Uart::InitTestUart(speed_t speed) {
zlog_info(zct, "InitTestUart");
TestFd = config_uart("/dev/ttymxc2", speed); // Test
if (TestFd < 0) {
zlog_error(zct, "Test config_uart error");
}
Regist(TestRecv);
}
void Uart::ReadTestUart() {
char buff[BUF_LENGTH] = {0x00};
zlog_info(zct, "ReadTestUart");
while (1) {
int ret = read_data(TestFd, buff, BUF_LENGTH, 10);
if (ret > 0) {
zlog_info(zct, "buff = %s", buff);
if (!strcmp(buff, "0")) {
char buf[256] = {0};
sprintf(buf, "{\"dataNodeGatewayNo\":\"%s\",\"cmd\":\"12\",\"status\":\"REQ\"}", GlobalConfig::MacAddr_G.c_str());
std::string str = std::string(buf);
int iRet = data_publish(str.c_str(), GlobalConfig::Topic_G.mPubCmd.c_str());
if (iRet < 0) {
pTestRecv(1);
} else {
pTestRecv(0);
}
iRet = ZigbeeTest();
} else if (!strcmp(buff, "1")) {
std::string IP = GetGwIp_("eth0");
write_data(TestFd, (char *)IP.c_str(), IP.size());
IP = GetGwIp_("eth1");
write_data(TestFd, (char *)"|", 1);
write_data(TestFd, (char *)IP.c_str(), IP.size());
write_data(TestFd, (char *)"|", 1);
} else {
ModifyMac(buff);
pTestRecv(0);
}
}
mssleep(20000);
}
}
int Uart::ZigbeeTest() {
modify_Localchannel(22);
mssleep(100000);
modify_LocalPanID(2222);
mssleep(100000);
modify_LocalAddr(6666);
mssleep(100000);
return 0;
}
void Uart::WriteToUart(const char *strSend, int pLen) {
if (!bUpdate)
{
优化调度和协议交互，增加web统计成功率
2025-05-10 11:43:05 +08:00
printf( "\nWrite To Uart Start: %s\n",GetCurrentTime().c_str());
add manager codes,again
2025-01-23 11:13:58 +08:00
for (int i = 0; i < pLen; i++) {
printf("%02X ", *(strSend + i) & 0xFF);
}
printf( "\nWrite To Uart End.\n");
}
write_data(fd, (char *)strSend, pLen);
}
int Uart::ReadFromUart() {
char buffer[100] = {0x00};
int len = read_data(fd, (char *)buffer, 100, 10);
for (int i = 0; i < len; i++) printf( "%02X ", buffer[i] & 0xFF);
zlog_info(zct, "==========ReadFromUart========len = %d", len);
if (len) {
char head[] = {0xAA, 0x55, 0xAA};
FindRecvPackage(len, buffer, head);
}
return len;
}
void Uart::Run() { mIoSev.run(); }
void Uart::Stop() {
if (mUart.is_open()) mUart.close();
mIoSev.stop();
}
void Uart::setCallBack(onReceiveUart _callback) { m_callback = _callback; }
void Uart::UpdateZigbeeInfo(const char *pData) {
zlog_info(zct, "update gateway zigbee info");
GlobalConfig::Zigbee_G = *((ZIGBEE *)pData);
char buff[8];
sprintf(buff, "%02d", pData[36] & 0xFF);
GlobalConfig::ZigbeeInfo_G.DevMode = atoi(buff);
memset(buff, 0, 8);
sprintf(buff, "%02d", pData[37] & 0xFF);
GlobalConfig::ZigbeeInfo_G.Channel = atoi(buff);
memset(buff, 0, 8);
sprintf(buff, "%02x%02x", pData[38] & 0xFF, pData[39] & 0xFF);
GlobalConfig::ZigbeeInfo_G.PanID = std::string(buff);
memset(buff, 0, 8);
sprintf(buff, "%02x%02x", pData[40] & 0xFF, pData[41] & 0xFF);
GlobalConfig::ZigbeeInfo_G.MyAddr = std::string(buff);
memset(buff, 0, 8);
sprintf(buff, "%02x%02x", pData[50] & 0xFF, pData[51] & 0xFF);
GlobalConfig::ZigbeeInfo_G.DstAddr = std::string(buff);
memset(buff, 0, 8);
sprintf(buff, "%d", pData[62]);
GlobalConfig::ZigbeeInfo_G.RetryNum = std::string(buff);
memset(buff, 0, 8);
sprintf(buff, "%d", pData[63]);
GlobalConfig::ZigbeeInfo_G.TranTimeout = std::string(buff);
zlog_info(zbt, "local zigbee module info Mode : %d Chan : %d PanID : %s MyAddr : %s DstAddr : %s,RetryNum:%s,TranTimeout:%s", GlobalConfig::ZigbeeInfo_G.DevMode, GlobalConfig::ZigbeeInfo_G.Channel, GlobalConfig::ZigbeeInfo_G.PanID.c_str(),
GlobalConfig::ZigbeeInfo_G.MyAddr.c_str(), GlobalConfig::ZigbeeInfo_G.DstAddr.c_str(), GlobalConfig::ZigbeeInfo_G.RetryNum.c_str(), GlobalConfig::ZigbeeInfo_G.TranTimeout.c_str());
zlog_info(zbt, "PanID = %s,MacAddr_G= %s", GlobalConfig::ZigbeeInfo_G.PanID.c_str(), GlobalConfig::MacAddr_G.c_str());
std::string strchan = ReadStrByOpt(ZIGBEECONFIG, "Zigbee", "channel");
zlog_info(zbt, "Channel = %d,strchan = %s", GlobalConfig::ZigbeeInfo_G.Channel, strchan.c_str());
std::string strType = ReadStrByOpt(SYSTEMINFOFILE, "ZigbeeType", "type");
zlog_info(zbt, "TranTimeout = %02x,strType = %s ", GlobalConfig::Zigbee_G.TranTimeout, strType.c_str());
if (strType == "aw21") {
unsigned short TranTimeout = 0x0A;
WriteTranTimeout2Zigbee(TranTimeout);
}
if (strType == "zm5161") {
unsigned short TranTimeout = 0x03;
WriteTranTimeout2Zigbee(TranTimeout);
}
}
void int2bytes(int i, unsigned char *bytes, int size) {
memset(bytes, 0, sizeof(unsigned char) * size);
bytes[0] = (unsigned char)(0xff & i);
bytes[1] = (unsigned char)((0xff00 & i) >> 8);
bytes[2] = (unsigned char)((0xff0000 & i) >> 16);
bytes[3] = (unsigned char)((0xff000000 & i) >> 24);
}
void Uart::GetLocalZigbeeRSSI(uint16_t ushortAdd){
zlog_info(zct, "Local Zigbee Signal !\n");
mssleep(20000);
getZigbeeSignal(ushortAdd);
优化调度和协议交互，增加web统计成功率
2025-05-10 11:43:05 +08:00
mssleep(20000);
getZigbeeSignal(ushortAdd);
mssleep(20000);
add manager codes,again
2025-01-23 11:13:58 +08:00
}
int Uart::DealAskTask(uint16_t ushortAdd){
char wherecon[50]={0};
sprintf(wherecon, "zigbeeShortAddr='%02x%02x'", UINT16_HIGH(ushortAdd),UINT16_LOW(ushortAdd));
int sensor_count = sqlite_db_ctrl::instance().GetTableRows(T_SENSOR_INFO(TNAME), wherecon);
if (sensor_count < 1) {
zlog_warn(zct, "device info not found %02x%02x ", UINT16_HIGH(ushortAdd),UINT16_LOW(ushortAdd));
return 1;
}
优化调度和协议交互，增加web统计成功率
2025-05-10 11:43:05 +08:00
int next_duration = 0,next_task_id = 0;
int taskID;
add manager codes,again
2025-01-23 11:13:58 +08:00
ScheduleTask scheduleTask;
优化调度和协议交互，增加web统计成功率
2025-05-10 11:43:05 +08:00
taskID = scheduler::instance().StartSchedule(ushortAdd,next_duration, next_task_id);
zlog_info(zct, "taskID = %d next_duration = %d next_task_id = %d", taskID, next_duration, next_task_id);
if (taskID == kScheduleConfigSensor)
add manager codes,again
2025-01-23 11:13:58 +08:00
{
优化调度和协议交互，增加web统计成功率
2025-05-10 11:43:05 +08:00
scheduleTask.cmd = CONFIG;
scheduleTask.duration = next_duration;
scheduleTask.next_taskID = next_task_id;
add manager codes,again
2025-01-23 11:13:58 +08:00
scheduleTask.shortAddr = ushortAdd;
TaskResp(scheduleTask);
优化调度和协议交互，增加web统计成功率
2025-05-10 11:43:05 +08:00
mssleep(50000);
UpdateConfig(ushortAdd);
add manager codes,again
2025-01-23 11:13:58 +08:00
}
优化调度和协议交互，增加web统计成功率
2025-05-10 11:43:05 +08:00
if(next_task_id == kScheduleWaveForm){
scheduleTask.cmd = REVIVE_DURATION;
add manager codes,again
2025-01-23 11:13:58 +08:00
scheduleTask.shortAddr = ushortAdd;
scheduleTask.duration = next_duration;
优化调度和协议交互，增加web统计成功率
2025-05-10 11:43:05 +08:00
scheduleTask.next_taskID = WAVE_CMD;
add manager codes,again
2025-01-23 11:13:58 +08:00
TaskResp(scheduleTask);
优化调度和协议交互，增加web统计成功率
2025-05-10 11:43:05 +08:00
}else if (next_task_id == kScheduleEigenValue) {
add manager codes,again
2025-01-23 11:13:58 +08:00
scheduleTask.cmd = REVIVE_DURATION;
scheduleTask.shortAddr = ushortAdd;
scheduleTask.duration = next_duration;
优化调度和协议交互，增加web统计成功率
2025-05-10 11:43:05 +08:00
scheduleTask.next_taskID = MEAS_EVAL;
add manager codes,again
2025-01-23 11:13:58 +08:00
TaskResp(scheduleTask);
优化调度和协议交互，增加web统计成功率
2025-05-10 11:43:05 +08:00
}else if(next_task_id == kScheduleUpgrade){
scheduleTask.cmd = REVIVE_DURATION;
add manager codes,again
2025-01-23 11:13:58 +08:00
scheduleTask.shortAddr = ushortAdd;
scheduleTask.duration = next_duration;
优化调度和协议交互，增加web统计成功率
2025-05-10 11:43:05 +08:00
scheduleTask.next_taskID = UPGRADE;
add manager codes,again
2025-01-23 11:13:58 +08:00
TaskResp(scheduleTask);
}
优化调度和协议交互，增加web统计成功率
2025-05-10 11:43:05 +08:00
// if (next_task_id == kScheduleEigenValue) //1.特征值
// {
// }
// else if (next_task_id == kScheduleWaveForm) //2.波形
// {
// DealReviveDuration(ushortAdd);
// }
// else if (next_task_id == kScheduleUpgrade) //3.升级
// {
// UpdateWirelessNode(ushortAdd);
// }else if (taskID == kScheduleConfigSensor) //4.更新配置
// {
// scheduleTask.cmd = CONFIG;
// scheduleTask.shortAddr = ushortAdd;
// mssleep(50000);
// TaskResp(scheduleTask);
// mssleep(50000);
// UpdateConfig(ushortAdd);
// }else if (taskID == kScheduleWrongTime) //5.异常连接
// {
// scheduleTask.cmd = REVIVE_DURATION;
// scheduleTask.shortAddr = ushortAdd;
// scheduleTask.duration = next_duration;
// zlog_info(zct, "next_duration = %d ", next_duration);
// TaskResp(scheduleTask);
// }
zlog_info(zct, " DealAskTask end" );
add manager codes,again
2025-01-23 11:13:58 +08:00
return 0;
}
int Uart::DealException(const char* pData){
return 0;
}
int Uart::DealReviveDuration(uint16_t ushortAdd){
ScheduleTask scheduleTask;
优化调度和协议交互，增加web统计成功率
2025-05-10 11:43:05 +08:00
int next_taskID = 0;
uint16_t next_duration = scheduler::instance().GetNextDuration(ushortAdd,next_taskID);
zlog_info(zct, "next_duration = %d next_taskID = %d", next_duration,next_taskID);
add manager codes,again
2025-01-23 11:13:58 +08:00
scheduleTask.cmd = REVIVE_DURATION;
scheduleTask.shortAddr = ushortAdd;
scheduleTask.duration = next_duration;
优化调度和协议交互，增加web统计成功率
2025-05-10 11:43:05 +08:00
scheduleTask.next_taskID = next_taskID & 0xFF;
add manager codes,again
2025-01-23 11:13:58 +08:00
TaskResp(scheduleTask);
return 0;
}
int Uart::DealConfig(uint16_t ushortAdd){
char whereCon[1024] = {0};
char updateSql[1024] = { 0 };
sprintf(updateSql, "UpdateFlag = 1");
sprintf(whereCon, "zigbeeShortAddr='%02x%02x'", UINT16_HIGH(ushortAdd),UINT16_LOW(ushortAdd));
sqlite_db_ctrl::instance().UpdateTableData(T_SENSOR_INFO(TNAME), updateSql, whereCon);
scheduler::instance().UpdateConfigResult(ushortAdd,0);
return 0;
}
int Uart::DealWaveCompress(const char *pData,uint16_t ushortAdd){
zlog_info(zct, "DealWaveCompress ");
优化调度和协议交互，增加web统计成功率
2025-05-10 11:43:05 +08:00
now_task = WAVE_CMD;
WaveResp(ushortAdd);
add manager codes,again
2025-01-23 11:13:58 +08:00
char buf[20] = {0x00};
sprintf(buf, "%02x%02x", (ushortAdd >> 8) & 0xFF, ushortAdd & 0xFF);
std::string strShortAddr = std::string(buf);
compressWaveChannel tempchannel;
tempchannel.compressChannelX = pData[7];
tempchannel.compressChannelY = pData[8];
tempchannel.compressChannelZ = pData[9];
tempchannel.CountX = BUILD_UINT32(pData[13], pData[12],pData[11],pData[10]);
tempchannel.CountY = BUILD_UINT32(pData[17], pData[16],pData[15],pData[14]);
tempchannel.CountZ = BUILD_UINT32(pData[21], pData[20],pData[19],pData[18]);
g_mapCompress[strShortAddr] = tempchannel;
优化调度和协议交互，增加web统计成功率
2025-05-10 11:43:05 +08:00
wave_shortAddr = ushortAdd;
char sensor_rssi[10] = {0x00};
sprintf(sensor_rssi, "%02d", pData[22] & 0xFF);
if (!strcmp(sensor_rssi, "00") || !strcmp(sensor_rssi, "0")) {
char errorInfo[100] = {0x00};
sprintf(errorInfo, "No RSSI %s", sensor_rssi);
zlog_error(zct, errorInfo);
} else {
char tableName[100] = {0x00};
char whereCon[100] = {0};
char updateSql[100] = {0};
sprintf(whereCon, "zigbeeShortAddr='%02x%02x'", UINT16_HIGH(ushortAdd),UINT16_LOW(ushortAdd));
vec_t vecDataNodeNo = sqlite_db_ctrl::instance().GetDataSingleLine(T_SENSOR_INFO(TNAME), " MeasurementID,RSSI ", whereCon);
sprintf(tableName, "t_dataStatic_%s", (char *)vecDataNodeNo[0].c_str());
memset(whereCon,0,sizeof(whereCon));
sprintf(whereCon, "dataNodeNo='%s' order by timeStamp desc limit 1", vecDataNodeNo[0].c_str());
std::string timestamp_last = sqlite_db_ctrl::instance().GetData(tableName, " timeStamp ", whereCon);
sprintf(updateSql, "zigbeeSignalNode = '%02d' ",atoi(sensor_rssi));
memset(whereCon,0,sizeof(whereCon));
sprintf(whereCon, "dataNodeNo='%s' and timeStamp = '%s'", (char*)vecDataNodeNo[0].c_str(),timestamp_last.c_str());
sqlite_db_ctrl::instance().UpdateTableData(tableName, updateSql, whereCon);
add manager codes,again
2025-01-23 11:13:58 +08:00
优化调度和协议交互，增加web统计成功率
2025-05-10 11:43:05 +08:00
std::vector<std::string> vParamRSSI;
boost::split(vParamRSSI, vecDataNodeNo[1], boost::is_any_of(","), boost::token_compress_on);
memset(updateSql,0,sizeof(updateSql));
memset(whereCon,0,sizeof(whereCon));
if (vParamRSSI.size() > 0) {
sprintf(updateSql, "RSSI = '%s,%02d' ", vParamRSSI[0].c_str(), pData[22] & 0xFF);
sprintf(whereCon, "dataNodeNo='%s'", (char *)vecDataNodeNo[0].c_str());
sqlite_db_ctrl::instance().UpdateTableData(T_SENSOR_INFO(TNAME), updateSql, whereCon);
}
}
add manager codes,again
2025-01-23 11:13:58 +08:00
zlog_info(zct, "count X = %d,Y = %d,Z = %d ", tempchannel.CountX, tempchannel.CountY, tempchannel.CountZ);
zlog_info(zct, "compress X = %d,Y = %d,Z = %d ", tempchannel.compressChannelX, tempchannel.compressChannelY, tempchannel.compressChannelZ);
return 0;
}
int Uart::DealSensorRSSI(const char *pData,uint16_t ushortAdd){
//传感器获取网关信号强度
zlog_info(zct, "DealSensorRSSI ushortAdd = %02x%02x",UINT16_HIGH(ushortAdd),UINT16_LOW(ushortAdd));
mssleep(200000);
ScheduleTask scheduleTask;
now_task = WAVE_CMD;
scheduleTask.cmd = WAVE_CMD;
scheduleTask.shortAddr = ushortAdd;
TaskResp(scheduleTask);
char localtimestamp[32] = {0};
GetTimeNet(localtimestamp, 1);
char sensor_rssi[10] = {0x00};
sprintf(sensor_rssi, "%02d", pData[7] & 0xFF);
if (!strcmp(sensor_rssi, "00") || !strcmp(sensor_rssi, "0")) {
char errorInfo[100] = {0x00};
sprintf(errorInfo, "No RSSI %s", sensor_rssi);
zlog_error(zct, errorInfo);
} else {
char tableName[100] = {0x00};
char whereCon[100] = {0};
char updateSql[100] = {0};
sprintf(whereCon, "zigbeeShortAddr='%02x%02x'", UINT16_HIGH(ushortAdd),UINT16_LOW(ushortAdd));
vec_t vecDataNodeNo = sqlite_db_ctrl::instance().GetDataSingleLine(T_SENSOR_INFO(TNAME), " MeasurementID,RSSI ", whereCon);
sprintf(tableName, "t_dataStatic_%s", (char *)vecDataNodeNo[0].c_str());
memset(whereCon,0,sizeof(whereCon));
sprintf(whereCon, "dataNodeNo='%s' order by timeStamp desc limit 1", vecDataNodeNo[0].c_str());
std::string timestamp_last = sqlite_db_ctrl::instance().GetData(tableName, " timeStamp ", whereCon);
sprintf(updateSql, "zigbeeSignalNode = '%02d' ",atoi(sensor_rssi));
memset(whereCon,0,sizeof(whereCon));
sprintf(whereCon, "dataNodeNo='%s' and timeStamp = '%s'", (char*)vecDataNodeNo[0].c_str(),timestamp_last.c_str());
sqlite_db_ctrl::instance().UpdateTableData(tableName, updateSql, whereCon);
std::vector<std::string> vParamRSSI;
boost::split(vParamRSSI, vecDataNodeNo[1], boost::is_any_of(","), boost::token_compress_on);
memset(updateSql,0,sizeof(updateSql));
memset(whereCon,0,sizeof(whereCon));
if (vParamRSSI.size() > 0) {
sprintf(updateSql, "RSSI = '%s,%02d' ", vParamRSSI[0].c_str(), pData[7] & 0xFF);
sprintf(whereCon, "dataNodeNo='%s'", (char *)vecDataNodeNo[0].c_str());
sqlite_db_ctrl::instance().UpdateTableData(T_SENSOR_INFO(TNAME), updateSql, whereCon);
}
}
return 0;
}
int Uart::DealUpgrade(uint16_t ushortAdd,int status){
char updateSql[100] = {0};
char wherecon[100] = {0};
memset(wherecon,0,sizeof(wherecon));
memset(updateSql,0,sizeof(updateSql));
sprintf(wherecon," zigbeeShortAddr = '%02x%02x' ",UINT16_HIGH(ushortAdd), UINT16_LOW(ushortAdd));
sprintf(updateSql, " upgradeStatus = %d", status);
sqlite_db_ctrl::instance().UpdateTableData(T_SENSOR_INFO(TNAME), updateSql,wherecon);
memset(wherecon,0,sizeof(wherecon));
sprintf(wherecon," short_addr = '%02x%02x' ORDER BY start_timestamp DESC LIMIT 1 ",UINT16_HIGH(ushortAdd), UINT16_LOW(ushortAdd));
std::string start_timestamp = sqlite_db_ctrl::instance().GetData("firmware_upgrade ", " start_timestamp ", wherecon);
memset(updateSql,0,sizeof(updateSql));
memset(wherecon,0,sizeof(wherecon));
sprintf(wherecon," short_addr = '%02x%02x' AND start_timestamp = '%s'",UINT16_HIGH(ushortAdd), UINT16_LOW(ushortAdd),start_timestamp.c_str());
sprintf(updateSql, " status = %d",status);
sqlite_db_ctrl::instance().UpdateTableData(" firmware_upgrade ", updateSql,wherecon);
return 0;
}
优化调度和协议交互，增加web统计成功率
2025-05-10 11:43:05 +08:00
int Uart::DealFeatureValue(const char *pData,uint16_t ushortAdd){
zlog_info(zct, "DealFeatureValue ");
char localtimestamp[32] = {0};
GetTimeNet(localtimestamp, 1);
std::string nowTimetamp = std::string(localtimestamp);
long now_time = atol(nowTimetamp.c_str());
if(ushortAdd == last_short_addr && (now_time - last_time) < 5){
优化代码
2025-05-12 17:26:09 +08:00
zlog_warn(zct, "DealFeatureValue short_addr_last = %02x%02x,timestamp_last = %ld,nowTime = %ld",UINT16_HIGH(ushortAdd), UINT16_LOW(ushortAdd),last_time,now_time);
优化调度和协议交互，增加web统计成功率
2025-05-10 11:43:05 +08:00
int iRet = DealDataNodeFeature(pData, 0);
if (iRet != 0)
{
return -1;
}
DealAskTask(ushortAdd);
}else {
DealAskTask(ushortAdd);
DealDataNodeFeature(pData, 0);
}
GetTimeNet(localtimestamp, 1);
nowTimetamp = std::string(localtimestamp);
last_time = atol(nowTimetamp.c_str());
return 0;
}
add manager codes,again
2025-01-23 11:13:58 +08:00
void Uart::DealRecvData(const char *pData) {
uint16_t ushortAdd = BUILD_UINT16(pData[3] & 0xFF, pData[4] & 0xFF);
uint8_t command = pData[5] & 0xFF;
uint8_t recvcode = pData[7] & 0xFF;
优化调度和协议交互，增加web统计成功率
2025-05-10 11:43:05 +08:00
int next_duration = 0,next_task_id = 0;
int taskID = 0;
ScheduleTask scheduleTask;
add manager codes,again
2025-01-23 11:13:58 +08:00
zlog_info(zct, "shortAdd = %02x%02x,command = %d ",UINT16_HIGH(ushortAdd),UINT16_LOW(ushortAdd),command);
优化代码
2025-05-12 17:26:09 +08:00
if (command == WAVE_COMPRESS || command == UPGRADE_ASK)
{
char localtimestamp[32] = {0};
GetTimeNet(localtimestamp, 1);
std::string nowTimetamp = std::string(localtimestamp);
long now_time = atol(nowTimetamp.c_str());
if(ushortAdd == last_short_addr && (now_time - last_time) < 5){
zlog_warn(zct, "WAVE_COMPRESS | UPGRADE_ASK short_addr_last = %02x%02x,timestamp_last = %ld,nowTime = %ld",UINT16_HIGH(ushortAdd), UINT16_LOW(ushortAdd),last_time,now_time);
return ;
}
GetTimeNet(localtimestamp, 1);
nowTimetamp = std::string(localtimestamp);
last_time = atol(nowTimetamp.c_str());
}
优化调度和协议交互，增加web统计成功率
2025-05-10 11:43:05 +08:00
if (ushortAdd != last_short_addr){
mssleep(50000);
ModifyDistAddr(ushortAdd);
mssleep(50000);
}
add manager codes,again
2025-01-23 11:13:58 +08:00
switch (command) {
case DEVICE_INF:
DealDataNodeInfo(pData);
break;
case DEVICE_INF2:
DealDataNodeName(pData);
break;
优化调度和协议交互，增加web统计成功率
2025-05-10 11:43:05 +08:00
// case ASK_TASK:
// DealAskTask(ushortAdd);
// break;
add manager codes,again
2025-01-23 11:13:58 +08:00
case DEVICE_EXCEPTION:
DealException(pData);
break;
case MEAS_EVAL:
优化调度和协议交互，增加web统计成功率
2025-05-10 11:43:05 +08:00
DealFeatureValue(pData, ushortAdd);
add manager codes,again
2025-01-23 11:13:58 +08:00
break;
case UPGRADE:
if (recvcode == 0){
优化调度和协议交互，增加web统计成功率
2025-05-10 11:43:05 +08:00
zlog_info(zbt, "[UPLOAD SUCCESS] shortAdd = %02x%02x,command = %d,recvcode = %d ",UINT16_HIGH(ushortAdd),UINT16_LOW(ushortAdd),command,recvcode);
add manager codes,again
2025-01-23 11:13:58 +08:00
}else if (recvcode == 5)
{
DealUpgrade(ushortAdd,2);
scheduler::instance().UpgradeResult(ushortAdd,0);
优化调度和协议交互，增加web统计成功率
2025-05-10 11:43:05 +08:00
zlog_warn(zbt, "[UPLOAD ALREADY] shortAdd = %02x%02x,command = %d,recvcode = %d ",UINT16_HIGH(ushortAdd),UINT16_LOW(ushortAdd),command,recvcode);
add manager codes,again
2025-01-23 11:13:58 +08:00
}else
{
DealUpgrade(ushortAdd,3);
scheduler::instance().UpgradeResult(ushortAdd,recvcode);
优化调度和协议交互，增加web统计成功率
2025-05-10 11:43:05 +08:00
zlog_warn(zbt, "[UPLOAD FAILED] shortAdd = %02x%02x,command = %d,recvcode = %d ",UINT16_HIGH(ushortAdd),UINT16_LOW(ushortAdd),command,recvcode);
add manager codes,again
2025-01-23 11:13:58 +08:00
}
break;
case CONFIG:
if (recvcode == 0){
DealReviveDuration(ushortAdd);
DealConfig(ushortAdd);
}else{
scheduler::instance().UpdateConfigResult(ushortAdd,recvcode);
zlog_warn(zbt, "[CONFIG] shortAdd = %02x%02x,command = %d,recvcode = %d ",UINT16_HIGH(ushortAdd),UINT16_LOW(ushortAdd),command,recvcode);
}
break;
case WAVE_COMPRESS:
优化调度和协议交互，增加web统计成功率
2025-05-10 11:43:05 +08:00
GetLocalZigbeeRSSI(ushortAdd);
add manager codes,again
2025-01-23 11:13:58 +08:00
DealWaveCompress(pData,ushortAdd);
break;
优化调度和协议交互，增加web统计成功率
2025-05-10 11:43:05 +08:00
case UPGRADE_ASK:
mssleep(50000);
taskID = scheduler::instance().StartSchedule(ushortAdd,next_duration, next_task_id);
taskID = kScheduleUpgrade;
if (taskID == kScheduleUpgrade){
UpdateWirelessNode(ushortAdd);
}else if(taskID == kScheduleResultNone){
scheduleTask.cmd = REVIVE_DURATION;
scheduleTask.shortAddr = ushortAdd;
scheduleTask.duration = next_duration;
scheduleTask.next_taskID = next_task_id;
TaskResp(scheduleTask);
}
add manager codes,again
2025-01-23 11:13:58 +08:00
break;
default: break;
}
优化调度和协议交互，增加web统计成功率
2025-05-10 11:43:05 +08:00
last_short_addr = ushortAdd;
add manager codes,again
2025-01-23 11:13:58 +08:00
}
void Uart::DealDataNodeName(const char *pData) {
zlog_info(zct, "DealDataNodeName ");
std::string strTime = GetLocalTimeWithMs();
char szShortAdd[8] = {0x00};
char shortAdd[8] = {0x00};
char NodeName[128] = {0x00};
sprintf(szShortAdd, "%02x%02x", pData[3] & 0xFF, pData[4] & 0xFF);
memcpy(NodeName, &pData[7], 64);
memcpy(shortAdd, &pData[3], 2);
优化调度和协议交互，增加web统计成功率
2025-05-10 11:43:05 +08:00
char whereCon[64] = {0};
add manager codes,again
2025-01-23 11:13:58 +08:00
char uplCon[200] = {0x00};
char nodeWaveSend[10] = {0x00};
for (int i = 0; i < 64; i++) {
sprintf(&NodeName[i * 2], "%02X", pData[7 + i] & 0xFF);
}
char MeasurementID[100] = {0x00};
sprintf(MeasurementID, "%02x%02x%02x%02x%02x%02x%02x%02x", pData[71], pData[72], pData[73], pData[74], pData[75], pData[76], pData[77], pData[78]);
优化调度和协议交互，增加web统计成功率
2025-05-10 11:43:05 +08:00
add manager codes,again
2025-01-23 11:13:58 +08:00
char gbkNodeName[128] = {0x00};
sprintf(whereCon, "zigbeeShortAddr='%s'", szShortAdd);
zlog_info(zct, "whereCon = %s", whereCon);
array_t vecRes = sqlite_db_ctrl::instance().GetDataMultiLine(T_SENSOR_INFO(TNAME), " dataNodeNo, MeasurementID,hardVersion,softVersion", whereCon);
优化调度和协议交互，增加web统计成功率
2025-05-10 11:43:05 +08:00
zlog_info(zct, "vecRes = %d", vecRes.size());
add manager codes,again
2025-01-23 11:13:58 +08:00
if (vecRes.size() > 1) {
for (size_t i = 0; i < vecRes.size(); i++) {
if (vecRes[i][1] != "") {
memset(whereCon,0,sizeof(whereCon));
sprintf(whereCon, "%s= '%s'", T_SENSOR_INFO(DATANODENO), vecRes[i][0].c_str());
sqlite_db_ctrl::instance().DeleteTableData(T_SENSOR_INFO(TNAME), whereCon);
memset(whereCon,0,sizeof(whereCon));
sprintf(whereCon, "%s= '%s'", T_SENSOR_INFO(DATANODENO), vecRes[i][1].c_str());
sqlite_db_ctrl::instance().DeleteTableData(T_DATA_INFO(TNAME), whereCon);
sqlite_db_ctrl::instance().DeleteTableData(T_DATASTATIC_INFO(TNAME), whereCon);
sqlite_db_ctrl::instance().DeleteTableData(T_BATTERY_INFO(TNAME), whereCon);
sqlite_db_ctrl::instance().DeleteTableData(" t_battery_history ", whereCon);
memset(whereCon,0,sizeof(whereCon));
sprintf(whereCon, "channelID like'%s'", vecRes[i][1].c_str());
sqlite_db_ctrl::instance().DeleteTableData(" t_data_waveSend ", whereCon);
char szTableName[50] = {0x00};
sprintf(szTableName, "DROP TABLE t_data_%s", vecRes[i][1].c_str());
sqlite_db_ctrl::instance().CreateTable(szTableName);
memset(szTableName, 0x00, sizeof(szTableName));
sprintf(szTableName, "DROP TABLE t_dataStatic_%s", vecRes[i][1].c_str());
sqlite_db_ctrl::instance().CreateTable(szTableName);
uint16_t short_addr;
char *end_ptr = NULL;
short_addr = strtol(szShortAdd, &end_ptr, 16);
scheduler::instance().ClearScheduleCfg(short_addr);
}
}
}
优化调度和协议交互，增加web统计成功率
2025-05-10 11:43:05 +08:00
zlog_info(zct, "vecRes22 = %d", vecRes.size());
zlog_info(zct, "hardVersion = %s,softVersion = %s", vecRes[0][2].c_str(),vecRes[0][3].c_str());
add manager codes,again
2025-01-23 11:13:58 +08:00
std::string hardVersion = vecRes[0][2];
std::string softVersion = vecRes[0][3];
if ((hardVersion == "3.0" && compareVersions(softVersion, "3.6") == -1) || (hardVersion == "4.0" && compareVersions(softVersion, "4.6") == -1)|| (hardVersion == "1.0" && compareVersions(softVersion,"1.2") == -1)) {
memcpy(MeasurementID, vecRes[0][0].c_str(), sizeof(MeasurementID));
}
memset(whereCon,0,sizeof(whereCon));
sprintf(whereCon, "zigbeeShortAddr='%s'", szShortAdd);
std::string strNodeName(NodeName);
zlog_info(zct, "strNodeName = %s", strNodeName.c_str());
优化调度和协议交互，增加web统计成功率
2025-05-10 11:43:05 +08:00
//solve(gbkNodeName, NodeName);
hexToAscii(strNodeName.c_str(), gbkNodeName);
add manager codes,again
2025-01-23 11:13:58 +08:00
zlog_info(zct, "gbkNodeName = %s", gbkNodeName);
zlog_info(zct, "NodeName = %s", NodeName);
zlog_info(zct, "whereCon = %s", whereCon);
sprintf(uplCon, "dataNodeName = '%s' , MeasurementID = '%s',NodeWaveSend = '%s'", gbkNodeName, MeasurementID, nodeWaveSend);
sqlite_db_ctrl::instance().UpdateTableData(T_SENSOR_INFO(TNAME), uplCon, whereCon);
std::string strData = sqlite_db_ctrl::instance().GetNodeConfigureInfor(whereCon);
data_publish(strData.c_str(), GlobalConfig::Topic_G.mPubConfig.c_str());
char szTableName[50] = {0x00};
sprintf(szTableName, "t_data_%s", MeasurementID);
memset(whereCon,0,sizeof(whereCon));
sprintf(whereCon,"type='table' and name = '%s'",szTableName);
int ret = sqlite_db_ctrl::instance().GetTableRows("sqlite_master",whereCon);
zlog_info(zct, "ret = %d", ret);
if (ret == 0){
sqlite_db_ctrl::instance().Createtable(szTableName);
}
memset(szTableName, 0x00, sizeof(szTableName));
sprintf(szTableName, "t_dataStatic_%s", MeasurementID);
memset(whereCon,0,sizeof(whereCon));
sprintf(whereCon,"type='table' and name = '%s'",szTableName);
ret = sqlite_db_ctrl::instance().GetTableRows("sqlite_master",whereCon);
zlog_info(zct, "ret = %d", ret);
if (ret == 0){
sqlite_db_ctrl::instance().CreatedataStatictable(szTableName);
}
}
void Uart::DealDataNodeInfo(const char *pData) {
int res = 0;
RecvData *pRecvData = (RecvData *)pData;
zlog_warn(zct, "recv remote zigbee module info shortAddr %02x%02x", pRecvData->Data[46], pRecvData->Data[47]);
char buf[32] = {0};
优化调度和协议交互，增加web统计成功率
2025-05-10 11:43:05 +08:00
char whereCon[64] = {0};
uint16_t ushortAdd = BUILD_UINT16(pData[3] & 0xFF, pData[4] & 0xFF);
add manager codes,again
2025-01-23 11:13:58 +08:00
char chTemp = pRecvData->Data[0]; //设备状态标志 1 byte
DataNodeInfo dataNodeInfo;
dataNodeInfo.EquipSta = GET_BIT(chTemp, 2);
dataNodeInfo.TemTopFlag = GET_BIT(chTemp, 3);
dataNodeInfo.TemBotFlag = GET_BIT(chTemp, 4);
dataNodeInfo.ZigbeeFlag = GET_BIT(chTemp, 5);
dataNodeInfo.AccFlag = GET_BIT(chTemp, 6);
dataNodeInfo.InitFlag = GET_BIT(chTemp, 7);
sprintf(buf, "%02x%02x%02x%02x%02x%02x%02x%02x", pRecvData->Data[1], pRecvData->Data[2], pRecvData->Data[3], pRecvData->Data[4], pRecvData->Data[5], pRecvData->Data[6], pRecvData->Data[7], pRecvData->Data[8]);
dataNodeInfo.ZigbeeLongAddr = std::string(buf); // Zigbee MAC 8 byte
chTemp = pRecvData->Data[9]; //硬件版本 1 byte
memset(buf, 0, 32);
sprintf(buf, "%.1f", 0.1 * chTemp);
dataNodeInfo.HardVersion = std::string(buf);
chTemp = pRecvData->Data[10]; //软件版本 1 byte
memset(buf, 0, 32);
sprintf(buf, "%.1f", 0.1 * chTemp);
dataNodeInfo.SoftVersion = std::string(buf);
memset(buf, 0, 32);
sprintf(buf, "%d", BUILD_UINT32(pRecvData->Data[11], pRecvData->Data[12], pRecvData->Data[13], pRecvData->Data[14]));
dataNodeInfo.BpNo = std::string(buf); //生产批号 4 byte
memset(buf, 0, 32);
sprintf(buf, "%d", BUILD_UINT32(pRecvData->Data[15], pRecvData->Data[16], pRecvData->Data[17], pRecvData->Data[18]));
dataNodeInfo.SerialNo = std::string(buf); //生产序列号 4 byte
memset(buf, 0, 32);
sprintf(buf, "%d", BUILD_UINT32(pRecvData->Data[19], pRecvData->Data[20], pRecvData->Data[21], pRecvData->Data[22]));
dataNodeInfo.FirstPowerTime = std::string(buf); //首次上电日期 4 byte
// 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38=>序号13 无线信号强度
memset(buf, 0, 32);
sprintf(buf, "%d", BUILD_UINT32(pRecvData->Data[23], pRecvData->Data[24], pRecvData->Data[25], pRecvData->Data[26]));
dataNodeInfo.WakeupTime = atoi(buf); //唤醒次数 4 byte
memset(buf, 0, 32);
sprintf(buf, "%d", BUILD_UINT32(pRecvData->Data[27], pRecvData->Data[28], pRecvData->Data[29], pRecvData->Data[30]));
dataNodeInfo.StaticTime = atoi(buf); //特征值发送次数 4 byte
memset(buf, 0, 32);
dataNodeInfo.WaveTime = BUILD_UINT32(pRecvData->Data[31], pRecvData->Data[32], pRecvData->Data[33], pRecvData->Data[34]); //原始波形发送次数 4 byte
memset(buf, 0, 32);
dataNodeInfo.BateryV = BUILD_UINT16(pRecvData->Data[35], pRecvData->Data[36]); //电池电压 2 byte
memset(buf, 0, 32);
sprintf(buf, "%02x", pRecvData->Data[37]);
dataNodeInfo.ProductNo = std::string(buf); //产品型号 1 byte
// 获取 RSSI
chTemp = pRecvData->Data[38];
memset(buf, 0, 32);
sprintf(buf, "%d", chTemp);
dataNodeInfo.RSSI = atoi(buf); //无线信号强度 1 byte
chTemp = pRecvData->Data[39];
memset(buf, 0, 32);
sprintf(buf, "%02x", chTemp);
dataNodeInfo.ConfigFlag = ((0 == std::string(buf).compare("aa")) ? 1 : 0); //配置标志 1 byte
chTemp = pRecvData->Data[40];
memset(buf, 0, 32);
sprintf(buf, "%d", chTemp);
dataNodeInfo.FeatureInterVal = atoi(buf); //唤醒周期 1 byte
memset(buf, 0, 32);
// yxq
sprintf(buf, "%u%u", pRecvData->Data[41], pRecvData->Data[42]);
dataNodeInfo.WaveInterVal = atoi(buf); //原始波形发送周期 2 byte
memset(buf, 0, 32);
sprintf(buf, "%02x%02x", pRecvData->Data[43], pRecvData->Data[44]); // Zigbee PID 2 byte
dataNodeInfo.ZigbeePanId = std::string(buf);
chTemp = pRecvData->Data[45];
memset(buf, 0, 32);
sprintf(buf, "%d", chTemp);
dataNodeInfo.ZigbeeChannel = atoi(buf); // Zigbee 信道 1 byte
memset(buf, 0, 32);
sprintf(buf, "%02x%02x", pRecvData->Data[46], pRecvData->Data[47]); // Zigbee 本地地址 2 byte
dataNodeInfo.ZigbeeShortAddr = std::string(buf);
unsigned char shortAddr[2] = {0x00};
memcpy(shortAddr, (unsigned char *)&pRecvData->Data[46], 2);
modify_DistAddr(shortAddr); //修改目标地址
std::string strTime = GetLocalTimeWithMs();
memset(buf, 0, 32);
sprintf(buf, "%02x%02x", pRecvData->Data[48], pRecvData->Data[49]); // Zigbee 目标地址 2 byte
dataNodeInfo.ZigbeeDesAddr = std::string(buf);
// 50 51 52=》序号23 zigbee重试间隔
memset(buf, 0, 32);
sprintf(buf, "%02x", pRecvData->Data[50]); // Zigbee 发射功率 1 byte
dataNodeInfo.ZigbeePower = atoi(buf);
memset(buf, 0, 32);
sprintf(buf, "%d", BUILD_UINT16(00, pRecvData->Data[51])); // Zigbee 重试次数 1 byte
dataNodeInfo.ZigbeeRetry = atoi(buf);
memset(buf, 0, 32);
sprintf(buf, "%d", BUILD_UINT16(00, pRecvData->Data[52])); // Zigbee 重试间隔 1 byte
dataNodeInfo.ZigbeeRetryGap = atoi(buf);
if (dataNodeInfo.ProductNo == "01") {
chTemp = pRecvData->Data[53];
unsigned char range = (chTemp >> 2) & 0x3;
dataNodeInfo.Range = range;
int SamplingRate = (chTemp & 0x3);
if (SamplingRate == 0) {
dataNodeInfo.SamplingRate = 3200;
} else if (SamplingRate == 1) {
dataNodeInfo.SamplingRate = 6400;
} else if (SamplingRate == 2) {
dataNodeInfo.SamplingRate = 12800;
} else if (SamplingRate == 3) {
dataNodeInfo.SamplingRate = 25600;
}
} else if (dataNodeInfo.ProductNo == "02") {
chTemp = pRecvData->Data[53];
unsigned char range = (chTemp >> 3) & 0x7;
dataNodeInfo.Range = range;
int SamplingRate = (chTemp & 0x7);
if (SamplingRate == 0) {
dataNodeInfo.SamplingRate = 8000;
} else if (SamplingRate == 1) {
dataNodeInfo.SamplingRate = 16000;
} else if (SamplingRate == 2) {
dataNodeInfo.SamplingRate = 24000;
} else if (SamplingRate == 3) {
dataNodeInfo.SamplingRate = 32000;
} else if (SamplingRate == 4) {
dataNodeInfo.SamplingRate = 48000;
} else if (SamplingRate == 5) {
dataNodeInfo.SamplingRate = 96000;
} else if (SamplingRate == 6) {
dataNodeInfo.SamplingRate = 192000;
}
}
优化调度和协议交互，增加web统计成功率
2025-05-10 11:43:05 +08:00
int upgrade = GET_BIT(chTemp, 7);
add manager codes,again
2025-01-23 11:13:58 +08:00
// 54=》序号25 ACC采样时间
memset(buf, 0, 32);
sprintf(buf, "%u", pRecvData->Data[54]); // ACC 采样时间 1 byte
dataNodeInfo.ACCSampleTime = atoi(buf);
int iTemp = 0;
//使用了55 56 59 60 63 64 67 68 71 72
for (int i = 0; i < 5; i++) {
memset(buf, 0, 32);
sprintf(buf, "%02x%02x", pRecvData->Data[55 + i * 4], pRecvData->Data[55 + i * 4 + 1]);
iTemp = (int)strtol(buf, NULL, 16);
if (0 == i) {
dataNodeInfo.StartBrands = std::to_string(iTemp);
} else {
dataNodeInfo.StartBrands += ("," + std::to_string(iTemp));
}
}
//使用了57 58 61 62 65 66 69 70 73 74
for (int j = 0; j < 5; j++) {
memset(buf, 0, 32);
sprintf(buf, "%02x%02x", pRecvData->Data[57 + j * 4], pRecvData->Data[57 + j * 4 + 1]);
iTemp = (int)strtol(buf, NULL, 16);
if (0 == j) {
dataNodeInfo.StopBrands = std::to_string(iTemp);
} else {
dataNodeInfo.StopBrands += ("," + std::to_string(iTemp));
}
}
memset(buf, 0, 32);
sprintf(buf, "%02x%02x", pRecvData->Data[75], pRecvData->Data[76]);
iTemp = (int)strtol(buf, NULL, 16);
dataNodeInfo.EnvelopeBandPass = std::to_string(iTemp);
memset(buf, 0, 32);
sprintf(buf, "%02x%02x", pRecvData->Data[77], pRecvData->Data[78]);
iTemp = (int)strtol(buf, NULL, 16);
dataNodeInfo.EnvelopeBandPass += ("," + std::to_string(iTemp));
//使用了79 80 81 82 83 84 85 86
for (int j = 0; j < 4; j++) {
memset(buf, 0, 32);
sprintf(buf, "%02x%02x", pRecvData->Data[79 + j * 2], pRecvData->Data[79 + j * 2 + 1]);
iTemp = (int)strtol(buf, NULL, 16);
if (0 == j) {
dataNodeInfo.FaultFrequency = std::to_string(iTemp);
} else {
dataNodeInfo.FaultFrequency += ("," + std::to_string(iTemp));
}
}
memset(buf, 0, 32);
sprintf(buf, "%02x%02x%02x%02x", pRecvData->Data[87], pRecvData->Data[88], pRecvData->Data[89], pRecvData->Data[90]);
long lTimeStamp = strtol(buf, NULL, 16);
dataNodeInfo.ConfigDate = std::to_string(lTimeStamp);
chTemp = pRecvData->Data[91];
memset(buf, 0, 32);
sprintf(buf, "%d", chTemp);
dataNodeInfo.VIntegralFilterFrequency = atoi(buf);
优化调度和协议交互，增加web统计成功率
2025-05-10 11:43:05 +08:00
sprintf(whereCon, "dataNodeNo='%s'", dataNodeInfo.ZigbeeLongAddr.c_str());
std::string soft_version = sqlite_db_ctrl::instance().GetData(T_SENSOR_INFO(TNAME), " softVersion ", whereCon);
add manager codes,again
2025-01-23 11:13:58 +08:00
sprintf(whereCon, "dataNodeNo='%s'", dataNodeInfo.ZigbeeLongAddr.c_str());
if (sqlite_db_ctrl::instance().GetTableRows(T_SENSOR_INFO(TNAME), whereCon) > 0) {
char updateSql[1024] = {0};
sprintf(updateSql, " initFlag = '%d',accFlag = '%d',zigbeeFlag = '%d',temTopFlag = '%d',temBotFlag = '%d',equipSta = '%d',\
hardVersion = '%s',softVersion = '%s',bpNo = '%s',serialNo = '%s',firstPowerTime = '%s',WakeupTime = '%d',\
StaticTime = '%d',WaveTime = '%d',BateryV = '%d',ProductNo = '%s',configFlag = '%d',startBrands = '%s',\
stopBrands = '%s',featureInterVal = '%u',waveInterVal = '%d',samplingRate = '%d',scope = '%s',range = '%d',envelopeBandPass = '%s',faultFrequency = '%s',\
zigbeePanId = '%s',zigbeeChannel = '%d',zigbeeShortAddr = '%s',zigbeeLongAddr = '%s',zigbeeDesAddr = '%s',\
ZigbeePower = '%d',ZigbeeRetry = '%d',ZigbeeRetryGap = '%d',ACCSampleTime = '%d',status = '%s',timeStamp = '%s',viff = '%d',RSSI = '0,%d',UpdateFlag = 1",
dataNodeInfo.InitFlag, dataNodeInfo.AccFlag, dataNodeInfo.ZigbeeFlag, dataNodeInfo.TemTopFlag, dataNodeInfo.TemBotFlag, dataNodeInfo.EquipSta, dataNodeInfo.HardVersion.c_str(), dataNodeInfo.SoftVersion.c_str(), dataNodeInfo.BpNo.c_str(),
dataNodeInfo.SerialNo.c_str(), dataNodeInfo.FirstPowerTime.c_str(), dataNodeInfo.WakeupTime, dataNodeInfo.StaticTime, dataNodeInfo.WaveTime, dataNodeInfo.BateryV, dataNodeInfo.ProductNo.c_str(), dataNodeInfo.ConfigFlag, dataNodeInfo.StartBrands.c_str(),
dataNodeInfo.StopBrands.c_str(), dataNodeInfo.FeatureInterVal, dataNodeInfo.WaveInterVal, dataNodeInfo.SamplingRate, "", dataNodeInfo.Range, dataNodeInfo.EnvelopeBandPass.c_str(), dataNodeInfo.FaultFrequency.c_str(), dataNodeInfo.ZigbeePanId.c_str(),
dataNodeInfo.ZigbeeChannel, dataNodeInfo.ZigbeeShortAddr.c_str(), dataNodeInfo.ZigbeeLongAddr.c_str(), dataNodeInfo.ZigbeeDesAddr.c_str(), dataNodeInfo.ZigbeePower, dataNodeInfo.ZigbeeRetry, dataNodeInfo.ZigbeeRetryGap, dataNodeInfo.ACCSampleTime, "1",
dataNodeInfo.ConfigDate.c_str(), dataNodeInfo.VIntegralFilterFrequency, dataNodeInfo.RSSI);
sprintf(whereCon, "dataNodeNo = '%s'", dataNodeInfo.ZigbeeLongAddr.c_str());
res = sqlite_db_ctrl::instance().UpdateTableData(T_SENSOR_INFO(TNAME), updateSql, whereCon);
if(res !=0 ){
zlog_error(zct, "res = %d", res);
}
} else {
char insertSql[1024] = {0};
sprintf(insertSql, " '%s','%s','%d','%d','%d','%d','%d','%d',\
'%s','%s','%s','%s','%s','%d',\
'%d','%d','%d','%s','%d','%s',\
'%s','%u','%d','%d','%s','%d', '%s', '%s',\
'%s','%d','%s','%s','%s',\
'%d','%d','%d','%d','%s','%s', '%d', '0,%d','1','0,0','','','',0",
dataNodeInfo.ZigbeeLongAddr.c_str(), " ", dataNodeInfo.InitFlag, dataNodeInfo.AccFlag, dataNodeInfo.ZigbeeFlag, dataNodeInfo.TemTopFlag, dataNodeInfo.TemBotFlag, dataNodeInfo.EquipSta, dataNodeInfo.HardVersion.c_str(), dataNodeInfo.SoftVersion.c_str(),
dataNodeInfo.BpNo.c_str(), dataNodeInfo.SerialNo.c_str(), dataNodeInfo.FirstPowerTime.c_str(), dataNodeInfo.WakeupTime, dataNodeInfo.StaticTime, dataNodeInfo.WaveTime, dataNodeInfo.BateryV, dataNodeInfo.ProductNo.c_str(), dataNodeInfo.ConfigFlag,
dataNodeInfo.StartBrands.c_str(), dataNodeInfo.StopBrands.c_str(), dataNodeInfo.FeatureInterVal, dataNodeInfo.WaveInterVal, dataNodeInfo.SamplingRate, "", dataNodeInfo.Range, dataNodeInfo.EnvelopeBandPass.c_str(), dataNodeInfo.FaultFrequency.c_str(),
dataNodeInfo.ZigbeePanId.c_str(), dataNodeInfo.ZigbeeChannel, dataNodeInfo.ZigbeeShortAddr.c_str(), dataNodeInfo.ZigbeeLongAddr.c_str(), dataNodeInfo.ZigbeeDesAddr.c_str(), dataNodeInfo.ZigbeePower, dataNodeInfo.ZigbeeRetry, dataNodeInfo.ZigbeeRetryGap,
dataNodeInfo.ACCSampleTime, "1", dataNodeInfo.ConfigDate.c_str(), dataNodeInfo.VIntegralFilterFrequency, dataNodeInfo.RSSI);
res = sqlite_db_ctrl::instance().InsertData(T_SENSOR_INFO(TNAME), insertSql);
if(res !=0 ){
zlog_error(zct, "res = %d", res);
}
}
优化调度和协议交互，增加web统计成功率
2025-05-10 11:43:05 +08:00
zlog_info(zct, "upgrade = %d", upgrade);
if (upgrade == 1)
{
zlog_info(zct, "soft_version = %s,dataNodeInfo.SoftVersion = %s", soft_version.c_str(),dataNodeInfo.SoftVersion.c_str());
if (dataNodeInfo.SoftVersion != soft_version) {
DealUpgrade(ushortAdd,2);
scheduler::instance().UpgradeResult(ushortAdd,0);
}else{
DealUpgrade(ushortAdd,3);
scheduler::instance().UpgradeResult(ushortAdd,3);
}
}
add manager codes,again
2025-01-23 11:13:58 +08:00
Json::Value jsonVal;
jsonVal.clear();
jsonVal["cmd"] = "26";
Json::Value jsBody;
jsBody["dataNodeGatewayNo"] = GlobalConfig::MacAddr_G;
jsBody["dataNodeNo"] = dataNodeInfo.ZigbeeLongAddr;
jsBody["type"] = "insert";
Json::Value jsSensorData;
jsSensorData["dataNodeNo"] = dataNodeInfo.ZigbeeLongAddr;
jsSensorData["dataNodeName"] = "";
jsSensorData["initFlag"] = dataNodeInfo.InitFlag;
jsSensorData["accFlag"] = dataNodeInfo.AccFlag;
jsSensorData["zigbeeFlag"] = dataNodeInfo.ZigbeeFlag;
jsSensorData["temTopFlag"] = dataNodeInfo.TemTopFlag;
jsSensorData["temBotFlag"] = dataNodeInfo.TemBotFlag;
jsSensorData["equipsta"] = dataNodeInfo.EquipSta;
jsSensorData["hardVersion"] = dataNodeInfo.HardVersion;
jsSensorData["softVersion"] = dataNodeInfo.SoftVersion;
jsSensorData["bpNo"] = dataNodeInfo.BpNo;
jsSensorData["serialNo"] = dataNodeInfo.SerialNo;
jsSensorData["firstPowerTime"] = dataNodeInfo.FirstPowerTime;
jsSensorData["configFlag"] = dataNodeInfo.ConfigFlag;
jsSensorData["startBrands"] = dataNodeInfo.StartBrands;
jsSensorData["stopBrands"] = dataNodeInfo.StopBrands;
jsSensorData["featureInterVal"] = dataNodeInfo.FeatureInterVal;
jsSensorData["waveInterVal"] = dataNodeInfo.WaveInterVal;
jsSensorData["samplingRate"] = dataNodeInfo.SamplingRate;
jsSensorData["range"] = dataNodeInfo.Range;
jsSensorData["envelopeBandPass"] = dataNodeInfo.EnvelopeBandPass;
jsSensorData["faultFrequency"] = dataNodeInfo.FaultFrequency;
jsSensorData["zigbeePanId"] = dataNodeInfo.ZigbeePanId;
jsSensorData["zigbeeChannel"] = dataNodeInfo.ZigbeeChannel;
jsSensorData["zigbeeAddr"] = dataNodeInfo.ZigbeeLongAddr;
jsSensorData["zigbeeDesAddr"] = dataNodeInfo.ZigbeeDesAddr;
jsSensorData["status"] = 1;
jsSensorData["timeStamp"] = dataNodeInfo.ConfigDate;
jsSensorData["VIntegralFilterFrequency"] = dataNodeInfo.VIntegralFilterFrequency;
jsSensorData["RSSI"] = dataNodeInfo.RSSI;
jsBody["dataNodeInfo"] = jsSensorData;
Json::FastWriter showValue;
std::string dataBody = showValue.write(jsBody);
jsonVal["cmdBody"] = dataBody;
std::string strCmd26 = showValue.write(jsonVal);
// 传感器发来的数据包中的表示设备信息的数据转化为json格式后，通过调用data_publish将数据传给mqttclient ： Topic：wireless/cmd/60294D203717
res = data_publish(strCmd26.c_str(), GlobalConfig::Topic_G.mPubCmd.c_str());
if(res !=0 ){
zlog_error(zct, "res = %d", res);
}
zlog_info(zct, "remote wireless sensor device info AccFlag : %d EquipSta : %d BpNo : %s ConfigFlag : %d EnvelopeBandPass : %s FaultFrequency : %s FeatureInterVal : %u FirstPowerTime : %s HardVersion : %s InitFlag : %d SamplingRate : %d range : %d SerialNo : %s\
SoftVersion : %s StartBrands : %s StopBrands : %s TemBotFlag : %d TemTopFlag : %d WaveInterVal : %d ZigbeeChannel : %d ZigbeeDesAddr : %s ZigbeeFlag : %d ZigbeeLongAddr : %s panid : %s ZigbeeShortAddr : %s Configdate : %s vintegralfilterfrequency : %d RSSI : %d ",
dataNodeInfo.AccFlag, dataNodeInfo.EquipSta, dataNodeInfo.BpNo.c_str(), dataNodeInfo.ConfigFlag, dataNodeInfo.EnvelopeBandPass.c_str(), dataNodeInfo.FaultFrequency.c_str(), dataNodeInfo.FeatureInterVal, dataNodeInfo.FirstPowerTime.c_str(),
dataNodeInfo.HardVersion.c_str(), dataNodeInfo.InitFlag, dataNodeInfo.SamplingRate, dataNodeInfo.Range, dataNodeInfo.SerialNo.c_str(), dataNodeInfo.SoftVersion.c_str(), dataNodeInfo.StartBrands.c_str(), dataNodeInfo.StopBrands.c_str(), dataNodeInfo.TemBotFlag,
dataNodeInfo.TemTopFlag, dataNodeInfo.WaveInterVal, dataNodeInfo.ZigbeeChannel, dataNodeInfo.ZigbeeDesAddr.c_str(), dataNodeInfo.ZigbeeFlag, dataNodeInfo.ZigbeeLongAddr.c_str(), dataNodeInfo.ZigbeePanId.c_str(), dataNodeInfo.ZigbeeShortAddr.c_str(),
dataNodeInfo.ConfigDate.c_str(), dataNodeInfo.VIntegralFilterFrequency, dataNodeInfo.RSSI);
if (g_mapCompress.find(dataNodeInfo.ZigbeeShortAddr) == g_mapCompress.end()) {
compressWaveChannel tempchannel;
g_mapCompress.insert(std::make_pair(dataNodeInfo.ZigbeeShortAddr, tempchannel));
zlog_info(zct, "new Node,size = %d", g_mapCompress.size());
}
zlog_info(zct, "DealDataNodeInfo %s ", dataNodeInfo.ZigbeeShortAddr.c_str());
}
void Uart::ZigbeeParameterConfig() {
std::string strPanId = sqlite_db_ctrl::instance().GetData("t_gateway_info", "zigbeePanID", NULL);
{
unsigned short shortAddr = 0x8888;
WriteShortAddr2Zigbee(shortAddr);
mssleep(100000);
}
zlog_info(zct, "strPanId : %s", strPanId.c_str());
zlog_info(zct, "MacAddr_G : %s", GlobalConfig::MacAddr_G.c_str());
std::string strchan = ReadStrByOpt(ZIGBEECONFIG, "Zigbee", "channel");
unsigned short Chan = (unsigned short)strtol(strchan.c_str(), NULL, 10);
zlog_info(zct, "the chan = %d", Chan);
zlog_info(zct, "ZigbeeInfo_G.Channel=%d", GlobalConfig::ZigbeeInfo_G.Channel);
if (Chan > 10 && Chan < 27) {
WriteChanl2Zigbee(Chan);
mssleep(100000);
}
zlog_info(zct, "PanID1 = %s,strPanId = %s", GlobalConfig::ZigbeeInfo_G.PanID.c_str(), strPanId.c_str());
long lShortAddr = strtol(strPanId.c_str(), NULL, 16);
unsigned short panid = lShortAddr & 0xffff;
WritePanId2Zigbee(panid);
mssleep(100000);
zlog_info(zct, "ZigbeeInfo_G.MyAddr=%s", GlobalConfig::ZigbeeInfo_G.MyAddr.c_str());
}
int Uart::FindRecvPackage(int bytesRead, char *mUartRecvBuf, char *head) {
char localtimestamp[32] = {0};
GetTimeNet(localtimestamp, 1);
char head1[] = {0xAB, 0xBC, 0xCD};
char head2[] = {0xDE, 0xDF, 0xEF};
int lastSize = 0;
char UartRecvBuf[BUF_LENGTH * 15] = {0x00};
char RecvBuf[200] = {0x00};
if (mlastSize > 0) {
zlog_info(zct, "mlastSize = %d", mlastSize);
memcpy(UartRecvBuf, mUartRecvTmpBuf, mlastSize);
for (int i = 0; i < mlastSize; i++) {
zlog_info(zct, "%02x ", UartRecvBuf[i]);
}
memset(mUartRecvTmpBuf, 0x00, sizeof(mUartRecvTmpBuf));
}
memcpy(UartRecvBuf + mlastSize, mUartRecvBuf, bytesRead);
添加波形接收时重发条件，添加可以解析xyz任一波形，添加可以统计特征值次数
2025-04-08 14:24:50 +08:00
bool wave_error_x = false;
bool wave_error_y = false;
bool wave_error_z = false;
add manager codes,again
2025-01-23 11:13:58 +08:00
bytesRead = bytesRead + mlastSize;
for (int i = 0; i < bytesRead; i++) {
if (UartRecvBuf[i] == head[0]) {
char buf[12] = {0x00};
char ShortAddr[8] = {0x00};
sprintf(buf, "%02X%02X%02X", UartRecvBuf[i] & 0xFF,UartRecvBuf[i + 1] & 0xFF,UartRecvBuf[i + 2] & 0xFF);
sprintf(ShortAddr, "%02x%02x", UartRecvBuf[i + 3] & 0xFF, UartRecvBuf[i + 4] & 0xFF);
std::string strShortAddr(ShortAddr);
std::string strHeadFlag(buf);
if (0 == strHeadFlag.compare("AA55AA")) {
char buf[8] = {0x00};
sprintf(buf, "%02d", UartRecvBuf[i + 5]);
int command = atoi(buf);
添加波形接收时重发条件，添加可以解析xyz任一波形，添加可以统计特征值次数
2025-04-08 14:24:50 +08:00
if (wave_error_x && !wave_error_y && !wave_error_z && command == WAVE_X)
{
continue;
}
else if ((wave_error_x || wave_error_y) && !wave_error_z && command == WAVE_Y)
{
continue;
}
if ( wave_error_z && command == WAVE_Z)
{
m_waveCountX = 0;
m_waveCountY = 0;
m_waveCountZ = 0;
g_VecWaveDataX.clear();
g_VecWaveDataY.clear();
g_VecWaveDataZ.clear();
break;
}
if ((mPackgeIndex == -1 || (unsigned int)UartRecvBuf[i + 6] == 0) && (command == WAVE_X || command == WAVE_Y || command == WAVE_Z) && now_task == WAVE_CMD) {
add manager codes,again
2025-01-23 11:13:58 +08:00
mPackgeIndex = UartRecvBuf[i + 6] & 0xFF;
添加波形接收时重发条件，添加可以解析xyz任一波形，添加可以统计特征值次数
2025-04-08 14:24:50 +08:00
} else if ((unsigned int)mPackgeIndex == (unsigned int)UartRecvBuf[i + 6] && mPackgeIndex != -1 && command != 2 && (command == WAVE_X || command == WAVE_Y || command == WAVE_Z) && now_task == WAVE_CMD) {
add manager codes,again
2025-01-23 11:13:58 +08:00
zlog_warn(zct, "mPackgeIndex same index1:%d,index2:%02d ShortAddr :%s ", mPackgeIndex, UartRecvBuf[i + 6] & 0xff, strShortAddr.c_str());
continue;
添加波形接收时重发条件，添加可以解析xyz任一波形，添加可以统计特征值次数
2025-04-08 14:24:50 +08:00
} else if ((unsigned int)mPackgeIndex + 1 != (unsigned int)UartRecvBuf[i + 6] && mPackgeIndex != -1 && command != 2 && (command == WAVE_X || command == WAVE_Y || command == WAVE_Z) && now_task == WAVE_CMD) {
zlog_warn(zct, "mPackgeIndex error index1:%d,index2:%02d ShortAddr :%s ,now_task = %d", mPackgeIndex, UartRecvBuf[i + 6] & 0xff, strShortAddr.c_str(),now_task);
zlog_warn(zct, "mPackgeIndex error ShortAddr :%s", strShortAddr.c_str());
add manager codes,again
2025-01-23 11:13:58 +08:00
char tmp[10] = {0x00};
char tmp2[10] = {0x00};
for (int j = 0; j < 100; j++) {
sprintf(tmp, "%02x ", UartRecvBuf[i + j] & 0xff);
strcat(tmp2, tmp);
}
zlog_warn(zct, "error str = %s", tmp2);
char insertSql[100] = {0x00};
char whereCon[50] = {0x00};
std::string error_msg = "";
std::string strChannelID = "";
sprintf(whereCon, "zigbeeShortAddr='%s'",strShortAddr.c_str());
std::string strMeasurementID = sqlite_db_ctrl::instance().GetData(T_SENSOR_INFO(TNAME), " MeasurementID ", whereCon);
memset(whereCon, 0x00, sizeof(whereCon));
if (command == WAVE_X){
error_msg = "Index error,wave X";
strChannelID = strMeasurementID + "-X";
添加波形接收时重发条件，添加可以解析xyz任一波形，添加可以统计特征值次数
2025-04-08 14:24:50 +08:00
wave_error_x = true;
add manager codes,again
2025-01-23 11:13:58 +08:00
}else if (command == WAVE_Y){
error_msg = "Index error,wave Y";
strChannelID = strMeasurementID + "-Y";
添加波形接收时重发条件，添加可以解析xyz任一波形，添加可以统计特征值次数
2025-04-08 14:24:50 +08:00
wave_error_y = true;
add manager codes,again
2025-01-23 11:13:58 +08:00
}else if (command == WAVE_Z){
error_msg = "Index error,wave Z";
strChannelID = strMeasurementID + "-Z";
添加波形接收时重发条件，添加可以解析xyz任一波形，添加可以统计特征值次数
2025-04-08 14:24:50 +08:00
wave_error_z = true;
add manager codes,again
2025-01-23 11:13:58 +08:00
}
解决bug,优化波形接收需要补发的逻辑，version 5.6
2025-04-10 15:50:52 +08:00
zlog_error(zct, "WaveError error ShortAddr :%s", strShortAddr.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);
添加波形接收时重发条件，添加可以解析xyz任一波形，添加可以统计特征值次数
2025-04-08 14:24:50 +08:00
add manager codes,again
2025-01-23 11:13:58 +08:00
JsonData jd;
jd.JsonCmd_32(strMeasurementID,1,1,strChannelID,error_msg);
添加波形接收时重发条件，添加可以解析xyz任一波形，添加可以统计特征值次数
2025-04-08 14:24:50 +08:00
continue;
add manager codes,again
2025-01-23 11:13:58 +08:00
}
if (now_task == WAVE_CMD && (command == WAVE_X || command == WAVE_Y || command == WAVE_Z)) {
if (!CheckCrc(&UartRecvBuf[i], 99)) {
zlog_warn(zct, "CheckCrc error ShortAddr :%s command = %d", strShortAddr.c_str(), command);
char tmp[10] = {0x00};
char tmp2[10] = {0x00};
for (int j = 0; j < 100; j++) {
sprintf(tmp, "%02x ", UartRecvBuf[i + j] & 0xff);
strcat(tmp2, tmp);
}
zlog_error(zct, "error str = %s", tmp2);
添加波形接收时重发条件，添加可以解析xyz任一波形，添加可以统计特征值次数
2025-04-08 14:24:50 +08:00
add manager codes,again
2025-01-23 11:13:58 +08:00
char insertSql[100] = {0x00};
char whereCon[50] = {0x00};
std::string error_msg = "";
std::string strChannelID = "";
sprintf(whereCon, "zigbeeShortAddr='%s'",strShortAddr.c_str());
std::string strMeasurementID = sqlite_db_ctrl::instance().GetData(T_SENSOR_INFO(TNAME), " MeasurementID ", whereCon);
memset(whereCon, 0x00, sizeof(whereCon));
if (command == WAVE_X){
error_msg = "Crc error,wave X";
strChannelID = strMeasurementID + "-X";
添加波形接收时重发条件，添加可以解析xyz任一波形，添加可以统计特征值次数
2025-04-08 14:24:50 +08:00
wave_error_x = true;
add manager codes,again
2025-01-23 11:13:58 +08:00
}else if (command == WAVE_Y){
error_msg = "Crc error,wave Y";
strChannelID = strMeasurementID + "-Y";
添加波形接收时重发条件，添加可以解析xyz任一波形，添加可以统计特征值次数
2025-04-08 14:24:50 +08:00
wave_error_y = true;
add manager codes,again
2025-01-23 11:13:58 +08:00
}else if (command == WAVE_Z){
error_msg = "Crc error,wave Z";
strChannelID = strMeasurementID + "-Z";
添加波形接收时重发条件，添加可以解析xyz任一波形，添加可以统计特征值次数
2025-04-08 14:24:50 +08:00
wave_error_z = true;
add manager codes,again
2025-01-23 11:13:58 +08:00
}
解决bug,优化波形接收需要补发的逻辑，version 5.6
2025-04-10 15:50:52 +08:00
zlog_error(zct, "WaveError error ShortAddr :%s", strShortAddr.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);
add manager codes,again
2025-01-23 11:13:58 +08:00
JsonData jd;
jd.JsonCmd_32(strMeasurementID,1,1,strChannelID,error_msg);
添加波形接收时重发条件，添加可以解析xyz任一波形，添加可以统计特征值次数
2025-04-08 14:24:50 +08:00
continue;
add manager codes,again
2025-01-23 11:13:58 +08:00
}
mlastSize = 0;
lastSize = bytesRead - i;
if (lastSize < 100 && lastSize > 0) {
memcpy(mUartRecvTmpBuf, (char *)&UartRecvBuf[bytesRead - lastSize], lastSize);
mlastSize = lastSize;
break;
}
memcpy(RecvBuf, (char *)&UartRecvBuf[i], 100);
DealDataNodeWave(RecvBuf, command);
mPackgeIndex = (unsigned int)UartRecvBuf[i + 6];
优化调度和协议交互，增加web统计成功率
2025-05-10 11:43:05 +08:00
} else if (now_task != WAVE_CMD && ( command == DEVICE_INF || command == MEAS_EVAL || command == CONFIG || command == UPGRADE || command == DEVICE_INF2 || command == SIGNAL_STRENGTH || command == DEVICE_EXCEPTION || command == UPGRADE_ASK)) {
add manager codes,again
2025-01-23 11:13:58 +08:00
char RecvBuf[100] = {0x00};
优化调度和协议交互，增加web统计成功率
2025-05-10 11:43:05 +08:00
if (command == UPGRADE_ASK)
add manager codes,again
2025-01-23 11:13:58 +08:00
{
memcpy(RecvBuf, &UartRecvBuf[i], 8);
if (!CheckCrc(RecvBuf, 7)) {
zlog_warn(zct, "CheckCrc error ShortAddr :%s command = %d ", strShortAddr.c_str(), command);
break;
}
}
优化调度和协议交互，增加web统计成功率
2025-05-10 11:43:05 +08:00
if (command == CONFIG || command == CONFIG_INF2 || command == UPGRADE || command == SIGNAL_STRENGTH || command == DEVICE_EXCEPTION)
add manager codes,again
2025-01-23 11:13:58 +08:00
{
memcpy(RecvBuf, &UartRecvBuf[i], 9);
if (!CheckCrc(RecvBuf, 8)) {
zlog_warn(zct, "CheckCrc error ShortAddr :%s command = %d ", strShortAddr.c_str(), command);
break;
}
}
if (command == DEVICE_INF || command == MEAS_EVAL || command == DEVICE_INF2)
{
memcpy(RecvBuf, &UartRecvBuf[i], 100);
if (!CheckCrc(RecvBuf, 99)) {
zlog_warn(zct, "CheckCrc error ShortAddr :%s command = %d ", strShortAddr.c_str(), command);
break;
}
}
DealRecvData(RecvBuf);
优化调度和协议交互，增加web统计成功率
2025-05-10 11:43:05 +08:00
}else if( command == WAVE_COMPRESS && now_task != WAVE_CMD) {
memcpy(RecvBuf, &UartRecvBuf[i], 24);
if (!CheckCrc(RecvBuf, 23)) {
add manager codes,again
2025-01-23 11:13:58 +08:00
zlog_warn(zct, "CheckCrc error ShortAddr :%s command = %d ", strShortAddr.c_str(), command);
break;
}
优化调度和协议交互，增加web统计成功率
2025-05-10 11:43:05 +08:00
// char tmp[23] = {0x00};
// char tmp2[23] = {0x00};
// for (int j = 0; j < 23; j++) {
// sprintf(tmp, "%02x ", UartRecvBuf[i + j] & 0xff);
// strcat(tmp2, tmp);
// }
// zlog_info(zct, "str = %s", tmp2);
add manager codes,again
2025-01-23 11:13:58 +08:00
DealRecvData(RecvBuf);
} else if (command == 35) {
char signalNode[10] = {0x00};
sprintf(signalNode, "%02d", UartRecvBuf[i + 14] & 0xFF);
if (!strcmp(signalNode, "00") || !strcmp(signalNode, "0")) {
char errorInfo[100] = {0x00};
sprintf(errorInfo, "No RSSI %s", signalNode);
zlog_warn(zct, errorInfo);
} else {
char whereCon[1024] = {0};
char updateSql[1024] = {0};
char tableName[100] = {0x00};
sprintf(whereCon, "zigbeeShortAddr='%s'", strShortAddr.c_str());
vec_t vecDataNodeNo = sqlite_db_ctrl::instance().GetDataSingleLine(T_SENSOR_INFO(TNAME), " dataNodeNo,RSSI ", whereCon);
memset(whereCon, 0x00, sizeof(whereCon));
sprintf(updateSql, "zigbeeSignalNode = '%02d' ", UartRecvBuf[i + 14] & 0xFF); // zigbeeRSSIType = 0 传感器获取网关信号强度
sprintf(whereCon, "dataNodeNo='%s' and timeStamp = '%s'", (char *)vecDataNodeNo[0].c_str(), strTimetamp.c_str());
sprintf(tableName, "t_dataStatic_%s", (char *)vecDataNodeNo[0].c_str());
sqlite_db_ctrl::instance().UpdateTableData(tableName, updateSql, whereCon);
std::vector<std::string> vParamRSSI;
boost::split(vParamRSSI, vecDataNodeNo[1], boost::is_any_of(","), boost::token_compress_on);
if (vParamRSSI.size() > 0) {
sprintf(updateSql, "RSSI = '%s,%02d' ", vParamRSSI[0].c_str(), UartRecvBuf[i + 14] & 0xFF);
sprintf(whereCon, "dataNodeNo='%s'", (char *)vecDataNodeNo[0].c_str());
sqlite_db_ctrl::instance().UpdateTableData(T_SENSOR_INFO(TNAME), updateSql, whereCon);
}
}
}
} else {
continue;
}
} else if (UartRecvBuf[i] == head1[0]) {
char buf[12] = {0x00};
sprintf(buf, "%02X%02X%02X", UartRecvBuf[i] & 0xFF,UartRecvBuf[i + 1] & 0xFF,UartRecvBuf[i + 2] & 0xFF);
std::string strHeadFlag(buf);
if (0 == strHeadFlag.compare("ABBCCD")) {
char buf[8] = {0x00};
sprintf(buf, "%02d", UartRecvBuf[i + 3] & 0xFF);
int command = atoi(buf);
zlog_info(zct, "command = %d", command);
if (command == 209) {
UpdateZigbeeInfo(&UartRecvBuf[i]);
} else if (command == 220) { // DC
zlog_info(zct, "zigbeeShortAddr = %s , ret = %02d", m_strDestShortAddr.c_str(), UartRecvBuf[i + 6] & 0xFF);
if ((UartRecvBuf[i + 6] & 0xFF) != 0) {
modify_LocalAddr(0x8888);
}
}
}
} else if (UartRecvBuf[i] == head2[0]) {
char buf[12] = {0x00};
sprintf(buf, "%02X%02X%02X", UartRecvBuf[i] & 0xFF,UartRecvBuf[i + 1] & 0xFF,UartRecvBuf[i + 2] & 0xFF);
std::string strHeadFlag(buf);
if (0 == strHeadFlag.compare("DEDFEF")) {
char buf[8] = {0x00};
sprintf(buf, "%02d", UartRecvBuf[i + 3] & 0xFF);
int command = atoi(buf);
zlog_info(zct, "command = %d", command);
if (command == 209) { // D1
pTestRecv(command);
} else if (command == 219) { // DB
pTestRecv(command);
} else if (command == 220) { // DC
zlog_info(zct, "%02x,%02x,%02x,%02x,%02x ", UartRecvBuf[i], UartRecvBuf[i + 1], UartRecvBuf[i + 2], UartRecvBuf[i + 3], UartRecvBuf[i + 4]);
zlog_info(zct, "zigbeeShortAddr = %s , ret = %02d", m_strDestShortAddr.c_str(), UartRecvBuf[i + 4] & 0xFF);
} else if (command == 218) { // DA 网关获取传感器信号强度
char localtimestamp[32] = {0};
GetTimeNet(localtimestamp, 1);
char whereCon[1024] = {0};
char updateSql[1024] = {0};
char tableName[100] = {0x00};
bZigbeeSinal = false;
sprintf(whereCon, "zigbeeShortAddr='%02x%02x'", UINT16_HIGH(wave_shortAddr),UINT16_LOW(wave_shortAddr));
vec_t vecDataNodeNo = sqlite_db_ctrl::instance().GetDataSingleLine(T_SENSOR_INFO(TNAME), " MeasurementID,LooseValue,RSSI ", whereCon);
memset(whereCon, 0x00, sizeof(whereCon));
sprintf(tableName,"t_dataStatic_%s",(char*)vecDataNodeNo[0].c_str());
memset(whereCon,0,sizeof(whereCon));
sprintf(whereCon, "dataNodeNo='%s' order by timeStamp desc limit 1", vecDataNodeNo[0].c_str());
std::string timestamp_last = sqlite_db_ctrl::instance().GetData(tableName, " timeStamp ", whereCon);
sprintf(updateSql, "zigbeeSignal = '%02d' ",UartRecvBuf[i+6]&0xFF);
sprintf(whereCon, "dataNodeNo='%s' and timeStamp = '%s'", (char*)vecDataNodeNo[0].c_str(),timestamp_last.c_str());
sqlite_db_ctrl::instance().UpdateTableData(tableName, updateSql, whereCon);
// zigbeeRSSIType = 1 网关获取传感器信号强度
Json::Value jsBody, jsonVal;
Json::FastWriter showValue;
char looseValue[10] = {0x00};
readStringValue("config", (char *)"loose", looseValue, GlobalConfig::Config_G.c_str());
if (atof(looseValue) < atof(vecDataNodeNo[1].c_str())) {
jsBody["looseStatus"] = "1";
} else {
jsBody["looseStatus"] = "0";
}
std::vector<std::string> vParamRSSI;
boost::split(vParamRSSI, vecDataNodeNo[2], boost::is_any_of(","), boost::token_compress_on);
memset(updateSql,0,sizeof(updateSql));
memset(whereCon,0,sizeof(whereCon));
if (vParamRSSI.size() == 1) {
sprintf(updateSql, "RSSI = '%02d,%s' ", UartRecvBuf[i + 6] & 0xFF, vParamRSSI[0].c_str());
} else if (vParamRSSI.size() == 2) {
sprintf(updateSql, "RSSI = '%02d,%s' ", UartRecvBuf[i + 6] & 0xFF, vParamRSSI[1].c_str());
}
sprintf(whereCon, "dataNodeNo='%s'", (char *)vecDataNodeNo[0].c_str());
sqlite_db_ctrl::instance().UpdateTableData(T_SENSOR_INFO(TNAME), updateSql, whereCon);
jsonVal["cmd"] = "52";
jsBody["timeStamp"] = strTimetamp;
jsBody["dataNodeNo"] = vecDataNodeNo[0];
jsBody["zigbeeSignal"] = UartRecvBuf[i + 6] & 0xFF;
std::string dataBody = showValue.write(jsBody);
jsonVal["cmdBody"] = dataBody;
data_publish(showValue.write(jsonVal).c_str(), GlobalConfig::Topic_G.mPubConfig.c_str());
}
}
}
}
return 0;
}
bool Uart::CheckCrc(char *pCheckBuff, int No) {
unsigned char tmp = 0x00;
for (int i = 0; i < No; i++) {
tmp += (unsigned char)pCheckBuff[i];
}
if ((unsigned char)pCheckBuff[No] != (unsigned char)tmp) return false;
return true;
}
Reference in New Issue Copy Permalink