2180 lines
70 KiB
C++
2180 lines
70 KiB
C++
#include <signal.h>
|
||
#include <boost/thread/thread.hpp>
|
||
#include <boost/lexical_cast.hpp>
|
||
#include <boost/algorithm/string.hpp>
|
||
#include <boost/bind.hpp>
|
||
#include <boost/timer.hpp>
|
||
#include <boost/date_time/posix_time/posix_time.hpp>
|
||
#include "../uart/SH_Uart.hpp"
|
||
|
||
namespace{
|
||
Uart *pUart = Uart::instance();
|
||
}
|
||
|
||
|
||
// namespace{
|
||
// PlatformInit *platform = PlatformInit::instance();
|
||
// LocalServer *wlServer = LocalServer::instance();
|
||
// GenericFunc *genericFunc = GenericFunc::instance();
|
||
// }
|
||
using namespace boost::asio;
|
||
const UINT CharSize = 8;
|
||
const UINT UartBaud = 115200;
|
||
|
||
Uart::Uart():mUart(mIoSev),mStrand(mIoSev)
|
||
{
|
||
mRdLength = 0;
|
||
memset(mUartRecvBuf,0,BUF_LENGTH);
|
||
update = false;
|
||
}
|
||
|
||
void Uart::InitUart()
|
||
{
|
||
//*.reset()作用重置对象，为run()的调用做准备
|
||
mUart.get_io_service().reset();
|
||
mStrand.get_io_service().reset();
|
||
// ThreadInit();
|
||
mRdLength = 0;
|
||
//errcode用来接收错误类型
|
||
boost::system::error_code errcode;
|
||
//打开/dev/ttymxc4串口文件
|
||
mUart.open(GlobalConfig::UartName_G,errcode);
|
||
if ( errcode) {
|
||
print_error("Fail To Open Uart!\n");
|
||
// LOG_ERROR("Fail To Open Uart!\n");
|
||
return ;
|
||
} else {
|
||
if (mUart.is_open()) {
|
||
print_info("Success To Open Uart!\n");
|
||
}
|
||
}
|
||
//设置串口的波特率 数据位 流控 奇偶校验位 停止位
|
||
mUart.set_option( serial_port::baud_rate(UartBaud), errcode);
|
||
mUart.set_option( serial_port::flow_control(serial_port::flow_control::none),errcode );
|
||
mUart.set_option( serial_port::parity(serial_port::parity::none),errcode );
|
||
mUart.set_option( serial_port::stop_bits(serial_port::stop_bits::one),errcode );
|
||
mUart.set_option( serial_port::character_size(CharSize),errcode );
|
||
|
||
|
||
// WriteToUart();
|
||
// mUart.set_option( serial_port::baud_rate(UartBaud), errcode);
|
||
|
||
}
|
||
|
||
Uart::~Uart()
|
||
{
|
||
if (mUart.is_open())
|
||
mUart.close();
|
||
}
|
||
|
||
void Uart::WriteToUart(const char *strSend,int pLen)
|
||
{
|
||
//#ifdef ZIGBEE_TEST
|
||
print_debug("Write To Uart Start:\n");
|
||
for(int i=0; i<pLen; i++){
|
||
print_debug("%02X ", *(strSend+i) & 0xFF);
|
||
}
|
||
print_debug("\nWrite To Uart End.\n");
|
||
//#endif
|
||
if (mUart.is_open()) {
|
||
mUart.async_write_some(buffer(strSend,pLen),
|
||
mStrand.wrap(
|
||
boost::bind(&Uart::WriteHandle,this,strSend,
|
||
boost::asio::placeholders::error,
|
||
boost::asio::placeholders::bytes_transferred))
|
||
);
|
||
}
|
||
}
|
||
|
||
void Uart::ReadFromUart()
|
||
{
|
||
if (mUart.is_open()) {
|
||
mUart.async_read_some(buffer(&mUartRecvBuf[mRdLength], BUF_LENGTH-mRdLength-4),
|
||
mStrand.wrap(
|
||
boost::bind(&Uart::ReadHandle,this,
|
||
boost::asio::placeholders::error,
|
||
boost::asio::placeholders::bytes_transferred))
|
||
);
|
||
}
|
||
print_info("async_read_some,wait......................................\n");
|
||
}
|
||
|
||
void Uart::Run()
|
||
{
|
||
mIoSev.run();
|
||
}
|
||
|
||
void Uart::Stop()
|
||
{
|
||
if (mUart.is_open())
|
||
mUart.close();
|
||
mIoSev.stop();
|
||
}
|
||
|
||
void Uart::ReadHandle(const boost::system::error_code &ec,size_t bytesRead)
|
||
{
|
||
try{
|
||
if (ec) {
|
||
mRdLength = 0;
|
||
ReadFromUart();
|
||
return ;
|
||
}
|
||
else
|
||
{ //长度检测
|
||
/* printf("recv uart len in ZigBee short address %4x : %d\n recv uart data:",
|
||
(unsigned short)GlobalConfig::Zigbee_G.MyAddr, bytesRead);
|
||
for (unsigned int i = 0; i < bytesRead; i++)
|
||
print_debug("%02X ",mUartRecvBuf[i]&0xFF);
|
||
*/
|
||
int iPackageSize = bytesRead / 100;
|
||
if (0 == iPackageSize) {
|
||
iPackageSize = 1;
|
||
}
|
||
int Count = bytesRead;
|
||
/*每次看到这块代码时总感觉不妥，因为bytesRead是100的整数倍时对结果不影响；如果不是，则会造成数据丢失（例如1024时，iPackageSize的值
|
||
为10，这样就丢失了24字节的数据）。况且一个传感器与无线网关通信数据量对 无线网关的处理影响不大，但是如果是多个传感器都在和无线网关
|
||
通信，数据量处理不好就会产生很大的影响。我的逻辑：利用while循环，条件是判断bytesRead是否大于0，如果条件满足，再取数据包的前3字节，
|
||
判断命令码是ABBCCD还是AA55AA，如果是ABBCCD就处理74字节数据，如果是AA55AA就处理100自己数据，此时存放数据的buf减去处理的大小数据，
|
||
然后进入下一次while循环。*/
|
||
for (int j = 0; j < iPackageSize; j++) {
|
||
char buf[6];
|
||
char buf1[2];
|
||
char mUartRecvPackage[100] = {0};
|
||
// 多包分包，解包，
|
||
if (Count < 100) {
|
||
memcpy(mUartRecvPackage, &mUartRecvBuf[j * 100], Count);
|
||
} else {
|
||
memcpy(mUartRecvPackage, &mUartRecvBuf[j * 100], 100);
|
||
Count = Count - 100;
|
||
}
|
||
sprintf(&buf[0], "%02X", mUartRecvPackage[0]&0xFF);
|
||
sprintf(&buf[2], "%02X", mUartRecvPackage[1]&0xFF);
|
||
sprintf(&buf[4], "%02X", mUartRecvPackage[2]&0xFF);
|
||
|
||
//sprintf(&buf1[0], "%02X", mUartRecvPackage[3]&0xFF);
|
||
std::string strHeadFlag(buf);
|
||
//std::string strType(buf1);
|
||
|
||
print_info("data package head command type:%s\n", strHeadFlag.c_str());
|
||
|
||
if ( 0 == strHeadFlag.compare("ABBCCD") && (0xD1 == (mUartRecvPackage[3]&0xFF))) {
|
||
UpdateZigbeeInfo(mUartRecvPackage);
|
||
}
|
||
|
||
if ( 0 == strHeadFlag.compare("DEDFEF") ) {
|
||
update = true;
|
||
LOG_INFO("ReadHandle flag = %s\n",strHeadFlag.c_str());
|
||
}
|
||
|
||
if ( 0 == strHeadFlag.compare("AA55AA") ) {
|
||
DealRecvData(mUartRecvPackage);
|
||
}
|
||
}
|
||
|
||
}
|
||
//读串口循环
|
||
ReadFromUart();
|
||
} catch(...) {
|
||
print_error("PlatFormInit exception happend.\n");
|
||
// LOG_ERROR("%s,%d\n", __FUNCTION__, __LINE__);
|
||
}
|
||
}
|
||
|
||
void Uart::setCallBack(onReceiveUart _callback)
|
||
{
|
||
m_callback = _callback;
|
||
}
|
||
|
||
void Uart::DataAnalysis_R(DevDataOfGwid &pData)
|
||
{
|
||
mLocalTime = boost::posix_time::microsec_clock::local_time();
|
||
m_callback(pData);
|
||
mLocalTime = boost::posix_time::microsec_clock::local_time();
|
||
}
|
||
|
||
void Uart::WriteHandle(const char *strSend,const boost::system::error_code &ec,size_t bytesWrite)
|
||
{
|
||
if (ec) {
|
||
print_error("Fail To Write Uart! ]\n");
|
||
// LOG_ERROR("Fail To Write Uart! ]\n");
|
||
} else {
|
||
// print_info("[ To Uart ][ Bytes:%d ]\n",bytesWrite);
|
||
}
|
||
}
|
||
|
||
|
||
void Uart::ThreadInit()
|
||
{
|
||
// SignalInit();
|
||
}
|
||
|
||
void Uart::DataAnalysis_W(DevData &pData,bool pFlag)
|
||
{
|
||
this->WriteToUart(pData.mData,pData.mLen);
|
||
// LOG_INFO("WriteToUart:%s", pData.mDataMing);
|
||
boost::this_thread::sleep(boost::posix_time::milliseconds(110));
|
||
}
|
||
|
||
void Uart::UpdateZigbeeInfoCtrl()
|
||
{
|
||
char buf[5] = {0xAB, 0xBC, 0xCD, 0xD1, 0x05};
|
||
WriteToUart(buf, 5);
|
||
boost::this_thread::sleep(boost::posix_time::seconds(1));
|
||
}
|
||
|
||
void Uart::UpdateZigbeeInfo(const char *pData)
|
||
{
|
||
|
||
print_info("update gateway zigbee info\n");
|
||
GlobalConfig::Zigbee_G = *((ZIGBEE *)pData);
|
||
char buff[8];
|
||
sprintf(buff, "%02d", pData[36]&0xFF);
|
||
GlobalConfig::ZigbeeInfo_G.DevMode = boost::lexical_cast<int>(buff);
|
||
|
||
memset(buff, 0, 8);
|
||
sprintf(buff, "%02d", pData[37]&0xFF);
|
||
GlobalConfig::ZigbeeInfo_G.Channel = boost::lexical_cast<int>(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);
|
||
|
||
print_info("local zigbee module info Mode : %d Chan : %d PanID : %s MyAddr : %s DstAddr : %s\n", 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());
|
||
// LOG_INFO("[UpdateZigbeeInfo---] ZigBee PanID: %s ; Channel: %d ; MyAddr : %s ",GlobalConfig::ZigbeeInfo_G.PanID.c_str(),GlobalConfig::ZigbeeInfo_G.Channel,GlobalConfig::ZigbeeInfo_G.MyAddr.c_str());
|
||
|
||
}
|
||
void int2bytes(int i, unsigned char* bytes, int size) {
|
||
// byte[] bytes = new byte[4];
|
||
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::UpdateWirelessNode(unsigned char* id)
|
||
{
|
||
LOG_INFO("UpdateWirelessNode id = %02x %02x\n",id[0],id[1]);
|
||
|
||
//compare hardversion in update list
|
||
std::vector<std::string> strHWversion;
|
||
std::string strFileName = "";
|
||
strHWversion = ReadStrByOpt("/opt/update/DataNode/config.json",strFileName);
|
||
char gethardVersion_sql[32] = { 0 };
|
||
sprintf(gethardVersion_sql, "zigbeeShortAddr='%s'", id);
|
||
std::string hardVersion = sql_ctl->GetData(T_SENSOR_INFO(TNAME), T_SENSOR_INFO(HARDVERSION), gethardVersion_sql);
|
||
int thisindex = -1;
|
||
for(int i = 0; i < strHWversion.size();i++){
|
||
if(hardVersion == strHWversion[i]){
|
||
thisindex = i;
|
||
break;
|
||
}
|
||
}
|
||
if(thisindex < 0)
|
||
return;
|
||
|
||
FILE * pFile=NULL;
|
||
int thisSize = 0;
|
||
char *buffer=NULL;
|
||
strFileName = "/opt/update/DataNode/" + strFileName;
|
||
pFile = fopen (strFileName.c_str(),"rb");
|
||
if (pFile==NULL) perror ("Error opening file");
|
||
else
|
||
{
|
||
while (fgetc(pFile) != EOF) {
|
||
++thisSize;
|
||
}
|
||
rewind(pFile);
|
||
buffer = (char*)malloc(thisSize);//
|
||
fread (buffer, sizeof (char), thisSize, pFile);
|
||
fclose (pFile);
|
||
unsigned char Data[12]={0x00};
|
||
unsigned char size[4]={0x00};
|
||
|
||
//帧头[3byte] 节点地址[2byte] 数据类型[1byte] 序号[1byte] 升级包大小[4byte] CRC校验[1byte]
|
||
Data[0]=0xAA;
|
||
Data[1]=0x55;
|
||
Data[2]=0xAA;
|
||
Data[3]=id[0] & 0xFF;
|
||
Data[4]=id[1] & 0xFF;
|
||
Data[5]=0x07;
|
||
Data[6]=0x00;
|
||
int2bytes(thisSize,size,4);
|
||
Data[7]=size[3];
|
||
Data[8]=size[2];
|
||
Data[9]=size[1];
|
||
Data[10]=size[0];
|
||
unsigned char tmp = 0x00;
|
||
for(int i = 0 ; i < 11;i++){
|
||
tmp +=Data[i];
|
||
}
|
||
Data[11]=tmp;
|
||
WriteToUart((const char*)Data,12);
|
||
boost::this_thread::sleep(boost::posix_time::milliseconds(100));
|
||
int Count = thisSize / 92;
|
||
int lastSize = thisSize % 92;
|
||
unsigned char UpdateData[100]={0x00};
|
||
//帧头[3byte] 节点地址[2byte] 数据类型[1byte] 序号[1byte] 数据包[92byte] CRC校验[1byte]
|
||
print_info("Start Update!!! file Size = %d\n",thisSize);
|
||
for(int j = 0; j < Count;j++){
|
||
UpdateData[0]=0xAA;
|
||
UpdateData[1]=0x55;
|
||
UpdateData[2]=0xAA;
|
||
UpdateData[3]=id[0];
|
||
UpdateData[4]=id[1];
|
||
UpdateData[5]=0x08;
|
||
UpdateData[6]=0xff & j;
|
||
memcpy(&UpdateData[7],buffer+92*j,92);
|
||
tmp = 0x00;
|
||
for(int k = 0; k < 99;k++){
|
||
tmp +=UpdateData[k];
|
||
}
|
||
UpdateData[99] = tmp;
|
||
WriteToUart((const char*)UpdateData,100);
|
||
boost::this_thread::sleep(boost::posix_time::milliseconds(100));
|
||
memset(UpdateData,0x00,sizeof(UpdateData));
|
||
}
|
||
printf("Count =%d,lastSize = %d\n",Count,lastSize);
|
||
if(lastSize > 0){
|
||
UpdateData[0]=0xAA;
|
||
UpdateData[1]=0x55;
|
||
UpdateData[2]=0xAA;
|
||
UpdateData[3]=id[0];
|
||
UpdateData[4]=id[1];
|
||
UpdateData[5]=0x08;
|
||
UpdateData[6]=0xff & Count;
|
||
memcpy(&UpdateData[7],buffer+92*Count,lastSize);
|
||
tmp = 0x00;
|
||
for(int k = 0; k < 99;k++){
|
||
tmp +=UpdateData[k];
|
||
}
|
||
UpdateData[99] = tmp;
|
||
WriteToUart((const char*)UpdateData,100);
|
||
memset(UpdateData,0x00,sizeof(UpdateData));
|
||
}
|
||
print_info("Update END!!! file Size = %d\n",thisSize);
|
||
}
|
||
free(buffer);
|
||
ZigbeeInit();
|
||
update = false;
|
||
LOG_INFO("UpdateWirelessNode success");
|
||
}
|
||
void Uart::DealRecvData(const char *pData)
|
||
{
|
||
char buf[8];
|
||
sprintf(buf, "%02d", pData[5]&0xFF);
|
||
int flag = boost::lexical_cast<int>(buf);
|
||
print_info("the data package type(1,2,3,4,5,6) is %s,%x\n",buf,pData[5]&0xFF);
|
||
|
||
switch (flag)
|
||
{
|
||
case 1:{//0x01:设备信息
|
||
DealDataNodeInfo(pData);
|
||
}
|
||
break;
|
||
case 2:{//0x02:特征值
|
||
DealDataNodeFeature(pData, 0);
|
||
}
|
||
break;
|
||
case 3:{//0x03:长波形X轴
|
||
DealDataNodeWave(pData);
|
||
}
|
||
break;
|
||
case 4:{//0x04:长波形Y轴
|
||
DealDataNodeWave(pData);
|
||
}
|
||
break;
|
||
case 5:{//0x05:长波形Z轴
|
||
DealDataNodeWave(pData);
|
||
}
|
||
break;
|
||
case 6:{//0x06:特征值+长波形
|
||
DealDataNodeFeature(pData, 1);
|
||
}
|
||
break;
|
||
case 7:{//0x07:升级
|
||
|
||
//DealDataNodeFeature(pData, 1);
|
||
}
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
|
||
|
||
void Uart::DealDataNodeInfo(const char *pData)
|
||
{
|
||
print_info("recv remote zigbee module info\n");
|
||
RecvData * pRecvData = (RecvData *)pData;
|
||
char buf[32] = {0};
|
||
char chTemp = pRecvData->Data[0];
|
||
DataNodeInfo dataNodeInfo;
|
||
dataNodeInfo.EquipSta = boost::lexical_cast<int>(chTemp >> 2 & 0x1);
|
||
dataNodeInfo.TemTopFlag = boost::lexical_cast<int>(chTemp >> 3 & 0x1);
|
||
dataNodeInfo.TemBotFlag = boost::lexical_cast<int>(chTemp >> 4 & 0x1);
|
||
dataNodeInfo.ZigbeeFlag = boost::lexical_cast<int>(chTemp >> 5 & 0x1);
|
||
dataNodeInfo.AccFlag = boost::lexical_cast<int>(chTemp >> 6 & 0x1);
|
||
dataNodeInfo.InitFlag = boost::lexical_cast<int>(chTemp >> 7 & 0x1);
|
||
|
||
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);
|
||
|
||
chTemp = pRecvData->Data[9];
|
||
memset(buf, 0, 32);
|
||
sprintf(buf, "%02x", chTemp);
|
||
dataNodeInfo.HardVersion = std::string(buf);
|
||
|
||
chTemp = pRecvData->Data[10];
|
||
memset(buf, 0, 32);
|
||
//sprintf(buf, "%02x", chTemp);
|
||
sprintf(buf, "%.1f", 0.1*chTemp);
|
||
dataNodeInfo.SoftVersion = std::string(buf);
|
||
|
||
memset(buf, 0, 32);
|
||
sprintf(buf, "%02x%02x%02x%02x", pRecvData->Data[11], pRecvData->Data[12], pRecvData->Data[13], pRecvData->Data[14]);
|
||
dataNodeInfo.BpNo = std::string(buf);
|
||
|
||
memset(buf, 0, 32);
|
||
sprintf(buf, "%02x%02x%02x%02x", pRecvData->Data[15], pRecvData->Data[16], pRecvData->Data[17], pRecvData->Data[18]);
|
||
dataNodeInfo.SerialNo = std::string(buf);
|
||
|
||
memset(buf, 0, 32);
|
||
sprintf(buf, "%02x%02x%02x%02x", pRecvData->Data[19], pRecvData->Data[20], pRecvData->Data[21], pRecvData->Data[22]);
|
||
dataNodeInfo.FirstPowerTime = std::string(buf);
|
||
|
||
//23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38=>序号13 无线信号强度
|
||
// 获取 RSSI
|
||
chTemp = pRecvData->Data[38];
|
||
memset(buf, 0, 32);
|
||
sprintf(buf, "%d", chTemp);
|
||
dataNodeInfo.RSSI = boost::lexical_cast<int>(buf);
|
||
|
||
chTemp = pRecvData->Data[39];
|
||
memset(buf, 0, 32);
|
||
sprintf(buf, "%02x", chTemp);
|
||
dataNodeInfo.ConfigFlag = ((0 == std::string(buf).compare("aa")) ? 1 : 0);
|
||
|
||
memset(buf, 0, 32);
|
||
sprintf(buf, "%u%u", pRecvData->Data[40], pRecvData->Data[41]);
|
||
dataNodeInfo.FeatureInterVal = boost::lexical_cast<unsigned int>(buf);
|
||
|
||
chTemp = pRecvData->Data[42];
|
||
memset(buf, 0, 32);
|
||
// sprintf(buf, "%02x", chTemp);
|
||
sprintf(buf, "%d",(unsigned int)chTemp); // yxq
|
||
dataNodeInfo.WaveInterVal = boost::lexical_cast<unsigned int>(buf);
|
||
|
||
memset(buf, 0, 32);
|
||
sprintf(buf, "%02x%02x", pRecvData->Data[43], pRecvData->Data[44]);
|
||
dataNodeInfo.ZigbeePanId = std::string(buf);
|
||
|
||
chTemp = pRecvData->Data[45];
|
||
memset(buf, 0, 32);
|
||
sprintf(buf, "%d", chTemp);
|
||
dataNodeInfo.ZigbeeChannel = boost::lexical_cast<int>(buf);
|
||
|
||
memset(buf, 0, 32);
|
||
sprintf(buf, "%02x%02x", pRecvData->Data[46], pRecvData->Data[47]);
|
||
dataNodeInfo.ZigbeeShortAddr = std::string(buf);
|
||
|
||
memset(buf, 0, 32);
|
||
sprintf(buf, "%02x%02x", pRecvData->Data[48], pRecvData->Data[49]);
|
||
dataNodeInfo.ZigbeeDesAddr = std::string(buf);
|
||
//50 51 52=》序号23 zigbee重试间隔
|
||
|
||
chTemp = pRecvData->Data[53];
|
||
dataNodeInfo.Range = boost::lexical_cast<int>(chTemp >> 2 & 0x3);
|
||
dataNodeInfo.SamplingRate = boost::lexical_cast<int>(chTemp & 0x3);
|
||
// 54=》序号25 ACC采样时间
|
||
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 = boost::lexical_cast<std::string>(iTemp);
|
||
} else {
|
||
dataNodeInfo.StartBrands += ("," + boost::lexical_cast<std::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 = boost::lexical_cast<std::string>(iTemp);
|
||
} else {
|
||
dataNodeInfo.StopBrands += ("," + boost::lexical_cast<std::string>(iTemp));
|
||
}
|
||
}
|
||
|
||
|
||
memset(buf, 0, 32);
|
||
sprintf(buf, "%02x%02x", pRecvData->Data[75], pRecvData->Data[76]);
|
||
iTemp = (int)strtol(buf, NULL, 16);
|
||
dataNodeInfo.EnvelopeBandPass = boost::lexical_cast<std::string>(iTemp);
|
||
|
||
|
||
memset(buf, 0, 32);
|
||
sprintf(buf, "%02x%02x", pRecvData->Data[77], pRecvData->Data[78]);
|
||
iTemp = (int)strtol(buf, NULL, 16);
|
||
dataNodeInfo.EnvelopeBandPass += ("," + boost::lexical_cast<std::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 = boost::lexical_cast<std::string>(iTemp);
|
||
} else {
|
||
dataNodeInfo.FaultFrequency += ("," + boost::lexical_cast<std::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 = boost::lexical_cast<std::string>(lTimeStamp);
|
||
|
||
chTemp = pRecvData->Data[91];
|
||
memset(buf, 0, 32);
|
||
sprintf(buf, "%d", chTemp);
|
||
dataNodeInfo.VIntegralFilterFrequency = boost::lexical_cast<int>(buf);
|
||
|
||
char whereCon[64] = {0};
|
||
sprintf(whereCon, "dataNodeNo='%s'", dataNodeInfo.ZigbeeLongAddr.c_str());
|
||
if (sql_ctl->GetTableRows(T_SENSOR_INFO(TNAME), whereCon) > 0) {
|
||
sql_ctl->DeleteTableData(T_SENSOR_INFO(TNAME), whereCon);
|
||
}
|
||
|
||
char insertSql[1024] = { 0 };
|
||
sprintf(insertSql, "'%s','%s','%d','%d','%d','%d','%d','%d','%s','%s','%s','%s','%s','%d','%s','%s','%u','%d','%d','%s','%d','%s','%s','%s','%d','%s','%s','%s','%s','%s','%d','%d'",
|
||
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.ConfigFlag, dataNodeInfo.StartBrands.c_str(), \
|
||
dataNodeInfo.StopBrands.c_str(), dataNodeInfo.FeatureInterVal, dataNodeInfo.WaveInterVal, dataNodeInfo.SamplingRate, "range", 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(), "1", dataNodeInfo.ConfigDate.c_str(),dataNodeInfo.VIntegralFilterFrequency,dataNodeInfo.RSSI);
|
||
sql_ctl->InsertData(T_SENSOR_INFO(TNAME), insertSql);
|
||
|
||
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 strCmd27 = showValue.write(jsonVal);
|
||
//传感器发来的数据包中的表示设备信息的数据转化为json格式后，通过调用data_publish将数据传给mqttclient ： Topic：wireless/cmd/60294D203717
|
||
data_publish(strCmd27.c_str(), GlobalConfig::Topic_G.mPubCmd.c_str());
|
||
|
||
print_info("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 \n", \
|
||
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);
|
||
|
||
}
|
||
|
||
|
||
void Uart::DealDataNodeFeature(const char *pData, int flag)
|
||
{
|
||
print_info("recv feature\n");
|
||
RecvData * pRecvData = (RecvData *)pData;
|
||
|
||
char buf[8];
|
||
sprintf(buf, "%02x%02x", pRecvData->ShortAddr[0], pRecvData->ShortAddr[1]);
|
||
LOG_INFO("DealDataNodeFeature %02x%02x\n",pRecvData->ShortAddr[0], pRecvData->ShortAddr[1]);
|
||
|
||
std::string strShortAddr = std::string(buf);
|
||
print_info("zigbeeShortAddr='%s'", strShortAddr.c_str());
|
||
if (1 == flag) {
|
||
print_info("recv wave minute\n");
|
||
unsigned short shortAddr = 0x9999;
|
||
|
||
WriteShortAddr_DistAddr2Zigbee(shortAddr,pRecvData->ShortAddr);
|
||
// LOG_INFO("[DealDataNodeFeature] ZigBee PanID: %s ; Channel: %d ; MyAddr : %4x ",GlobalConfig::ZigbeeInfo_G.PanID.c_str(),GlobalConfig::ZigbeeInfo_G.Channel,
|
||
// (unsigned short)GlobalConfig::Zigbee_G.MyAddr);
|
||
UpdateWirelessNode(pRecvData->ShortAddr);
|
||
// 进入传输原始数据状态，启动计数 60秒
|
||
GlobalConfig::EnterZigBeeWaveTransmittingFlag_G = ENTER_TRANSMITTING_STATUS;
|
||
GlobalConfig::EnterZigBeeWaveTransmittingCnt_G = 0;
|
||
}
|
||
|
||
|
||
char getLongAddr_sql[32] = { 0 };
|
||
//根据数据包中的传感器的短地址获取数据库中长地址（MAC），在下面判断该传感器是否存在，如果不存在则把数据包丢弃
|
||
sprintf(getLongAddr_sql, "zigbeeShortAddr='%s'", strShortAddr.c_str());
|
||
std::string strLongAddr = sql_ctl->GetData(T_SENSOR_INFO(TNAME), T_SENSOR_INFO(ZIGBEELONGADDR), getLongAddr_sql);
|
||
print_info("--------->the remote sensor short addr:%s strLongAddr=%s\n",buf,strLongAddr.c_str());
|
||
|
||
if (0 == strLongAddr.length()) {
|
||
print_error("device info not found\n");
|
||
return;
|
||
}
|
||
|
||
char localtimestamp[32] = { 0 };
|
||
GetTimeNet(localtimestamp, 1);
|
||
std::string nowTimetamp = std::string(localtimestamp);
|
||
|
||
int iTemp = 0;
|
||
unsigned char highbit = 0;
|
||
unsigned int lowbit = 0;
|
||
float n = 0;
|
||
|
||
DataRecvStatic dataStatic;
|
||
memset(buf, 0, 8);
|
||
sprintf(buf, "%02x%02x", pRecvData->Data[5], pRecvData->Data[4]);
|
||
print_blue("!!!!!!!!!!!!!!!!!!!!!!%s\n",buf);
|
||
iTemp = (int)strtol(buf, NULL, 16);
|
||
dataStatic.Dip = iTemp;
|
||
|
||
memset(buf, 0, 8);
|
||
sprintf(buf, "%02x%02x", pRecvData->Data[1], pRecvData->Data[0]);
|
||
print_blue("@@@@@@@@@@@@@@@@@%s\n",buf);
|
||
iTemp = (int)strtol(buf, NULL, 16);
|
||
dataStatic.TemBot = iTemp * 0.0625;
|
||
|
||
memset(buf, 0, 8);
|
||
sprintf(buf, "%02x%02x", pRecvData->Data[3], pRecvData->Data[2]);
|
||
iTemp = (int)strtol(buf, NULL, 16);
|
||
dataStatic.TemTop = iTemp * 0.0625;
|
||
|
||
memset(buf, 0, 8);
|
||
sprintf(buf, "%02x%02x", pRecvData->Data[7], pRecvData->Data[6]);
|
||
iTemp = (int)strtol(buf, NULL, 16);
|
||
dataStatic.Voltage = iTemp;
|
||
|
||
|
||
print_info("dataStatic.TemTop : %f dataStatic.TemBot : %f dataStatic.Dip :%d dataStatic.Voltage : %d\n", dataStatic.TemTop\
|
||
, dataStatic.TemBot, dataStatic.Dip, dataStatic.Voltage);
|
||
char whereCon[64] = {0};
|
||
sprintf(whereCon, "channelID='%s'", (strLongAddr + "-S").c_str());
|
||
if ( 0 == sql_ctl->GetTableRows(T_DATASTATIC_INFO(TNAME), whereCon) ) {
|
||
print_info("insert static data to sql\n");
|
||
char insertSql[1024] = { 0 };
|
||
sprintf(insertSql, "'%s','%s','%f','%f','%d','%d','%s'",
|
||
strLongAddr.c_str(), (strLongAddr + "-S").c_str(), dataStatic.TemTop, dataStatic.TemBot, dataStatic.Dip, dataStatic.Voltage, nowTimetamp.c_str());
|
||
sql_ctl->InsertData(T_DATASTATIC_INFO(TNAME), insertSql);
|
||
} else {
|
||
print_info("update static data to sql\n");
|
||
char updateSql[1024] = { 0 };
|
||
sprintf(updateSql, "temTop='%f',temBot='%f',dip='%d',voltage='%d',timeStamp='%s'",\
|
||
dataStatic.TemTop, dataStatic.TemBot, dataStatic.Dip, dataStatic.Voltage, nowTimetamp.c_str());
|
||
sql_ctl->UpdateTableData(T_DATASTATIC_INFO(TNAME), updateSql, whereCon);
|
||
}
|
||
|
||
DataRecvDym dataDymX;
|
||
memset(buf, 0, 8);
|
||
sprintf(buf, "%02x%02x", pRecvData->Data[9], pRecvData->Data[8]);
|
||
iTemp = (unsigned int)strtol(buf, NULL, 16);
|
||
highbit = iTemp >> 14 & 0x3;
|
||
lowbit = iTemp & 0x3fff;
|
||
switch (highbit)
|
||
{
|
||
case 0:
|
||
n = 0.0001;
|
||
break;
|
||
case 1:
|
||
n = 0.01;
|
||
break;
|
||
case 2:
|
||
n = 1;
|
||
break;
|
||
case 3:
|
||
n = 100;
|
||
break;
|
||
}
|
||
dataDymX.DiagnosisPk = lowbit * n;
|
||
|
||
memset(buf, 0, 8);
|
||
sprintf(buf, "%02x%02x", pRecvData->Data[11], pRecvData->Data[10]);
|
||
iTemp = (unsigned int)strtol(buf, NULL, 16);
|
||
highbit = iTemp >> 14 & 0x3;
|
||
lowbit = iTemp & 0x3fff;
|
||
switch (highbit)
|
||
{
|
||
case 0:
|
||
n = 0.0001;
|
||
break;
|
||
case 1:
|
||
n = 0.01;
|
||
break;
|
||
case 2:
|
||
n = 1;
|
||
break;
|
||
case 3:
|
||
n = 100;
|
||
break;
|
||
}
|
||
dataDymX.RmsValues = lowbit * n;
|
||
|
||
memset(buf, 0, 8);
|
||
sprintf(buf, "%02x%02x", pRecvData->Data[13], pRecvData->Data[12]);
|
||
iTemp = (unsigned int)strtol(buf, NULL, 16);
|
||
highbit = iTemp >> 14 & 0x3;
|
||
lowbit = iTemp & 0x3fff;
|
||
switch (highbit)
|
||
{
|
||
case 0:
|
||
n = 0.0001;
|
||
break;
|
||
case 1:
|
||
n = 0.01;
|
||
break;
|
||
case 2:
|
||
n = 1;
|
||
break;
|
||
case 3:
|
||
n = 100;
|
||
break;
|
||
}
|
||
dataDymX.IntegratPk = lowbit * n;
|
||
|
||
memset(buf, 0, 8);
|
||
sprintf(buf, "%02x%02x", pRecvData->Data[15], pRecvData->Data[14]);
|
||
iTemp = (unsigned int)strtol(buf, NULL, 16);
|
||
highbit = iTemp >> 14 & 0x3;
|
||
lowbit = iTemp & 0x3fff;
|
||
switch (highbit)
|
||
{
|
||
case 0:
|
||
n = 0.0001;
|
||
break;
|
||
case 1:
|
||
n = 0.01;
|
||
break;
|
||
case 2:
|
||
n = 1;
|
||
break;
|
||
case 3:
|
||
n = 100;
|
||
break;
|
||
}
|
||
dataDymX.IntegratRMS = lowbit * n;
|
||
|
||
memset(buf, 0, 8);
|
||
sprintf(buf, "%02x%02x", pRecvData->Data[17], pRecvData->Data[16]);
|
||
iTemp = (unsigned int)strtol(buf, NULL, 16);
|
||
highbit = iTemp >> 14 & 0x3;
|
||
lowbit = iTemp & 0x3fff;
|
||
switch (highbit)
|
||
{
|
||
case 0:
|
||
n = 0.0001;
|
||
break;
|
||
case 1:
|
||
n = 0.01;
|
||
break;
|
||
case 2:
|
||
n = 1;
|
||
break;
|
||
case 3:
|
||
n = 100;
|
||
break;
|
||
}
|
||
dataDymX.Amp1 = lowbit * n;
|
||
|
||
memset(buf, 0, 8);
|
||
sprintf(buf, "%02x%02x", pRecvData->Data[19], pRecvData->Data[18]);
|
||
iTemp = (unsigned int)strtol(buf, NULL, 16);
|
||
highbit = iTemp >> 14 & 0x3;
|
||
lowbit = iTemp & 0x3fff;
|
||
switch (highbit)
|
||
{
|
||
case 0:
|
||
n = 0.0001;
|
||
break;
|
||
case 1:
|
||
n = 0.01;
|
||
break;
|
||
case 2:
|
||
n = 1;
|
||
break;
|
||
case 3:
|
||
n = 100;
|
||
break;
|
||
}
|
||
dataDymX.Amp2 = lowbit * n;
|
||
|
||
memset(buf, 0, 8);
|
||
sprintf(buf, "%02x%02x", pRecvData->Data[21], pRecvData->Data[20]);
|
||
iTemp = (unsigned int)strtol(buf, NULL, 16);
|
||
highbit = iTemp >> 14 & 0x3;
|
||
lowbit = iTemp & 0x3fff;
|
||
switch (highbit)
|
||
{
|
||
case 0:
|
||
n = 0.0001;
|
||
break;
|
||
case 1:
|
||
n = 0.01;
|
||
break;
|
||
case 2:
|
||
n = 1;
|
||
break;
|
||
case 3:
|
||
n = 100;
|
||
break;
|
||
}
|
||
dataDymX.Amp3 = lowbit * n;
|
||
|
||
memset(buf, 0, 8);
|
||
sprintf(buf, "%02x%02x", pRecvData->Data[23], pRecvData->Data[22]);
|
||
iTemp = (unsigned int)strtol(buf, NULL, 16);
|
||
highbit = iTemp >> 14 & 0x3;
|
||
lowbit = iTemp & 0x3fff;
|
||
switch (highbit)
|
||
{
|
||
case 0:
|
||
n = 0.0001;
|
||
break;
|
||
case 1:
|
||
n = 0.01;
|
||
break;
|
||
case 2:
|
||
n = 1;
|
||
break;
|
||
case 3:
|
||
n = 100;
|
||
break;
|
||
}
|
||
dataDymX.Amp4 = lowbit * n;
|
||
|
||
memset(buf, 0, 8);
|
||
sprintf(buf, "%02x%02x", pRecvData->Data[25], pRecvData->Data[24]);
|
||
iTemp = (unsigned int)strtol(buf, NULL, 16);
|
||
highbit = iTemp >> 14 & 0x3;
|
||
lowbit = iTemp & 0x3fff;
|
||
switch (highbit)
|
||
{
|
||
case 0:
|
||
n = 0.0001;
|
||
break;
|
||
case 1:
|
||
n = 0.01;
|
||
break;
|
||
case 2:
|
||
n = 1;
|
||
break;
|
||
case 3:
|
||
n = 100;
|
||
break;
|
||
}
|
||
dataDymX.Amp5 = lowbit * n;
|
||
|
||
memset(buf, 0, 8);
|
||
sprintf(buf, "%02x%02x", pRecvData->Data[27], pRecvData->Data[26]);
|
||
iTemp = (unsigned int)strtol(buf, NULL, 16);
|
||
highbit = iTemp >> 14 & 0x3;
|
||
lowbit = iTemp & 0x3fff;
|
||
switch (highbit)
|
||
{
|
||
case 0:
|
||
n = 0.0001;
|
||
break;
|
||
case 1:
|
||
n = 0.01;
|
||
break;
|
||
case 2:
|
||
n = 1;
|
||
break;
|
||
case 3:
|
||
n = 100;
|
||
break;
|
||
}
|
||
dataDymX.EnvelopEnergy = lowbit * n;
|
||
|
||
memset(buf, 0, 8);
|
||
sprintf(buf, "%02x%02x", pRecvData->Data[29], pRecvData->Data[28]);
|
||
iTemp = (unsigned int)strtol(buf, NULL, 16);
|
||
highbit = iTemp >> 14 & 0x3;
|
||
lowbit = iTemp & 0x3fff;
|
||
switch (highbit)
|
||
{
|
||
case 0:
|
||
n = 0.0001;
|
||
break;
|
||
case 1:
|
||
n = 0.01;
|
||
break;
|
||
case 2:
|
||
n = 1;
|
||
break;
|
||
case 3:
|
||
n = 100;
|
||
break;
|
||
}
|
||
dataDymX.Phase1 = lowbit * n;
|
||
|
||
memset(buf, 0, 8);
|
||
sprintf(buf, "%02x%02x", pRecvData->Data[31], pRecvData->Data[30]);
|
||
iTemp = (unsigned int)strtol(buf, NULL, 16);
|
||
highbit = iTemp >> 14 & 0x3;
|
||
lowbit = iTemp & 0x3fff;
|
||
switch (highbit)
|
||
{
|
||
case 0:
|
||
n = 0.0001;
|
||
break;
|
||
case 1:
|
||
n = 0.01;
|
||
break;
|
||
case 2:
|
||
n = 1;
|
||
break;
|
||
case 3:
|
||
n = 100;
|
||
break;
|
||
}
|
||
dataDymX.Phase2 = lowbit * n;
|
||
|
||
memset(buf, 0, 8);
|
||
sprintf(buf, "%02x%02x", pRecvData->Data[33], pRecvData->Data[32]);
|
||
iTemp = (unsigned int)strtol(buf, NULL, 16);
|
||
highbit = iTemp >> 14 & 0x3;
|
||
lowbit = iTemp & 0x3fff;
|
||
switch (highbit)
|
||
{
|
||
case 0:
|
||
n = 0.0001;
|
||
break;
|
||
case 1:
|
||
n = 0.01;
|
||
break;
|
||
case 2:
|
||
n = 1;
|
||
break;
|
||
case 3:
|
||
n = 100;
|
||
break;
|
||
}
|
||
dataDymX.Phase3 = lowbit * n;
|
||
|
||
memset(buf, 0, 8);
|
||
sprintf(buf, "%02x%02x", pRecvData->Data[35], pRecvData->Data[34]);
|
||
iTemp = (unsigned int)strtol(buf, NULL, 16);
|
||
highbit = iTemp >> 14 & 0x3;
|
||
lowbit = iTemp & 0x3fff;
|
||
switch (highbit)
|
||
{
|
||
case 0:
|
||
n = 0.0001;
|
||
break;
|
||
case 1:
|
||
n = 0.01;
|
||
break;
|
||
case 2:
|
||
n = 1;
|
||
break;
|
||
case 3:
|
||
n = 100;
|
||
break;
|
||
}
|
||
dataDymX.Phase4 = lowbit * n;
|
||
|
||
memset(whereCon, 0, 64);
|
||
sprintf(whereCon, "channelID='%s'", (strLongAddr + "-X").c_str());
|
||
if ( 0 == sql_ctl->GetTableRows(T_DATA_INFO(TNAME), whereCon) ) {
|
||
char insertSql[1024] = { 0 };
|
||
sprintf(insertSql, "'%s','%s','%f','%f','%f','%f','%f','%f','%f','%f','%f','%f','%f','%f','%f','%f','%s'",
|
||
strLongAddr.c_str(), (strLongAddr + "-X").c_str(), dataDymX.DiagnosisPk, dataDymX.IntegratPk, dataDymX.IntegratRMS, dataDymX.RmsValues, dataDymX.EnvelopEnergy,\
|
||
dataDymX.Amp1, dataDymX.Amp2, dataDymX.Amp3, dataDymX.Amp4, dataDymX.Amp5,dataDymX.Phase1, dataDymX.Phase2, dataDymX.Phase3, dataDymX.Phase4, nowTimetamp.c_str());
|
||
sql_ctl->InsertData(T_DATA_INFO(TNAME), insertSql);
|
||
} else {
|
||
char updateSql[1024] = { 0 };
|
||
sprintf(updateSql, "diagnosisPk='%f',integratPk='%f',integratRMS='%f',rmsValues='%f',envelopEnergy='%f',\
|
||
Amp1='%f',Amp2='%f',Amp3='%f',Amp4='%f',Amp5='%f',Phase1='%f',Phase2='%f',Phase3='%f',Phase4='%f',timeStamp='%s'",\
|
||
dataDymX.DiagnosisPk, dataDymX.IntegratPk, dataDymX.IntegratRMS, dataDymX.RmsValues, dataDymX.EnvelopEnergy,\
|
||
dataDymX.Amp1, dataDymX.Amp2, dataDymX.Amp3, dataDymX.Amp4, dataDymX.Amp5,dataDymX.Phase1, dataDymX.Phase2, dataDymX.Phase3, dataDymX.Phase4, nowTimetamp.c_str());
|
||
sql_ctl->UpdateTableData(T_DATA_INFO(TNAME), updateSql, whereCon);
|
||
}
|
||
print_info("x:%s,%s,diagnosisPk=%f,integratPk=%f,integratRMS=%f,rmsValues=%f,envelopEnergy=%f,Amp1=%f,Amp2=%f,Amp3=%f,Amp4=%f,Amp5=%f,Phase1=%f,Phase2=%f,Phase3=%f,Phase4=%f,timeStamp=%s\n",\
|
||
strLongAddr.c_str(), (strLongAddr + "-X").c_str(), dataDymX.DiagnosisPk, dataDymX.IntegratPk, dataDymX.IntegratRMS, dataDymX.RmsValues, dataDymX.EnvelopEnergy,\
|
||
dataDymX.Amp1, dataDymX.Amp2, dataDymX.Amp3, dataDymX.Amp4, dataDymX.Amp5,dataDymX.Phase1, dataDymX.Phase2, dataDymX.Phase3, dataDymX.Phase4, nowTimetamp.c_str());
|
||
|
||
Json::Value valNodeData;
|
||
Json::Value valNodeFeature;
|
||
valNodeFeature["dataNodeNo"] = strLongAddr;
|
||
valNodeFeature["channelID"] = strLongAddr + "-X";
|
||
valNodeFeature["diagnosisPk"] = dataDymX.DiagnosisPk;
|
||
valNodeFeature["integratPk"] = dataDymX.IntegratPk;
|
||
valNodeFeature["integratRMS"] = dataDymX.IntegratRMS;
|
||
valNodeFeature["rmsValues"] = dataDymX.RmsValues;
|
||
valNodeFeature["envelopEnergy"] = dataDymX.EnvelopEnergy;
|
||
valNodeFeature["Amp1"] = dataDymX.Amp1;
|
||
valNodeFeature["Amp2"] = dataDymX.Amp2;
|
||
valNodeFeature["Amp3"] = dataDymX.Amp3;
|
||
valNodeFeature["Amp4"] = dataDymX.Amp4;
|
||
valNodeFeature["Amp5"] = dataDymX.Amp5;
|
||
valNodeFeature["Phase1"] = dataDymX.Phase1;
|
||
valNodeFeature["Phase2"] = dataDymX.Phase2;
|
||
valNodeFeature["Phase3"] = dataDymX.Phase3;
|
||
valNodeFeature["Phase4"] = dataDymX.Phase4;
|
||
valNodeFeature["timeStamp"] = nowTimetamp;
|
||
valNodeData.append(valNodeFeature);
|
||
DataRecvDym dataDymY;
|
||
memset(buf, 0, 8);
|
||
sprintf(buf, "%02x%02x", pRecvData->Data[37], pRecvData->Data[36]);
|
||
iTemp = (unsigned int)strtol(buf, NULL, 16);
|
||
highbit = iTemp >> 14 & 0x3;
|
||
lowbit = iTemp & 0x3fff;
|
||
switch (highbit)
|
||
{
|
||
case 0:
|
||
n = 0.0001;
|
||
break;
|
||
case 1:
|
||
n = 0.01;
|
||
break;
|
||
case 2:
|
||
n = 1;
|
||
break;
|
||
case 3:
|
||
n = 100;
|
||
break;
|
||
}
|
||
dataDymY.DiagnosisPk = lowbit * n;
|
||
|
||
memset(buf, 0, 8);
|
||
sprintf(buf, "%02x%02x", pRecvData->Data[39], pRecvData->Data[38]);
|
||
iTemp = (unsigned int)strtol(buf, NULL, 16);
|
||
highbit = iTemp >> 14 & 0x3;
|
||
lowbit = iTemp & 0x3fff;
|
||
switch (highbit)
|
||
{
|
||
case 0:
|
||
n = 0.0001;
|
||
break;
|
||
case 1:
|
||
n = 0.01;
|
||
break;
|
||
case 2:
|
||
n = 1;
|
||
break;
|
||
case 3:
|
||
n = 100;
|
||
break;
|
||
}
|
||
dataDymY.RmsValues = lowbit * n;
|
||
|
||
memset(buf, 0, 8);
|
||
sprintf(buf, "%02x%02x", pRecvData->Data[41], pRecvData->Data[40]);
|
||
iTemp = (unsigned int)strtol(buf, NULL, 16);
|
||
highbit = iTemp >> 14 & 0x3;
|
||
lowbit = iTemp & 0x3fff;
|
||
switch (highbit)
|
||
{
|
||
case 0:
|
||
n = 0.0001;
|
||
break;
|
||
case 1:
|
||
n = 0.01;
|
||
break;
|
||
case 2:
|
||
n = 1;
|
||
break;
|
||
case 3:
|
||
n = 100;
|
||
break;
|
||
}
|
||
dataDymY.IntegratPk = lowbit * n;
|
||
|
||
memset(buf, 0, 8);
|
||
sprintf(buf, "%02x%02x", pRecvData->Data[43], pRecvData->Data[42]);
|
||
iTemp = (unsigned int)strtol(buf, NULL, 16);
|
||
highbit = iTemp >> 14 & 0x3;
|
||
lowbit = iTemp & 0x3fff;
|
||
switch (highbit)
|
||
{
|
||
case 0:
|
||
n = 0.0001;
|
||
break;
|
||
case 1:
|
||
n = 0.01;
|
||
break;
|
||
case 2:
|
||
n = 1;
|
||
break;
|
||
case 3:
|
||
n = 100;
|
||
break;
|
||
}
|
||
dataDymY.IntegratRMS = lowbit * n;
|
||
|
||
memset(buf, 0, 8);
|
||
sprintf(buf, "%02x%02x", pRecvData->Data[45], pRecvData->Data[44]);
|
||
iTemp = (unsigned int)strtol(buf, NULL, 16);
|
||
highbit = iTemp >> 14 & 0x3;
|
||
lowbit = iTemp & 0x3fff;
|
||
switch (highbit)
|
||
{
|
||
case 0:
|
||
n = 0.0001;
|
||
break;
|
||
case 1:
|
||
n = 0.01;
|
||
break;
|
||
case 2:
|
||
n = 1;
|
||
break;
|
||
case 3:
|
||
n = 100;
|
||
break;
|
||
}
|
||
dataDymY.Amp1 = lowbit * n;
|
||
|
||
memset(buf, 0, 8);
|
||
sprintf(buf, "%02x%02x", pRecvData->Data[47], pRecvData->Data[46]);
|
||
iTemp = (unsigned int)strtol(buf, NULL, 16);
|
||
highbit = iTemp >> 14 & 0x3;
|
||
lowbit = iTemp & 0x3fff;
|
||
switch (highbit)
|
||
{
|
||
case 0:
|
||
n = 0.0001;
|
||
break;
|
||
case 1:
|
||
n = 0.01;
|
||
break;
|
||
case 2:
|
||
n = 1;
|
||
break;
|
||
case 3:
|
||
n = 100;
|
||
break;
|
||
}
|
||
dataDymY.Amp2 = lowbit * n;
|
||
|
||
memset(buf, 0, 8);
|
||
sprintf(buf, "%02x%02x", pRecvData->Data[49], pRecvData->Data[48]);
|
||
iTemp = (unsigned int)strtol(buf, NULL, 16);
|
||
highbit = iTemp >> 14 & 0x3;
|
||
lowbit = iTemp & 0x3fff;
|
||
switch (highbit)
|
||
{
|
||
case 0:
|
||
n = 0.0001;
|
||
break;
|
||
case 1:
|
||
n = 0.01;
|
||
break;
|
||
case 2:
|
||
n = 1;
|
||
break;
|
||
case 3:
|
||
n = 100;
|
||
break;
|
||
}
|
||
dataDymY.Amp3 = lowbit * n;
|
||
|
||
memset(buf, 0, 8);
|
||
sprintf(buf, "%02x%02x", pRecvData->Data[51], pRecvData->Data[50]);
|
||
iTemp = (unsigned int)strtol(buf, NULL, 16);
|
||
highbit = iTemp >> 14 & 0x3;
|
||
lowbit = iTemp & 0x3fff;
|
||
switch (highbit)
|
||
{
|
||
case 0:
|
||
n = 0.0001;
|
||
break;
|
||
case 1:
|
||
n = 0.01;
|
||
break;
|
||
case 2:
|
||
n = 1;
|
||
break;
|
||
case 3:
|
||
n = 100;
|
||
break;
|
||
}
|
||
dataDymY.Amp4 = lowbit * n;
|
||
|
||
memset(buf, 0, 8);
|
||
sprintf(buf, "%02x%02x", pRecvData->Data[53], pRecvData->Data[52]);
|
||
iTemp = (unsigned int)strtol(buf, NULL, 16);
|
||
highbit = iTemp >> 14 & 0x3;
|
||
lowbit = iTemp & 0x3fff;
|
||
switch (highbit)
|
||
{
|
||
case 0:
|
||
n = 0.0001;
|
||
break;
|
||
case 1:
|
||
n = 0.01;
|
||
break;
|
||
case 2:
|
||
n = 1;
|
||
break;
|
||
case 3:
|
||
n = 100;
|
||
break;
|
||
}
|
||
dataDymY.Amp5 = lowbit * n;
|
||
|
||
memset(buf, 0, 8);
|
||
sprintf(buf, "%02x%02x", pRecvData->Data[55], pRecvData->Data[54]);
|
||
iTemp = (unsigned int)strtol(buf, NULL, 16);
|
||
highbit = iTemp >> 14 & 0x3;
|
||
lowbit = iTemp & 0x3fff;
|
||
switch (highbit)
|
||
{
|
||
case 0:
|
||
n = 0.0001;
|
||
break;
|
||
case 1:
|
||
n = 0.01;
|
||
break;
|
||
case 2:
|
||
n = 1;
|
||
break;
|
||
case 3:
|
||
n = 100;
|
||
break;
|
||
}
|
||
dataDymY.EnvelopEnergy = lowbit * n;
|
||
|
||
memset(buf, 0, 8);
|
||
sprintf(buf, "%02x%02x", pRecvData->Data[57], pRecvData->Data[56]);
|
||
iTemp = (unsigned int)strtol(buf, NULL, 16);
|
||
highbit = iTemp >> 14 & 0x3;
|
||
lowbit = iTemp & 0x3fff;
|
||
switch (highbit)
|
||
{
|
||
case 0:
|
||
n = 0.0001;
|
||
break;
|
||
case 1:
|
||
n = 0.01;
|
||
break;
|
||
case 2:
|
||
n = 1;
|
||
break;
|
||
case 3:
|
||
n = 100;
|
||
break;
|
||
}
|
||
dataDymY.Phase1 = lowbit * n;
|
||
|
||
memset(buf, 0, 8);
|
||
sprintf(buf, "%02x%02x", pRecvData->Data[59], pRecvData->Data[58]);
|
||
iTemp = (unsigned int)strtol(buf, NULL, 16);
|
||
highbit = iTemp >> 14 & 0x3;
|
||
lowbit = iTemp & 0x3fff;
|
||
switch (highbit)
|
||
{
|
||
case 0:
|
||
n = 0.0001;
|
||
break;
|
||
case 1:
|
||
n = 0.01;
|
||
break;
|
||
case 2:
|
||
n = 1;
|
||
break;
|
||
case 3:
|
||
n = 100;
|
||
break;
|
||
}
|
||
dataDymY.Phase2 = lowbit * n;
|
||
|
||
memset(buf, 0, 8);
|
||
sprintf(buf, "%02x%02x", pRecvData->Data[61], pRecvData->Data[60]);
|
||
iTemp = (unsigned int)strtol(buf, NULL, 16);
|
||
highbit = iTemp >> 14 & 0x3;
|
||
lowbit = iTemp & 0x3fff;
|
||
switch (highbit)
|
||
{
|
||
case 0:
|
||
n = 0.0001;
|
||
break;
|
||
case 1:
|
||
n = 0.01;
|
||
break;
|
||
case 2:
|
||
n = 1;
|
||
break;
|
||
case 3:
|
||
n = 100;
|
||
break;
|
||
}
|
||
dataDymY.Phase3 = lowbit * n;
|
||
|
||
memset(buf, 0, 8);
|
||
sprintf(buf, "%02x%02x", pRecvData->Data[63], pRecvData->Data[62]);
|
||
iTemp = (unsigned int)strtol(buf, NULL, 16);
|
||
highbit = iTemp >> 14 & 0x3;
|
||
lowbit = iTemp & 0x3fff;
|
||
switch (highbit)
|
||
{
|
||
case 0:
|
||
n = 0.0001;
|
||
break;
|
||
case 1:
|
||
n = 0.01;
|
||
break;
|
||
case 2:
|
||
n = 1;
|
||
break;
|
||
case 3:
|
||
n = 100;
|
||
break;
|
||
}
|
||
dataDymY.Phase4 = lowbit * n;
|
||
|
||
memset(whereCon, 0, 64);
|
||
sprintf(whereCon, "channelID='%s'", (strLongAddr + "-Y").c_str());
|
||
if ( 0 == sql_ctl->GetTableRows(T_DATA_INFO(TNAME), whereCon) ) {
|
||
char insertSql[1024] = { 0 };
|
||
sprintf(insertSql, "'%s','%s','%f','%f','%f','%f','%f','%f','%f','%f','%f','%f','%f','%f','%f','%f','%s'",
|
||
strLongAddr.c_str(), (strLongAddr + "-Y").c_str(), dataDymY.DiagnosisPk, dataDymY.IntegratPk, dataDymY.IntegratRMS, dataDymY.RmsValues, dataDymY.EnvelopEnergy,\
|
||
dataDymY.Amp1, dataDymY.Amp2, dataDymY.Amp3, dataDymY.Amp4, dataDymY.Amp5,dataDymY.Phase1, dataDymY.Phase2, dataDymY.Phase3, dataDymY.Phase4, nowTimetamp.c_str());
|
||
sql_ctl->InsertData(T_DATA_INFO(TNAME), insertSql);
|
||
} else {
|
||
char updateSql[1024] = { 0 };
|
||
sprintf(updateSql, "diagnosisPk='%f',integratPk='%f',integratRMS='%f',rmsValues='%f',envelopEnergy='%f',\
|
||
Amp1='%f',Amp2='%f',Amp3='%f',Amp4='%f',Amp5='%f',Phase1='%f',Phase2='%f',Phase3='%f',Phase4='%f',timeStamp='%s'",\
|
||
dataDymY.DiagnosisPk, dataDymY.IntegratPk, dataDymY.IntegratRMS, dataDymY.RmsValues, dataDymY.EnvelopEnergy,\
|
||
dataDymY.Amp1, dataDymY.Amp2, dataDymY.Amp3, dataDymY.Amp4, dataDymY.Amp5,dataDymY.Phase1, dataDymY.Phase2, dataDymY.Phase3, dataDymY.Phase4, nowTimetamp.c_str());
|
||
sql_ctl->UpdateTableData(T_DATA_INFO(TNAME), updateSql, whereCon);
|
||
}
|
||
print_info("y: %s,%s,diagnosisPk=%f,integratPk=%f,integratRMS=%f,rmsValues=%f,envelopEnergy=%f,Amp1=%f,Amp2=%f,Amp3=%f,Amp4=%f,Amp5=%f,Phase1=%f,Phase2=%f,Phase3=%f,Phase4=%f,timeStamp=%s\n",\
|
||
strLongAddr.c_str(), (strLongAddr + "-Y").c_str(), dataDymY.DiagnosisPk, dataDymY.IntegratPk, dataDymY.IntegratRMS, dataDymY.RmsValues, dataDymY.EnvelopEnergy,\
|
||
dataDymY.Amp1, dataDymY.Amp2, dataDymY.Amp3, dataDymY.Amp4, dataDymY.Amp5,dataDymY.Phase1, dataDymY.Phase2, dataDymY.Phase3, dataDymY.Phase4, nowTimetamp.c_str());
|
||
|
||
|
||
valNodeFeature["dataNodeNo"] = strLongAddr;
|
||
valNodeFeature["channelID"] = strLongAddr + "-Y";
|
||
valNodeFeature["diagnosisPk"] = dataDymY.DiagnosisPk;
|
||
valNodeFeature["integratPk"] = dataDymY.IntegratPk;
|
||
valNodeFeature["integratRMS"] = dataDymY.IntegratRMS;
|
||
valNodeFeature["rmsValues"] = dataDymY.RmsValues;
|
||
valNodeFeature["envelopEnergy"] = dataDymY.EnvelopEnergy;
|
||
valNodeFeature["Amp1"] = dataDymY.Amp1;
|
||
valNodeFeature["Amp2"] = dataDymY.Amp2;
|
||
valNodeFeature["Amp3"] = dataDymY.Amp3;
|
||
valNodeFeature["Amp4"] = dataDymY.Amp4;
|
||
valNodeFeature["Amp5"] = dataDymY.Amp5;
|
||
valNodeFeature["Phase1"] = dataDymY.Phase1;
|
||
valNodeFeature["Phase2"] = dataDymY.Phase2;
|
||
valNodeFeature["Phase3"] = dataDymY.Phase3;
|
||
valNodeFeature["Phase4"] = dataDymY.Phase4;
|
||
valNodeFeature["timeStamp"] = nowTimetamp;
|
||
valNodeData.append(valNodeFeature);
|
||
|
||
DataRecvDym dataDymZ;
|
||
memset(buf, 0, 8);
|
||
sprintf(buf, "%02x%02x", pRecvData->Data[65], pRecvData->Data[64]);
|
||
iTemp = (unsigned int)strtol(buf, NULL, 16);
|
||
highbit = iTemp >> 14 & 0x3;
|
||
lowbit = iTemp & 0x3fff;
|
||
switch (highbit)
|
||
{
|
||
case 0:
|
||
n = 0.0001;
|
||
break;
|
||
case 1:
|
||
n = 0.01;
|
||
break;
|
||
case 2:
|
||
n = 1;
|
||
break;
|
||
case 3:
|
||
n = 100;
|
||
break;
|
||
}
|
||
dataDymZ.DiagnosisPk = lowbit * n;
|
||
|
||
memset(buf, 0, 8);
|
||
sprintf(buf, "%02x%02x", pRecvData->Data[67], pRecvData->Data[66]);
|
||
iTemp = (unsigned int)strtol(buf, NULL, 16);
|
||
highbit = iTemp >> 14 & 0x3;
|
||
lowbit = iTemp & 0x3fff;
|
||
switch (highbit)
|
||
{
|
||
case 0:
|
||
n = 0.0001;
|
||
break;
|
||
case 1:
|
||
n = 0.01;
|
||
break;
|
||
case 2:
|
||
n = 1;
|
||
break;
|
||
case 3:
|
||
n = 100;
|
||
break;
|
||
}
|
||
dataDymZ.RmsValues = lowbit * n;
|
||
|
||
memset(buf, 0, 8);
|
||
sprintf(buf, "%02x%02x", pRecvData->Data[69], pRecvData->Data[68]);
|
||
iTemp = (unsigned int)strtol(buf, NULL, 16);
|
||
highbit = iTemp >> 14 & 0x3;
|
||
lowbit = iTemp & 0x3fff;
|
||
switch (highbit)
|
||
{
|
||
case 0:
|
||
n = 0.0001;
|
||
break;
|
||
case 1:
|
||
n = 0.01;
|
||
break;
|
||
case 2:
|
||
n = 1;
|
||
break;
|
||
case 3:
|
||
n = 100;
|
||
break;
|
||
}
|
||
dataDymZ.IntegratPk = lowbit * n;
|
||
|
||
memset(buf, 0, 8);
|
||
sprintf(buf, "%02x%02x", pRecvData->Data[71], pRecvData->Data[70]);
|
||
iTemp = (unsigned int)strtol(buf, NULL, 16);
|
||
highbit = iTemp >> 14 & 0x3;
|
||
lowbit = iTemp & 0x3fff;
|
||
switch (highbit)
|
||
{
|
||
case 0:
|
||
n = 0.0001;
|
||
break;
|
||
case 1:
|
||
n = 0.01;
|
||
break;
|
||
case 2:
|
||
n = 1;
|
||
break;
|
||
case 3:
|
||
n = 100;
|
||
break;
|
||
}
|
||
dataDymZ.IntegratRMS = lowbit * n;
|
||
|
||
memset(buf, 0, 8);
|
||
sprintf(buf, "%02x%02x", pRecvData->Data[73], pRecvData->Data[72]);
|
||
iTemp = (unsigned int)strtol(buf, NULL, 16);
|
||
highbit = iTemp >> 14 & 0x3;
|
||
lowbit = iTemp & 0x3fff;
|
||
switch (highbit)
|
||
{
|
||
case 0:
|
||
n = 0.0001;
|
||
break;
|
||
case 1:
|
||
n = 0.01;
|
||
break;
|
||
case 2:
|
||
n = 1;
|
||
break;
|
||
case 3:
|
||
n = 100;
|
||
break;
|
||
}
|
||
dataDymZ.Amp1 = lowbit * n;
|
||
|
||
memset(buf, 0, 8);
|
||
sprintf(buf, "%02x%02x", pRecvData->Data[75], pRecvData->Data[74]);
|
||
iTemp = (unsigned int)strtol(buf, NULL, 16);
|
||
highbit = iTemp >> 14 & 0x3;
|
||
lowbit = iTemp & 0x3fff;
|
||
switch (highbit)
|
||
{
|
||
case 0:
|
||
n = 0.0001;
|
||
break;
|
||
case 1:
|
||
n = 0.01;
|
||
break;
|
||
case 2:
|
||
n = 1;
|
||
break;
|
||
case 3:
|
||
n = 100;
|
||
break;
|
||
}
|
||
dataDymZ.Amp2 = lowbit * n;
|
||
|
||
memset(buf, 0, 8);
|
||
sprintf(buf, "%02x%02x", pRecvData->Data[77], pRecvData->Data[76]);
|
||
iTemp = (unsigned int)strtol(buf, NULL, 16);
|
||
highbit = iTemp >> 14 & 0x3;
|
||
lowbit = iTemp & 0x3fff;
|
||
switch (highbit)
|
||
{
|
||
case 0:
|
||
n = 0.0001;
|
||
break;
|
||
case 1:
|
||
n = 0.01;
|
||
break;
|
||
case 2:
|
||
n = 1;
|
||
break;
|
||
case 3:
|
||
n = 100;
|
||
break;
|
||
}
|
||
dataDymZ.Amp3 = lowbit * n;
|
||
|
||
memset(buf, 0, 8);
|
||
sprintf(buf, "%02x%02x", pRecvData->Data[79], pRecvData->Data[78]);
|
||
iTemp = (unsigned int)strtol(buf, NULL, 16);
|
||
highbit = iTemp >> 14 & 0x3;
|
||
lowbit = iTemp & 0x3fff;
|
||
switch (highbit)
|
||
{
|
||
case 0:
|
||
n = 0.0001;
|
||
break;
|
||
case 1:
|
||
n = 0.01;
|
||
break;
|
||
case 2:
|
||
n = 1;
|
||
break;
|
||
case 3:
|
||
n = 100;
|
||
break;
|
||
}
|
||
dataDymZ.Amp4 = lowbit * n;
|
||
|
||
memset(buf, 0, 8);
|
||
sprintf(buf, "%02x%02x", pRecvData->Data[81], pRecvData->Data[80]);
|
||
iTemp = (unsigned int)strtol(buf, NULL, 16);
|
||
highbit = iTemp >> 14 & 0x3;
|
||
lowbit = iTemp & 0x3fff;
|
||
switch (highbit)
|
||
{
|
||
case 0:
|
||
n = 0.0001;
|
||
break;
|
||
case 1:
|
||
n = 0.01;
|
||
break;
|
||
case 2:
|
||
n = 1;
|
||
break;
|
||
case 3:
|
||
n = 100;
|
||
break;
|
||
}
|
||
dataDymZ.Amp5 = lowbit * n;
|
||
|
||
memset(buf, 0, 8);
|
||
sprintf(buf, "%02x%02x", pRecvData->Data[83], pRecvData->Data[82]);
|
||
iTemp = (unsigned int)strtol(buf, NULL, 16);
|
||
highbit = iTemp >> 14 & 0x3;
|
||
lowbit = iTemp & 0x3fff;
|
||
switch (highbit)
|
||
{
|
||
case 0:
|
||
n = 0.0001;
|
||
break;
|
||
case 1:
|
||
n = 0.01;
|
||
break;
|
||
case 2:
|
||
n = 1;
|
||
break;
|
||
case 3:
|
||
n = 100;
|
||
break;
|
||
}
|
||
dataDymZ.EnvelopEnergy = lowbit * n;
|
||
|
||
memset(buf, 0, 8);
|
||
sprintf(buf, "%02x%02x", pRecvData->Data[85], pRecvData->Data[84]);
|
||
iTemp = (unsigned int)strtol(buf, NULL, 16);
|
||
highbit = iTemp >> 14 & 0x3;
|
||
lowbit = iTemp & 0x3fff;
|
||
switch (highbit)
|
||
{
|
||
case 0:
|
||
n = 0.0001;
|
||
break;
|
||
case 1:
|
||
n = 0.01;
|
||
break;
|
||
case 2:
|
||
n = 1;
|
||
break;
|
||
case 3:
|
||
n = 100;
|
||
break;
|
||
}
|
||
dataDymZ.Phase1 = lowbit * n;
|
||
|
||
memset(buf, 0, 8);
|
||
sprintf(buf, "%02x%02x", pRecvData->Data[87], pRecvData->Data[86]);
|
||
iTemp = (unsigned int)strtol(buf, NULL, 16);
|
||
highbit = iTemp >> 14 & 0x3;
|
||
lowbit = iTemp & 0x3fff;
|
||
switch (highbit)
|
||
{
|
||
case 0:
|
||
n = 0.0001;
|
||
break;
|
||
case 1:
|
||
n = 0.01;
|
||
break;
|
||
case 2:
|
||
n = 1;
|
||
break;
|
||
case 3:
|
||
n = 100;
|
||
break;
|
||
}
|
||
dataDymZ.Phase2 = lowbit * n;
|
||
|
||
memset(buf, 0, 8);
|
||
sprintf(buf, "%02x%02x", pRecvData->Data[89], pRecvData->Data[88]);
|
||
iTemp = (unsigned int)strtol(buf, NULL, 16);
|
||
highbit = iTemp >> 14 & 0x3;
|
||
lowbit = iTemp & 0x3fff;
|
||
switch (highbit)
|
||
{
|
||
case 0:
|
||
n = 0.0001;
|
||
break;
|
||
case 1:
|
||
n = 0.01;
|
||
break;
|
||
case 2:
|
||
n = 1;
|
||
break;
|
||
case 3:
|
||
n = 100;
|
||
break;
|
||
}
|
||
dataDymZ.Phase3 = lowbit * n;
|
||
|
||
memset(buf, 0, 8);
|
||
sprintf(buf, "%02x%02x", pRecvData->Data[91], pRecvData->Data[90]);
|
||
iTemp = (unsigned int)strtol(buf, NULL, 16);
|
||
highbit = iTemp >> 14 & 0x3;
|
||
lowbit = iTemp & 0x3fff;
|
||
switch (highbit)
|
||
{
|
||
case 0:
|
||
n = 0.0001;
|
||
break;
|
||
case 1:
|
||
n = 0.01;
|
||
break;
|
||
case 2:
|
||
n = 1;
|
||
break;
|
||
case 3:
|
||
n = 100;
|
||
break;
|
||
}
|
||
dataDymZ.Phase4 = lowbit * n;
|
||
|
||
memset(whereCon, 0, 64);
|
||
sprintf(whereCon, "channelID='%s'", (strLongAddr + "-Z").c_str());
|
||
if ( 0 == sql_ctl->GetTableRows(T_DATA_INFO(TNAME), whereCon) ) {
|
||
char insertSql[1024] = { 0 };
|
||
sprintf(insertSql, "'%s','%s','%f','%f','%f','%f','%f','%f','%f','%f','%f','%f','%f','%f','%f','%f','%s'",
|
||
strLongAddr.c_str(), (strLongAddr + "-Z").c_str(), dataDymZ.DiagnosisPk, dataDymZ.IntegratPk, dataDymZ.IntegratRMS, dataDymZ.RmsValues, dataDymZ.EnvelopEnergy,\
|
||
dataDymZ.Amp1, dataDymZ.Amp2, dataDymZ.Amp3, dataDymZ.Amp4, dataDymZ.Amp5,dataDymZ.Phase1, dataDymZ.Phase2, dataDymZ.Phase3, dataDymZ.Phase4, nowTimetamp.c_str());
|
||
sql_ctl->InsertData(T_DATA_INFO(TNAME), insertSql);
|
||
} else {
|
||
char updateSql[1024] = { 0 };
|
||
sprintf(updateSql, "diagnosisPk='%f',integratPk='%f',integratRMS='%f',rmsValues='%f',envelopEnergy='%f',\
|
||
Amp1='%f',Amp2='%f',Amp3='%f',Amp4='%f',Amp5='%f',Phase1='%f',Phase2='%f',Phase3='%f',Phase4='%f',timeStamp='%s'",\
|
||
dataDymZ.DiagnosisPk, dataDymZ.IntegratPk, dataDymZ.IntegratRMS, dataDymZ.RmsValues, dataDymZ.EnvelopEnergy,\
|
||
dataDymZ.Amp1, dataDymZ.Amp2, dataDymZ.Amp3, dataDymZ.Amp4, dataDymZ.Amp5,dataDymZ.Phase1, dataDymZ.Phase2, dataDymZ.Phase3, dataDymZ.Phase4, nowTimetamp.c_str());
|
||
sql_ctl->UpdateTableData(T_DATA_INFO(TNAME), updateSql, whereCon);
|
||
}
|
||
print_info("Z: %s,%s,diagnosisPk=%f,integratPk=%f,integratRMS=%f,rmsValues=%f,envelopEnergy=%f,Amp1=%f,Amp2=%f,Amp3=%f,Amp4=%f,Amp5=%f,Phase1=%f,Phase2=%f,Phase3=%f,Phase4=%f,timeStamp=%s\n",\
|
||
strLongAddr.c_str(), (strLongAddr + "-Z").c_str(), dataDymZ.DiagnosisPk, dataDymZ.IntegratPk, dataDymZ.IntegratRMS, dataDymZ.RmsValues, dataDymZ.EnvelopEnergy,\
|
||
dataDymZ.Amp1, dataDymZ.Amp2, dataDymZ.Amp3, dataDymZ.Amp4, dataDymZ.Amp5,dataDymZ.Phase1, dataDymZ.Phase2, dataDymZ.Phase3, dataDymZ.Phase4, nowTimetamp.c_str());
|
||
|
||
//无线传感器Z信息
|
||
valNodeFeature["dataNodeNo"] = strLongAddr;
|
||
valNodeFeature["channelID"] = strLongAddr + "-Z";
|
||
valNodeFeature["diagnosisPk"] = dataDymZ.DiagnosisPk;
|
||
valNodeFeature["integratPk"] = dataDymZ.IntegratPk;
|
||
valNodeFeature["integratRMS"] = dataDymZ.IntegratRMS;
|
||
valNodeFeature["rmsValues"] = dataDymZ.RmsValues;
|
||
valNodeFeature["envelopEnergy"] = dataDymZ.EnvelopEnergy;
|
||
valNodeFeature["Amp1"] = dataDymZ.Amp1;
|
||
valNodeFeature["Amp2"] = dataDymZ.Amp2;
|
||
valNodeFeature["Amp3"] = dataDymZ.Amp3;
|
||
valNodeFeature["Amp4"] = dataDymZ.Amp4;
|
||
valNodeFeature["Amp5"] = dataDymZ.Amp5;
|
||
valNodeFeature["Phase1"] = dataDymZ.Phase1;
|
||
valNodeFeature["Phase2"] = dataDymZ.Phase2;
|
||
valNodeFeature["Phase3"] = dataDymZ.Phase3;
|
||
valNodeFeature["Phase4"] = dataDymZ.Phase4;
|
||
valNodeFeature["timeStamp"] = nowTimetamp;
|
||
valNodeData.append(valNodeFeature);
|
||
|
||
//无线传感器信息
|
||
Json::Value root;
|
||
Json::Value valdatastatic;
|
||
valdatastatic["TemperatureTop"] = dataStatic.TemTop;
|
||
valdatastatic["TemperatureBot"] = dataStatic.TemBot;
|
||
valdatastatic["Dip"] = dataStatic.Dip;
|
||
valdatastatic["Voltage"] = dataStatic.Voltage;
|
||
valdatastatic["ChannelType"] = "STATUS";
|
||
valdatastatic["ChannelId"] = strLongAddr + "-S";
|
||
valdatastatic["TimeStamp"] = nowTimetamp;
|
||
valdatastatic["dataNodeNo"] = strLongAddr;
|
||
valNodeData.append(valdatastatic);
|
||
|
||
root["data"] = valNodeData;
|
||
root["TimeStamp"] = nowTimetamp;
|
||
root["dataNodeNo"] = strLongAddr;
|
||
root["dataNodeGatewayNo"] = GlobalConfig::MacAddr_G;
|
||
Json::FastWriter featureValue;
|
||
std::string strstatisticData = featureValue.write(root);
|
||
//传感器发来的数据包中的表示设备信息的数据转化为json格式后，通过调用data_publish将数据传给mqttclient ： Topic：wireless/cmd/60294D203717
|
||
data_publish(strstatisticData.c_str(), GlobalConfig::Topic_G.mPubData.c_str());
|
||
//综上代码，把静态数据，x y z轴的特征值存放到sql数据库中（如果数据原来不存在，则插入新数据；如果存在，则更新数据）
|
||
print_info("Dip : %d TemBot : %f TemBot : %f Voltage : %d\n", dataStatic.Dip, dataStatic.TemBot, dataStatic.TemTop, dataStatic.Voltage);
|
||
|
||
}
|
||
|
||
void Uart::DealDataNodeWave(const char *pData)
|
||
{
|
||
print_info("recv wave\n");
|
||
RecvData * pRecvData = (RecvData *)pData;
|
||
m_VecWaveData.push_back(*pRecvData);
|
||
print_blue("wave data size is(m_VecWaveData.size) : %d\n",m_VecWaveData.size());
|
||
char localtimestamp[32] = { 0 };
|
||
GetTimeNet(localtimestamp, 1);
|
||
// 接收到原始数据信息，则更新时间戳，如果三秒种未收到原始数据，则重新从短地址 9999 切换回 短地址 8888
|
||
m_TimeStamp = strtol(localtimestamp, NULL, 10);
|
||
}
|
||
|
||
|
||
void Uart::DealWaveThread() //连续三秒没有原始数据，则处理缓存的原始数据
|
||
{
|
||
unsigned long nowTimeStamp = 0;
|
||
unsigned long tmpTimeStamp = 0;
|
||
|
||
while (1)
|
||
{
|
||
// 接收到原始波形，则 m_TimeStamp 不为零
|
||
// 如果当前时间与记录时间超过3秒，要求，m_TimeStamp不变化，而数据在传输，则一定小于3秒
|
||
if (0 == m_TimeStamp) {
|
||
boost::this_thread::sleep(boost::posix_time::seconds(1));
|
||
continue;
|
||
}
|
||
char localtimestamp[32] = { 0 };
|
||
GetTimeNet(localtimestamp, 1);
|
||
nowTimeStamp = strtol(localtimestamp, NULL, 10);
|
||
// 避免在未同步时钟导致数据错误
|
||
if(nowTimeStamp >= m_TimeStamp) {
|
||
tmpTimeStamp = nowTimeStamp - m_TimeStamp;
|
||
}
|
||
else {
|
||
tmpTimeStamp = m_TimeStamp - nowTimeStamp;
|
||
}
|
||
//if ((nowTimeStamp - m_TimeStamp) > 3) { 时间戳需要修改为绝对值，可能丢失时钟，或工作一会儿，才同步时钟，可能减出异常值
|
||
if (tmpTimeStamp > 3 ) { // TODO： 时间戳需要修改为绝对值，可能丢失时钟，或工作一会儿，才同步时钟，可能减出异常值 print_info("yes!The time difference is more than 3,nowTimeStamp : %ld m_TimeStamp : %ld\n", nowTimeStamp, m_TimeStamp);
|
||
DealWave();
|
||
m_TimeStamp = 0;
|
||
pUart->UpdateZigbeeInfoCtrl();
|
||
GlobalConfig::EnterZigBeeWaveTransmittingFlag_G = NO_ENTER_TRANSMITTING_STATUS;
|
||
GlobalConfig::EnterZigBeeWaveTransmittingCnt_G = 0;
|
||
// 准备重新恢复到 8888 PanID，正常接收特征数据
|
||
ZigbeeInit();
|
||
} else {
|
||
print_info("NO! The time difference is less than 3,nowTimeStamp : %ld m_TimeStamp : %ld\n", nowTimeStamp, m_TimeStamp);
|
||
}
|
||
|
||
boost::this_thread::sleep(boost::posix_time::seconds(1));
|
||
}
|
||
}
|
||
|
||
void Uart::DealWave()
|
||
{
|
||
print_info("begin deal Wave data !\n");
|
||
std::string strShortAddr = "";
|
||
std::string strShortAddrTemp;
|
||
std::string strLongAddr = "";
|
||
std::string strFileName = "";
|
||
int iChannel = 0;
|
||
int iChannelTemp = 0;
|
||
long iTemp = 0;
|
||
std::vector<float> vecData;
|
||
char buf[8];
|
||
RecvData recvTemp;
|
||
|
||
print_info("all wave data size is(m_VecWaveData.size) : %d\n", m_VecWaveData.size());
|
||
while (m_VecWaveData.size() > 0) { //对每个传感器的每个通道进行遍历然后处理数据，例如：传感器1x轴的数据处理完后，再去处理y轴的。传感器1的所有数据处理完后，再处理传感器2的
|
||
std::vector<RecvData>::iterator iter = m_VecWaveData.begin();
|
||
recvTemp = *iter;
|
||
memset(buf, 0, 8);
|
||
sprintf(buf, "%02x%02x", recvTemp.ShortAddr[0], recvTemp.ShortAddr[1]);
|
||
strShortAddr = std::string(buf);
|
||
|
||
memset(buf, 0, 8);
|
||
sprintf(buf, "%02d", recvTemp.Type&0xFF);
|
||
iChannel = boost::lexical_cast<int>(buf);
|
||
|
||
char getLongAddr_sql[32] = { 0 };
|
||
sprintf(getLongAddr_sql, "zigbeeShortAddr='%s'", strShortAddr.c_str());
|
||
strLongAddr = sql_ctl->GetData(T_SENSOR_INFO(TNAME), T_SENSOR_INFO(ZIGBEELONGADDR), getLongAddr_sql);
|
||
//print_info("3.1.2.3--->strLongAddr : %s\n", strLongAddr.c_str());
|
||
if ( 0 == strLongAddr.length() ) {
|
||
boost::this_thread::sleep(boost::posix_time::seconds(1));
|
||
continue;
|
||
}
|
||
|
||
std::string ran = "";
|
||
int n = 0;
|
||
int range = 0;
|
||
float coe = 0;
|
||
char getrange[32] = {0};
|
||
std::string str = "range";
|
||
sprintf(getrange, "scope='%s'", str.c_str());
|
||
ran = sql_ctl->GetData(T_SENSOR_INFO(TNAME), T_SENSOR_INFO(RANGE), getrange);
|
||
//print_info("@@@@@@@@@@@@@@@@@@@@@@ran=%s\n",ran.c_str());
|
||
memset(getrange, 0, 32);
|
||
sprintf(getrange, "%s", ran.c_str());
|
||
n = (int)strtol(getrange, NULL, 32);
|
||
//print_light_purple("!!!!!!!!!!!!!n=%d\n",n);
|
||
switch (n)
|
||
{
|
||
case 0:{
|
||
range = 8;
|
||
coe = 8*1.0/32767;
|
||
}
|
||
break;
|
||
case 1:{
|
||
range = 16;
|
||
coe = 16*1.0/32767;
|
||
}
|
||
break;
|
||
case 2:{
|
||
range = 32;
|
||
coe = 32*1.0/32767;
|
||
}
|
||
break;
|
||
case 3:{
|
||
range = 64;
|
||
coe = 64*1.0/32767;
|
||
}
|
||
break;
|
||
}
|
||
//print_blue("##############range = %d,%f\n",range,coe);
|
||
for(; iter != m_VecWaveData.end();)
|
||
{
|
||
recvTemp = *iter;
|
||
memset(buf, 0, 8);
|
||
sprintf(buf, "%02x%02x", recvTemp.ShortAddr[0], recvTemp.ShortAddr[1]);
|
||
strShortAddrTemp = std::string(buf);
|
||
|
||
memset(buf, 0, 8);
|
||
sprintf(buf, "%02d", recvTemp.Type & 0xFF);
|
||
iChannelTemp = boost::lexical_cast<int>(buf);
|
||
|
||
if( 0 == strShortAddr.compare(strShortAddrTemp) && (iChannel == iChannelTemp) ) {
|
||
float fTemp;
|
||
for (int i = 0; i < 46; i++) {
|
||
memset(buf, 0, 8);
|
||
sprintf(buf, "%02x%02x", recvTemp.Data[2*i+1],recvTemp.Data[i*2]);
|
||
iTemp = strtol(buf, NULL, 16);
|
||
if (iTemp < 0x8000) {
|
||
fTemp = iTemp * coe;
|
||
} else {
|
||
fTemp = (((~iTemp)&0xffff) + 1) * -coe;
|
||
}
|
||
//print_blue("wave data is %u,%f\n",iTemp,fTemp);
|
||
vecData.push_back(fTemp);
|
||
}
|
||
iter = m_VecWaveData.erase(iter);
|
||
} else {
|
||
iter++;
|
||
}
|
||
}
|
||
|
||
|
||
/*char getLongAddr_sql[32] = { 0 };
|
||
sprintf(getLongAddr_sql, "zigbeeShortAddr='%s'", strShortAddr.c_str());
|
||
strLongAddr = sql_ctl->GetData(T_SENSOR_INFO(TNAME), T_SENSOR_INFO(ZIGBEELONGADDR), getLongAddr_sql);
|
||
|
||
print_info("strLongAddr : %s\n", strLongAddr.c_str());*/
|
||
if ( 0 == strLongAddr.length() ) {
|
||
boost::this_thread::sleep(boost::posix_time::seconds(1));
|
||
continue;
|
||
}
|
||
std::string strChannelID = "";
|
||
switch (iChannel)
|
||
{
|
||
case 3:{
|
||
strFileName = "/opt/data/" + strLongAddr + "-X.dat";
|
||
strChannelID = strLongAddr + "-X";
|
||
}
|
||
break;
|
||
case 4:{
|
||
strFileName = "/opt/data/" + strLongAddr + "-Y.dat";
|
||
strChannelID = strLongAddr + "-Y";
|
||
}
|
||
break;
|
||
case 5:{
|
||
strFileName = "/opt/data/" + strLongAddr + "-Z.dat";
|
||
strChannelID = strLongAddr + "-Z";
|
||
}
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
|
||
if (access(strFileName.c_str(), 0) > 0) { //如果存在原始数据删除原来的，只保留一份
|
||
std::string strCmd = "rm " + strFileName;
|
||
system(strCmd.c_str());
|
||
}
|
||
|
||
|
||
FILE *fp = fopen(strFileName.c_str(), "w");
|
||
print_info("fopen FIle vecData.size : %d\n", vecData.size());
|
||
float frTemp;
|
||
char buf[33]={0x00};
|
||
std::string strWaveData = "";
|
||
for (int i = 0; i < vecData.size(); i++) {
|
||
frTemp = vecData[i];
|
||
fwrite(&frTemp,sizeof(float),1,fp);
|
||
memset(buf,0x00,sizeof(buf));
|
||
sprintf(buf, "%.2f", vecData[i]);
|
||
std::string waveTemp(buf);
|
||
if(i == 0)
|
||
strWaveData = waveTemp;
|
||
strWaveData = strWaveData + "," + waveTemp;
|
||
}
|
||
vecData.clear();
|
||
fclose(fp);
|
||
//
|
||
Json::Value valWaveData;
|
||
valWaveData["number"] = strWaveData.length();
|
||
valWaveData["channelId"] = strChannelID;
|
||
valWaveData["dataNodeNo"] = strLongAddr;
|
||
valWaveData["dataNodeGatewayNo"] = GlobalConfig::MacAddr_G;
|
||
valWaveData["SensorEngineeringUnit"] = "";
|
||
valWaveData["waveData"] = strWaveData;
|
||
Json::FastWriter WaveValue;
|
||
std::string WaveData = WaveValue.write(valWaveData);
|
||
//传感器发来的数据包中的表示设备信息的数据转化为json格式后，通过调用data_publish将数据传给mqttclient ： Topic：wireless/cmd/60294D203717
|
||
data_publish(WaveData.c_str(), GlobalConfig::Topic_G.mPubWaveData.c_str());
|
||
print_info("write data to filename %s\n", strFileName.c_str());
|
||
boost::this_thread::sleep(boost::posix_time::seconds(1));
|
||
}
|
||
|
||
|
||
// memset(buf, 0, 8);
|
||
// sprintf(buf, "%02x%02x", recvTemp.ShortAddr[0], recvTemp.ShortAddr[1]);
|
||
// std::string strShortAddr = std::string(buf);
|
||
|
||
}
|
||
void Uart::modify_distaddr_info(unsigned short id, char * zigbee,unsigned char* distAddr)
|
||
{
|
||
/*char command[6];
|
||
command[0] = 0xDE;
|
||
command[1] = 0xDF;
|
||
command[2] = 0xEF;
|
||
command[3] = 0xD2;
|
||
command[4] = destaddr[0];
|
||
command[5] = destaddr[1];
|
||
WriteToUart(command, 6);*/
|
||
|
||
}
|
||
void Uart::modify_info(unsigned short id, char * zigbee)
|
||
{
|
||
int i, j, ret,con;
|
||
char command[100];
|
||
char command1[20];
|
||
char tmp = 0;
|
||
command[0] = 0xab;
|
||
command[1] = 0xbc;
|
||
command[2] = 0xcd;
|
||
command[3] = 0xd6;
|
||
command[4] = ((char *)&id)[1];
|
||
command[5] = ((char *)&id)[0];
|
||
command[6] = 0;
|
||
if (zigbee != NULL) {
|
||
con = 71;
|
||
memcpy(&(command[6]), zigbee + 4, 65);
|
||
} else {
|
||
con = 6;
|
||
}
|
||
for(i = 0; i < con; i++)
|
||
{
|
||
tmp += command[i];
|
||
}
|
||
command[i] = tmp;
|
||
WriteToUart(command, i+1);
|
||
boost::this_thread::sleep(boost::posix_time::seconds(1));
|
||
}
|
||
|
||
void Uart::zigbee_reset(unsigned short pad, unsigned short type)
|
||
{
|
||
char command[10],tmp = 0,i;
|
||
command[0] = 0xab;
|
||
command[1] = 0xbc;
|
||
command[2] = 0xcd;
|
||
command[3] = 0xd9;
|
||
command[4] = ((char *)&pad)[1];
|
||
command[5] = ((char *)&pad)[0];
|
||
command[6] = ((char *)&type)[1];
|
||
command[7] = ((char *)&type)[0];
|
||
for(i = 0; i<8; i++)
|
||
{
|
||
tmp += command[i];
|
||
}
|
||
command[8] = tmp;
|
||
WriteToUart(command, 9);
|
||
}
|
||
|
||
void Uart::WriteChanl2Zigbee(unsigned char pad)
|
||
{
|
||
print_info("WriteChanl2Zigbee : %d\n", pad);
|
||
unsigned char pad1 = pad;
|
||
unsigned short tmp;
|
||
tmp = GlobalConfig::Zigbee_G.MyAddr;
|
||
//swap((char *)&pad1);
|
||
swap((char *)&tmp);
|
||
GlobalConfig::Zigbee_G.Chan = pad1;
|
||
modify_info(tmp, (char *)& GlobalConfig::Zigbee_G);
|
||
zigbee_reset(tmp, 1);
|
||
}
|
||
|
||
void Uart::WritePanId2Zigbee(unsigned short pad)
|
||
{
|
||
print_info("WritePanId2Zigbee : %d\n", pad);
|
||
unsigned short pad1 = pad,tmp;
|
||
tmp = GlobalConfig::Zigbee_G.MyAddr;
|
||
swap((char *)&pad1);
|
||
swap((char *)&tmp);
|
||
GlobalConfig::Zigbee_G.PanID = pad1;
|
||
modify_info(tmp, (char *)&GlobalConfig::Zigbee_G);
|
||
zigbee_reset(tmp, 1);
|
||
}
|
||
|
||
|
||
void Uart::WriteShortAddr2Zigbee(unsigned short pad)
|
||
{
|
||
print_info("WriteShortAddr2Zigbee : %4x\n", (unsigned short)pad);
|
||
unsigned short pad1 = pad,tmp;
|
||
tmp = GlobalConfig::Zigbee_G.MyAddr;
|
||
swap((char *)&pad1);
|
||
swap((char *)&tmp);
|
||
GlobalConfig::Zigbee_G.MyAddr = pad1;
|
||
modify_info(tmp, (char *)& GlobalConfig::Zigbee_G);
|
||
zigbee_reset(tmp, 1);
|
||
}
|
||
|
||
void Uart::WriteShortAddr_DistAddr2Zigbee(unsigned short pad,unsigned char* id)
|
||
{
|
||
print_info("WriteShortAddr2Zigbee : %4x\n", (unsigned short)pad);
|
||
unsigned short pad1 = pad,tmp;
|
||
tmp = GlobalConfig::Zigbee_G.MyAddr;
|
||
swap((char *)&pad1);
|
||
swap((char *)&tmp);
|
||
GlobalConfig::Zigbee_G.MyAddr = BUILD_UINT16(id[0],id[1]);
|
||
GlobalConfig::ZigbeeInfo_G.MyAddr = "9999";
|
||
modify_info(tmp, (char *)& GlobalConfig::Zigbee_G);
|
||
zigbee_reset(tmp, 1);
|
||
}
|
||
|
||
void Uart::ZigbeeInit()
|
||
{
|
||
std::string strPanId = GlobalConfig::MacAddr_G.substr(8);
|
||
print_info("strPanId : %s\n", strPanId.c_str());
|
||
// 新增管理ZigBee代码
|
||
std::string strchan = ReadStrByOpt(ZIGBEECONFIG, "Zigbee", "channel");
|
||
unsigned char Chan = (unsigned char)strtol(strchan.c_str(), NULL, 10);
|
||
printf("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%the chan = %u\n",Chan);
|
||
print_info("ZigbeeInfo_G.Channel=%d\n",GlobalConfig::ZigbeeInfo_G.Channel);
|
||
if(Chan > 10 && Chan < 27)
|
||
{
|
||
if (Chan != GlobalConfig::ZigbeeInfo_G.Channel) {
|
||
printf("the chanl is different\n");
|
||
WriteChanl2Zigbee(Chan);
|
||
boost::this_thread::sleep(boost::posix_time::seconds(1));
|
||
}
|
||
}
|
||
|
||
if (0 != GlobalConfig::ZigbeeInfo_G.PanID.compare(strPanId.c_str())) {
|
||
long lShortAddr = strtol(strPanId.c_str(), NULL, 16);
|
||
unsigned short panid = lShortAddr & 0xffff;
|
||
print_info("the panid is different\n");
|
||
WritePanId2Zigbee(panid);
|
||
boost::this_thread::sleep(boost::posix_time::seconds(1));
|
||
}
|
||
|
||
if (0 != GlobalConfig::ZigbeeInfo_G.MyAddr.compare("8888")) {
|
||
unsigned short shortAddr = 0x8888;
|
||
print_info("the short addr is different\n");
|
||
WriteShortAddr2Zigbee(shortAddr);
|
||
boost::this_thread::sleep(boost::posix_time::seconds(1));
|
||
LOG_INFO("[ZigbeeInit---------] ZigBee PanID: %s ; Channel: %d ; MyAddr : %4x ",GlobalConfig::ZigbeeInfo_G.PanID.c_str(),GlobalConfig::ZigbeeInfo_G.Channel,
|
||
(unsigned short)GlobalConfig::Zigbee_G.MyAddr);
|
||
// 更新GlobalConfig::ZigbeeInfo_G.MyAddr，用于外部显示
|
||
char tmp[16];
|
||
sprintf(tmp,"%4x",(unsigned short)GlobalConfig::Zigbee_G.MyAddr);
|
||
std::string strTmp(tmp);
|
||
GlobalConfig::ZigbeeInfo_G.MyAddr = strTmp;
|
||
}
|
||
print_info("ZigbeeInfo_G.MyAddr=%s\n",GlobalConfig::ZigbeeInfo_G.MyAddr.c_str());
|
||
|
||
}
|
||
|
||
|