wirelessgateway/uart/SH_Uart.cpp

#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;
		}
	}
	printf("thisindex = %d\n",thisindex);
	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());

}