#include <signal.h>
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <termios.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <boost/thread/thread.hpp> 
#include <boost/lexical_cast.hpp> 
#include <boost/algorithm/string.hpp>
#include <boost/bind.hpp>
#include <boost/timer.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
#include "../uart/SH_Uart.hpp"
#include "../serial/serial.h"


namespace{
    Uart *pUart = Uart::instance();
    Calculation *pCalculation = Calculation::instance();
}
char g_UartRecvBuf[GENERAL_BUF_SIZE];
int offSize = 0;
pTestRecvCallBack pTestRecv ;
std::vector<RecvData> g_VecWaveDataX;
std::vector<RecvData> g_VecWaveDataY;
std::vector<RecvData> g_VecWaveDataZ;
map<string,compressWaveChannel> g_mapCompress;
// 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;

int Uart::UartRecv(int fd, char srcshow,char* buffer)
{
	char buff[BUF_LENGTH];
	int ret = 0;
	int maxSize = 0;
	int offSize = 0;
	int timeoutflag = 0;
	char head[] = {0xAA,0x55,0xAA};
	char szbuffer[BUF_LENGTH]={0x00};
	while(1)
	{ 

		if((unsigned short)GlobalConfig::Zigbee_G.MyAddr == 0x9999){
			
			memset(buff, 0, sizeof(buff));
			ret = read_data(fd, buff, BUF_LENGTH, 10);
			if (ret <= 0 ){
				if(!bUpdate && !bUpdateconfig && GlobalConfig::EnterZigBeeWaveTransmittingCnt_G > 15){
					timeoutflag ++;
					if(timeoutflag > 300){
						LOG_DEBUG("===============0x9999 timeout= %d offSize = %d===============\n",timeoutflag,offSize);
						print_info("0x9999 timeout %d===============Size = %d\n",timeoutflag,offSize);
						FindRecvPackage(offSize, mUartRecvTmpBuf,head);
						GlobalConfig::Zigbee_G.MyAddr = 0x8888;
						timeoutflag = 0;
						offSize = 0;
						maxSize = 0;
						tcflush(fd,TCIFLUSH);
						bModifyAddr = true;
						modify_LocalAddr(0x8888);
						bSendTimeStamp = false;
						mssleep(10000);
						m_waveTrans = true;
						memset(mUartRecvTmpBuf,0,BUF_LENGTH);
						GlobalConfig::EnterZigBeeWaveTransmittingFlag_G  = NO_ENTER_TRANSMITTING_STATUS;
						GlobalConfig::EnterZigBeeWaveTransmittingCnt_G   = 0;
						
						LOG_DEBUG("wave end\n");
					}
					mssleep(10000);
				}else if(bUpdatePre || (bUpdateconfig && GlobalConfig::EnterZigBeeWaveTransmittingCnt_G > 15)){
					timeoutflag ++;
					if(timeoutflag > 300){
						print_info("bUpdateconfig %d===============\n",timeoutflag);
						GlobalConfig::EnterZigBeeWaveTransmittingFlag_G  = NO_ENTER_TRANSMITTING_STATUS;
						GlobalConfig::EnterZigBeeWaveTransmittingCnt_G   = 0;
						timeoutflag = 0;
						offSize = 0;
						maxSize = 0;
						bUpdate = false;
						bUpdatePre = false;
						bUpdateconfig = false;
						bModifyAddr = true;
						bSendTimeStamp = false;
						modify_LocalAddr(0x8888);
						mssleep(10000);
						GlobalConfig::Zigbee_G.MyAddr = 0x8888;
					}
					mssleep(10000);
				}
			}
			else if(ret > 0){
				maxSize += ret;
//				print_debug("0x9999===str_recv===,ret = %d offSize = %d,bUpdatePre = %d,bUpdateconfig = %d\n",ret,maxSize,bUpdatePre,bUpdateconfig);
//				for(int i = 0; i < ret;i++){
//					printf("[%02x]", buff[i]&0xff);
//				}
				//print_debug("maxSize = %d\n",maxSize);
				//print_debug("\n");
				timeoutflag = 0;

				if((bUpdatePre || bUpdateconfig))
				{
					for(int i = 0; i < ret;i++){
						printf("%02x ", buff[i]&0xff);
					}
					//print_debug("maxSize111 = %d\n",maxSize);
		//			string strTime = GetLocalTimeWithMs();
		//			LOG_INFO("str_recv strTime1 = %s\n",strTime.c_str());
					FindRecvPackage(ret,buff,head);
		//			ReadHandle(buff,ret);
		//			strTime = GetLocalTimeWithMs();
		//			LOG_INFO("str_recv strTime2 = %s\n",strTime.c_str());
				}else{
					m_TimeStamp = 0;
					memcpy(mUartRecvTmpBuf + offSize,buff,ret);
					offSize = offSize + ret;
					if(offSize > BUF_LENGTH * 15){
						LOG_INFO("maxSize = %d\n",offSize);
						memset(mUartRecvTmpBuf,0,BUF_LENGTH);
						timeoutflag = 0;
						offSize = 0;
						maxSize = 0;
						tcflush(fd,TCIOFLUSH);
						bModifyAddr = true;
						modify_LocalAddr(0x8888);
						GlobalConfig::Zigbee_G.MyAddr = 0x8888;
						GlobalConfig::EnterZigBeeWaveTransmittingFlag_G  = NO_ENTER_TRANSMITTING_STATUS;
						GlobalConfig::EnterZigBeeWaveTransmittingCnt_G   = 0;
					}
					//print_debug("offSize = %d\n",offSize);
				}
			}

		}else if((unsigned short)GlobalConfig::Zigbee_G.MyAddr == 0x8888){
#ifdef IMX6UL_GATEWAY
			memset(buff, 0, sizeof(buff));
			ret = read_data(fd, buff, BUF_LENGTH, 50);
			if (ret <= 0){
				continue;
			}
			if (srcshow) {
				print_info("0x8888 ===str_recv===,ret = %d\n",ret);
				for(int i = 0; i < ret;i++){
					print_debug("[%02x]", buff[i]&0xff);
				}
				printf("\n");
				FindRecvPackage(ret, buff,head);

			}
#else if G2UL_GATEWAY
			memset(buff, 0x00, sizeof(buff));
			ret = read_data(fd, buff, BUF_LENGTH, 50);
			if (ret <= 0 ){
				timeoutflag ++;
				if(timeoutflag > 5){

					FindRecvPackage(offSize, szbuffer,(char*)head);
					memset(szbuffer,0x00,sizeof(szbuffer));
					timeoutflag = 0;
					offSize = 0;
					maxSize = 0;
					mssleep(10000);
				}
			}else if(ret > 0){
				maxSize += ret;
				print_debug("0x8888==str_recv===,ret = %d offSize = %d\n",ret,maxSize);
				for(int i = 0; i < ret;i++){
					print_debug("%02x ", buff[i]&0xff);
				}
				print_debug("\n");
				timeoutflag = 0;
				m_TimeStamp = 0;
				memcpy(szbuffer + offSize,buff,ret);
				offSize = offSize + ret;
			}
#endif
		}
		//mssleep(50);
	}
}

Uart::Uart():mUart(mIoSev),mStrand(mIoSev)
{
		mRdLength = 0;
		m_TimeStamp = 0;
	    mlastSize = 0;
	    fd = 0;
	    waittime = 0;
	    mPackgeIndex = -1;
	    bUpdate = false;
	    m_strDestShortAddr = "";
	    memset(mUartRecvBuf,0,BUF_LENGTH);
	    memset(mUartRecvTmpBuf,0,BUF_LENGTH);
	    bTest = false;
	    TestFd  = 0;
	    DataNodeUpdateFile = "";
	    strTimetamp = "";
	    bZigbeeSinal = false;
	    bModifyAddr = false;
	    bUpdatePre = false;
		bSendTimeStamp = false;
		m_waveCountX = 0;
		m_waveCountY = 0;
		m_waveCountZ = 0;
		VecWaveDataX.reserve(1000);
    	VecWaveDataY.reserve(1000);
    	VecWaveDataZ.reserve (1500);
}
Uart::~Uart()
{
	close(fd);
	close(TestFd);
    if (mUart.is_open())
        mUart.close();
}

void Uart::openSwitch()
{
	char buffer[100]={0x00};
	int len;
	int fdSwitch = config_uart("/dev/ttymxc1",B38400);
	char strSend[8]={0x01,0x06,0x00,0x00,0x00,0x00,0x89,0xCA};
	len = write_data(fdSwitch,(char*)strSend,8);
	sleep(1);
	len = read_data(fdSwitch,(char*)buffer,100,10);
	for ( int i = 0; i < len; i++)
		print_debug("%02X ",buffer[i]&0xFF);
	char strSend2[8]={0x01,0x06,0x00,0x00,0x00,0x01,0x48,0x0A};
	len = write_data(fdSwitch,(char*)strSend2,8);
	sleep(1);
	len = read_data(fdSwitch,(char*)buffer,100,10);
	for ( int i = 0; i < len; i++)
		print_debug("%02X ",buffer[i]&0xFF);
	close(fdSwitch);
}
void Uart::InitUart(speed_t speed)
{

#ifdef G2UL_GATEWAY
	fd = config_uart("/dev/ttySC2",speed);
#endif
#ifdef IMX6UL_GATEWAY
	fd = config_uart("/dev/ttymxc4",speed);
#endif
	print_info("InitUart fd = %d\n",fd);
	if(fd < 0){
		printf("config_uart error\n");
	}

}
void Uart::Close()
{
	close(fd);
	fd = 0;
}
void Uart::InitZigbee()
{

	InitUart(B115200);
	UpdateZigbeeInfoCtrl();
	sleep(2);
	int iRet = ReadFromUart();
	if(iRet <= 0)
	{
		Close();
		sleep(2);
		print_info("Speed error\n");
		InitUart(B57600);
		UpdateZigbeeInfoCtrl();
		sleep(2);
		ReadFromUart();
		print_info("modify speed\n");
		WriteSpeed2Zigbee();
		ReadFromUart();
	}
	Close();
	sleep(1);
}
void TestRecv(int status)
{
	char szStatus[10]={0x00};
	sprintf(szStatus,"%d",status);
	write_data(pUart->TestFd,(char*)szStatus,strlen(szStatus));
}
void Regist(pTestRecvCallBack pTestRecv1){
	pTestRecv = pTestRecv1;
}
void Uart::InitTestUart(speed_t speed)
{
	print_info("InitTestUart\n");
	TestFd = config_uart("/dev/ttymxc2",speed);//Test
	if(TestFd < 0){
		printf("Test config_uart error\n");
	}
	Regist(TestRecv);
}

void Uart::ReadTestUart()
{
	char buff[BUF_LENGTH] = {0x00};
	print_info("ReadTestUart\n");
	while(1){
		int ret = read_data(TestFd, buff, BUF_LENGTH, 10);
		if(ret > 0){
			print_info("buff = %s\n",buff);
			if(!strcmp(buff,"0")){

			char buf[256] = {0};
			sprintf(buf, "{\"dataNodeGatewayNo\":\"%s\",\"cmd\":\"12\",\"status\":\"REQ\"}",
			                                        GlobalConfig::MacAddr_G.c_str());
			std::string str = std::string(buf);
			int iRet = data_publish(str.c_str(), GlobalConfig::Topic_G.mPubCmd.c_str());
			if(iRet < 0){
				pTestRecv(1);
			}else{
				pTestRecv(0);
			}
			iRet = ZigbeeTest();
			}else if(!strcmp(buff,"1")){
				string IP = GetGwIp_("eth0");
				write_data(TestFd,(char*)IP.c_str(),IP.size());
				IP = GetGwIp_("eth1");
				write_data(TestFd,(char*)"|",1);
				write_data(TestFd,(char*)IP.c_str(),IP.size());
				write_data(TestFd,(char*)"|",1);
			}else{
				ModifyMac(buff);
				pTestRecv(0);
			}
		}
		mssleep(20000);
	}
}

int Uart::ZigbeeTest()
{
	char buff[BUF_LENGTH] = {0x00};
	modify_Localchannel(22);
	mssleep(100000);

	modify_LocalPanID(2222);

	mssleep(100000);
	modify_LocalAddr(6666);

	mssleep(100000);
	return 0;
}

void Uart::WriteToUart(const char *strSend,int pLen)
{
//#ifdef ZIGBEE_TEST
	if(!bUpdate){
		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))
                               );
    }*/
    int len = write_data(fd,(char*)strSend,pLen);
   // printf("len = %d\n",len);
 //   ReadFromUart();
}

int Uart::ReadFromUart()
{

 /*   if (mUart.is_open()) {
    	print_info("async_read_some,wait......................................\n");
        mUart.async_read_some(buffer(&mUartRecvBuf[mRdLength], BUF_LENGTH-mRdLength-offSize),
                              mStrand.wrap(
                                  boost::bind(&Uart::ReadHandle,this,
                                              boost::asio::placeholders::error,
                                              boost::asio::placeholders::bytes_transferred))
                              );
    }*/
	char buffer[100]={0x00};
	int len = read_data(fd,(char*)buffer,100,10);
	for ( int i = 0; i < len; i++)
	    print_debug("%02X ",buffer[i]&0xFF);
	print_info("\n");
	print_info("==========ReadFromUart========len = %d\n",len);

	if(len){
		char head[] = {0xAA,0x55,0xAA};
		FindRecvPackage(len, buffer,head);
	}
	return len;
	/*if(len > 0){
		ReadHandle(buffer,len);
	}*/
}

void Uart::Run()
{
    mIoSev.run();
}

void Uart::Stop()
{
    if (mUart.is_open())
        mUart.close();
    mIoSev.stop();
}
int Uart::FindRecvPackage(int  bytesRead, char* mUartRecvBuf,char* head)
{
		string strTime = GetLocalTimeWithMs();
		char head1[] = {0xAB,0xBC,0xCD};
		char head2[] = {0xDE,0xDF,0xEF};

		//LOG_INFO("m_VecWaveData= %d\n",m_VecWaveData.size());
		int lastSize = 0;
		char UartRecvBuf[BUF_LENGTH*15]={0x00};
		char RecvBuf[200] = {0x00};
		if(mlastSize > 0){
			print_info("mlastSize = %d\n",mlastSize);
			memcpy(UartRecvBuf,mUartRecvTmpBuf,mlastSize);
			for(int i = 0; i < mlastSize;i++){
				print_info("%02x ",UartRecvBuf[i]);
			}
			print_info("\n ");
			memset(mUartRecvTmpBuf,0x00,sizeof(mUartRecvTmpBuf));
		}
		memcpy(UartRecvBuf + mlastSize,mUartRecvBuf,bytesRead);
		// for(int i = 0 ; i < bytesRead;i++){
		// 	if(!(i % 100))
		// 		printf("\n");
		// 	printf("%02x ",mUartRecvBuf[i]);
		// }
		bytesRead = bytesRead + mlastSize;
		for(int i = 0; i < bytesRead;i++){
			if(UartRecvBuf[i] == head[0]){
				char buf[6]={0x00};
				char ShortAddr[8]={0x00};
				sprintf(&buf[0], "%02X", UartRecvBuf[i]&0xFF);
				sprintf(&buf[2], "%02X", UartRecvBuf[i+1]&0xFF);
				sprintf(&buf[4], "%02X", UartRecvBuf[i+2]&0xFF);
				sprintf(ShortAddr, "%02x%02x", UartRecvBuf[i+3]&0xFF, UartRecvBuf[i+4]&0xFF);
				std::string strShortAddr(ShortAddr);
				std::string strHeadFlag(buf);
				if ( 0 == strHeadFlag.compare("AA55AA")) {
					char buf[8]={0x00};
					sprintf(buf, "%02d", UartRecvBuf[i+5]&0xFF);
					int command = atoi(buf);
					//print_info("command = %d\n",command);
					//print_info("index = %d\n",UartRecvBuf[i+6]&0xFF);
					//print_info("mPackgeIndex1 = %d\n",mPackgeIndex);
					if((mPackgeIndex == -1 || (unsigned int)UartRecvBuf[i+6] == 0) && (!bUpdatePre && !bUpdateconfig)){
						//print_info("mPackgeIndex2 = %d\n",mPackgeIndex);
						mPackgeIndex = UartRecvBuf[i+6]&0xFF;
					}else if((unsigned int)mPackgeIndex  == (unsigned int)UartRecvBuf[i+6] &&
							mPackgeIndex != -1 && (!bUpdatePre && !bUpdateconfig) && command != 2){
						LOG_ERROR("mPackgeIndex same index1:%d,index2:%02d ShortAddr :%s \n",\
														mPackgeIndex,UartRecvBuf[i+6]&0xff,strShortAddr.c_str());
						continue;

					}else if((unsigned int)mPackgeIndex + 1 != (unsigned int)UartRecvBuf[i+6] &&
							mPackgeIndex != -1 && (!bUpdatePre && !bUpdateconfig) && command != 2){
						m_TimeStamp = 0;
						//print_info("mPackgeIndex3 = %d\n",mPackgeIndex);
						LOG_ERROR("mPackgeIndex error index1:%d,index2:%02d ShortAddr :%s \n",\
								mPackgeIndex,UartRecvBuf[i+6]&0xff,strShortAddr.c_str());
						mPackgeIndex = -1;
						print_error("mPackgeIndex error  ShortAddr :%s \n",strShortAddr.c_str());

						char tmp[10]={0x00};
						char tmp2[10]={0x00};
						for(int j = 0; j < 100;j++){
							sprintf(tmp,"%02x ",UartRecvBuf[i + j] & 0xff);
							strcat(tmp2,tmp);
						}
						LOG_ERROR("error str = %s\n",tmp2);
						GlobalConfig::Zigbee_G.MyAddr = 0x8888;
						tcflush(fd,TCIOFLUSH);
						sleep(1);
						modify_LocalAddr(0x8888);
						sleep(1);
						bModifyAddr = true;
						bSendTimeStamp = false; 
						GlobalConfig::EnterZigBeeWaveTransmittingFlag_G = NO_ENTER_TRANSMITTING_STATUS;
						GlobalConfig::EnterZigBeeWaveTransmittingCnt_G  = 0;
						//std::vector<RecvData>().swap(m_VecWaveData);
						break;
					}

					if(command == 32){
						LOG_INFO("bUpdatepackge command = %d ShortAddr :%s\n",command,strShortAddr.c_str());
						memcpy(RecvBuf,(char*)&UartRecvBuf[i],12);
						//for(int j = i; j < i+12;j++){
						//	print_info("%02X ",UartRecvBuf[j]&0xFF);
						//}

						if(!CheckCrc(RecvBuf,11)){
								LOG_INFO("CheckCrc error command 20 \n");
								mPackgeIndex = -1;
								GlobalConfig::Zigbee_G.MyAddr = 0x8888;
								tcflush(fd,TCIOFLUSH);
								sleep(1);
								modify_LocalAddr(0x8888);
								sleep(1);
								bModifyAddr = true;
								bSendTimeStamp = false;
								GlobalConfig::EnterZigBeeWaveTransmittingFlag_G = NO_ENTER_TRANSMITTING_STATUS;
								GlobalConfig::EnterZigBeeWaveTransmittingCnt_G  = 0;
								break;
						}
						bUpdate = true;
						m_TimeStamp = 0;
						DealRecvData(RecvBuf);
						break;
					}else if(!bUpdatePre && !bUpdateconfig && (command == 3 || command == 4 || command == 5)){
						if(!CheckCrc(&UartRecvBuf[i],99)){
								m_TimeStamp = 0;
								mPackgeIndex = -1;
								LOG_INFO("CheckCrc error  ShortAddr :%s command = %d\n",strShortAddr.c_str(),command);
								print_error("CheckCrc error  ShortAddr :%s \n",strShortAddr.c_str());
								char tmp[10]={0x00};
								char tmp2[10]={0x00};
								for(int j = 0; j < 100;j++){
									sprintf(tmp,"%02x ",UartRecvBuf[i + j] & 0xff);
									strcat(tmp2,tmp);
								}
								LOG_ERROR("error str = %s\n",tmp2);
								print_info("\n");
								GlobalConfig::Zigbee_G.MyAddr = 0x8888;
								tcflush(fd,TCIOFLUSH);
								sleep(1);
								modify_LocalAddr(0x8888);
								bModifyAddr = true;
								sleep(1);
								bSendTimeStamp = false; 
								GlobalConfig::EnterZigBeeWaveTransmittingFlag_G = NO_ENTER_TRANSMITTING_STATUS;
								GlobalConfig::EnterZigBeeWaveTransmittingCnt_G  = 0;
								m_waveCountX = 0;
								m_waveCountY = 0;
								m_waveCountZ = 0;
								g_VecWaveDataX.clear();
								g_VecWaveDataY.clear();
								g_VecWaveDataZ.clear();
								//std::vector<RecvData>().swap(m_VecWaveData);
								break;
						}
						mlastSize = 0;
						lastSize = bytesRead - i;
						//print_info("laseSize = %d , i = %d\n",lastSize,i);
						if(lastSize < 100 && lastSize > 0){
							memcpy(mUartRecvTmpBuf,(char*)&UartRecvBuf[bytesRead-lastSize],lastSize);
							mlastSize = lastSize;
							break;
						}
						memcpy(RecvBuf,(char*)&UartRecvBuf[i],100);
						DealDataNodeWave(RecvBuf,command);
					}else if(!bUpdate && !bUpdateconfig && (command == 1 || command == 2 || command == 6 || command == 7)){
						char RecvBuf[100] = {0x00};
						memcpy(RecvBuf,&UartRecvBuf[i],100);
						if(!CheckCrc(RecvBuf,99)){
							LOG_INFO("CheckCrc error  ShortAddr :%s command = %d \n",strShortAddr.c_str(),command);
							break;
						}
						DealRecvData(RecvBuf);

					}else if(bUpdate && !bUpdateconfig && (command == 1 || command == 2 || command == 6 || command == 7)){

						print_info("m_strDestShortAddr = %s,strShortAddr = %s,waittime = %d\n",\
								m_strDestShortAddr.c_str(),strShortAddr.c_str(),waittime);
						//if(waittime >= 2 || m_strDestShortAddr == strShortAddr)
						{
								char RecvBuf[100] = {0x00};
								memcpy(RecvBuf,&UartRecvBuf[i],100);
								DealRecvData(RecvBuf);
						        LOG_INFO("Online = %s,command = %d\n",strShortAddr.c_str(),command);
						        waittime = 0;
						        bUpdate = false;
						        bUpdatePre = false;
						        m_strDestShortAddr = "";
						        GlobalConfig::Zigbee_G.MyAddr = 0x8888;
						        GlobalConfig::EnterZigBeeWaveTransmittingFlag_G = NO_ENTER_TRANSMITTING_STATUS;
						        GlobalConfig::EnterZigBeeWaveTransmittingCnt_G  = 0;
						        //break;
						 }/*else if(m_strDestShortAddr != strShortAddr){
						        mssleep(100000);
						        waittime ++;
						 }*/

					}else if(command == 34 && bUpdateconfig){
						LOG_INFO("bUpdateconfig command = %d ShortAddr :%s\n",command,strShortAddr.c_str());
						memset(RecvBuf,0x00,sizeof(RecvBuf));
						print_info("bUpdateconfig ShortAddr :%s\n",strShortAddr.c_str());
						//memcpy(RecvBuf,(char*)&UartRecvBuf[i],100);
						/*for(int j = i; j < i+100;j++){
							print_info("%02X ",UartRecvBuf[j]&0xFF);
						}*/
						m_TimeStamp = 0;
						//if(!CheckCrc((char*)&UartRecvBuf[i],99))
						{
							char whereCon[1024] = {0};
							char updateSql[1024] = { 0 };
							char buf[20]={0x00};
							sprintf(buf, "%02x%02x", UartRecvBuf[i+3]&0xFF, UartRecvBuf[i+4]&0xFF);//Zigbee 本地地址 2 byte
							sprintf(updateSql, "UpdateFlag = UpdateFlag + 1");
							sprintf(whereCon, "zigbeeShortAddr='%s'", buf);
							sql_ctl->UpdateTableData(T_SENSOR_INFO(TNAME), updateSql, whereCon);
							//string strData = sql_ctl->GetNodeConfigureInfor(whereCon);
							//data_publish(strData.c_str(), GlobalConfig::Topic_G.mPubConfig.c_str());
							GlobalConfig::Zigbee_G.MyAddr = 0x8888;
							bUpdateconfig = false;
							mPackgeIndex = -1;
							tcflush(fd,TCIOFLUSH);
							sleep(1);
							modify_LocalAddr(0x8888);
							bModifyAddr = true;
							bSendTimeStamp = false;
							sleep(1);
							
							GlobalConfig::EnterZigBeeWaveTransmittingFlag_G  = NO_ENTER_TRANSMITTING_STATUS;
							GlobalConfig::EnterZigBeeWaveTransmittingCnt_G   = 0;
							break;
						}
						break;
					}else if(command == 35){
						//LOG_INFO("command = %d ShortAddr :%s,Timetamp=%s\n",command,strShortAddr.c_str(),strTimetamp.c_str());
						// for(int j = i; j < i+100;j++){
						// 	printf("%02X ",UartRecvBuf[j]&0xFF);
						// }
						char signalNode[10]={0x00};
						sprintf(signalNode,"%02d",UartRecvBuf[i+14]&0xFF);
						if(!strcmp(signalNode,"00") || !strcmp(signalNode,"0")){
							char errorInfo[100]={0x00};
							sprintf(errorInfo,"未检测到信号！%s",signalNode);
							LOG_ERROR(errorInfo);
						}else{
							char whereCon[1024] = {0};
							char updateSql[1024] = { 0 };
							char tableName[100]={0x00};
							sprintf(whereCon, "zigbeeShortAddr='%s'", strShortAddr.c_str());
							vec_t vecDataNodeNo = sql_ctl->GetDataSingleLine(T_SENSOR_INFO(TNAME), " dataNodeNo,RSSI ", whereCon);
							memset(whereCon,0x00,sizeof(whereCon));
							sprintf(updateSql, "zigbeeSignalNode = '%02d' ",UartRecvBuf[i+14]&0xFF);//zigbeeRSSIType = 0 传感器获取网关信号强度
							sprintf(whereCon, "dataNodeNo='%s' and timeStamp = '%s'", (char*)vecDataNodeNo[0].c_str(),strTimetamp.c_str());
							sprintf(tableName,"t_dataStatic_%s",(char*)vecDataNodeNo[0].c_str());
							sql_ctl->UpdateTableData(tableName, updateSql, whereCon);

							vector<string> vParamRSSI;
							boost::split( vParamRSSI, vecDataNodeNo[1], boost::is_any_of( "," ), boost::token_compress_on );
							if(vParamRSSI.size() > 0){
								sprintf(updateSql, "RSSI = '%s,%02d' ",vParamRSSI[0].c_str(),UartRecvBuf[i+14]&0xFF);
								//LOG_INFO(updateSql);
								sprintf(whereCon, "dataNodeNo='%s'", (char*)vecDataNodeNo[0].c_str());
								sql_ctl->UpdateTableData(T_SENSOR_INFO(TNAME), updateSql, whereCon);
							} 
						}

					}
					mPackgeIndex = (unsigned int)UartRecvBuf[i+6];

				}
				else{
					continue;
				}
			}else if(UartRecvBuf[i] == head1[0]){
				char buf[6]={0x00};
				sprintf(&buf[0], "%02X", UartRecvBuf[i]&0xFF);
				sprintf(&buf[2], "%02X", UartRecvBuf[i+1]&0xFF);
				sprintf(&buf[4], "%02X", UartRecvBuf[i+2]&0xFF);
				std::string strHeadFlag(buf);
				if ( 0 == strHeadFlag.compare("ABBCCD")) {
					char buf[8]={0x00};
					sprintf(buf, "%02d", UartRecvBuf[i+3]&0xFF);
					int command = atoi(buf);
					print_info("command = %d\n",command);
					if(command == 209){
						UpdateZigbeeInfo(&UartRecvBuf[i]);
					}else if(command == 220){//DC
						bModifyAddr = false;
						LOG_INFO("zigbeeShortAddr = %s , ret = %02d\n",m_strDestShortAddr.c_str(),UartRecvBuf[i+6]&0xFF);
						if(UartRecvBuf[i+6]&0xFF != 00){
							modify_LocalAddr(0x8888);
						}
					}
				}
			}else if(UartRecvBuf[i] == head2[0]){
				char buf[6]={0x00};
				sprintf(&buf[0], "%02X", UartRecvBuf[i]&0xFF);
				sprintf(&buf[2], "%02X", UartRecvBuf[i+1]&0xFF);
				sprintf(&buf[4], "%02X", UartRecvBuf[i+2]&0xFF);
				std::string strHeadFlag(buf);
				if ( 0 == strHeadFlag.compare("DEDFEF")) {
					char buf[8]={0x00};
					sprintf(buf, "%02d", UartRecvBuf[i+3]&0xFF);
					int command = atoi(buf);
					print_info("command = %d\n",command);
					char tmp[16] = {0x00};
					if(command == 209){//D1
						pTestRecv(command);
					}else if(command == 219){//DB
						pTestRecv(command);
					}else if(command == 220){//DC
						bModifyAddr = false;
						print_info("%02x,%02x,%02x,%02x,%02x \n",UartRecvBuf[i],UartRecvBuf[i+1],UartRecvBuf[i+2],UartRecvBuf[i+3],UartRecvBuf[i+4]);
						LOG_INFO("zigbeeShortAddr = %s , ret = %02d\n",m_strDestShortAddr.c_str(),UartRecvBuf[i+4]&0xFF);

						//pTestRecv(command);
					}else if(command == 218){//DA
						//LOG_INFO("command = %d,zigbeeShortAddr = %s , signal = %02d,strTimetamp = %s\n",command,m_strDestShortAddr.c_str(),UartRecvBuf[i+6]&0xFF,strTimetamp.c_str());
						char whereCon[1024] = {0};
						char updateSql[1024] = { 0 };
						char tableName[100]={0x00};
						bZigbeeSinal  = false;
						sprintf(whereCon, "zigbeeShortAddr='%s'", m_strDestShortAddr.c_str());
						vec_t vecDataNodeNo = sql_ctl->GetDataSingleLine(T_SENSOR_INFO(TNAME), " dataNodeNo,LooseValue,RSSI ", whereCon);
						memset(whereCon,0x00,sizeof(whereCon));
						sprintf(updateSql, "zigbeeSignal = '%02d' ",UartRecvBuf[i+6]&0xFF);//zigbeeRSSIType = 1 网关获取传感器信号强度
						sprintf(whereCon, "dataNodeNo='%s' and timeStamp = '%s'", (char*)vecDataNodeNo[0].c_str(),strTimetamp.c_str());
						sprintf(tableName,"t_dataStatic_%s",(char*)vecDataNodeNo[0].c_str());
						sql_ctl->UpdateTableData(tableName, updateSql, whereCon);
						Json::Value jsBody,jsonVal;
						Json::FastWriter showValue;
						char looseValue[10]={0x00};
						readStringValue("config", "loose",looseValue,(char*)GlobalConfig::Config_G.c_str());
						 if(atof(looseValue) < atof(vecDataNodeNo[1].c_str())){
							 jsBody["looseStatus"] = "1";
						 }else{
							 jsBody["looseStatus"] = "0";
						 }
						vector<string> vParamRSSI;
						boost::split( vParamRSSI, vecDataNodeNo[2], boost::is_any_of( "," ), boost::token_compress_on );
						if(vParamRSSI.size() == 1){
							sprintf(updateSql, "RSSI = '%02d,%s' ",UartRecvBuf[i+6]&0xFF,vParamRSSI[0].c_str());
							//LOG_INFO(updateSql);
							
						}else if(vParamRSSI.size() == 2){
							sprintf(updateSql, "RSSI = '%02d,%s' ",UartRecvBuf[i+6]&0xFF,vParamRSSI[1].c_str());
							//LOG_INFO(updateSql);
						} 
						sprintf(whereCon, "dataNodeNo='%s'", (char*)vecDataNodeNo[0].c_str());
						sql_ctl->UpdateTableData(T_SENSOR_INFO(TNAME), updateSql, whereCon);

						jsonVal["cmd"] = "52";
						jsBody["timeStamp"] = strTimetamp;
						jsBody["dataNodeNo"] = vecDataNodeNo[0];
						jsBody["zigbeeSignal"] = UartRecvBuf[i+6]&0xFF;
						std::string dataBody = showValue.write(jsBody);
						jsonVal["cmdBody"] = dataBody;
						data_publish(showValue.write(jsonVal).c_str(), GlobalConfig::Topic_G.mPubConfig.c_str());
					}
				}
			}

		}
		strTime = GetLocalTimeWithMs();
//		LOG_INFO("findRecvPackage strTime2 = %s\n",strTime.c_str());
}
void Uart::ReadHandle(char* pUartRecvBuf,size_t bytesRead)
{
/*try{
    if (ec) {
        mRdLength = 0;
        ReadFromUart();
        return ;
    }
    else*/
    {   //长度检测
    	char UartRecvBuf[BUF_LENGTH]={0x00};
    	memcpy(UartRecvBuf,pUartRecvBuf,bytesRead);
    	print_info("recv uart len in ZigBee short address %4x : %d\n recv uart data:",
    			         (unsigned short)GlobalConfig::Zigbee_G.MyAddr, bytesRead);
 //   	 for ( 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循环。*/

        if((unsigned short)GlobalConfig::Zigbee_G.MyAddr == (unsigned short)0x9999){

        }else{
        for (int j = 0; j < iPackageSize; j++) {
        	char buf[6];
        	char mUartRecvPackage[100] = {0};
        	char ShortAddr[8];

        	// 多包分包，解包，
        	if (Count < 100) {
        	     memcpy(mUartRecvPackage, &UartRecvBuf[j * 100], Count);
        	} else {
        	     memcpy(mUartRecvPackage, &UartRecvBuf[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(ShortAddr, "%02x%02x", mUartRecvPackage[3]&0xFF, mUartRecvPackage[4]&0xFF);
        	if(bUpdate){//waitting for the upated node 4s
        	      std::string strShortAddr(ShortAddr);
        	      print_info("m_strDestShortAddr = %s,strShortAddr = %s,waittime = %d\n",m_strDestShortAddr.c_str(),strShortAddr.c_str(),waittime);
        	       if(waittime >= 40 || m_strDestShortAddr == strShortAddr){
        	            LOG_INFO("Online = %s\n",strShortAddr.c_str());
        	            waittime = 0;
        	            bUpdate = false;
        	            m_strDestShortAddr = "";
        	        }else if(m_strDestShortAddr != strShortAddr){
        	            mssleep(100000);
        	            waittime ++;
        	            return ;
        	         }
        	 }
            std::string strHeadFlag(buf);
            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") ) {
            	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);
    sleep(1);*/
//    ReadFromUart();
		char command[5]={0x00};
	    unsigned char command1[100]={0x00};
	    command[0] = 0xab;
	    command[1] = 0xbc;
	    command[2] = 0xcd;
	    command[3] = 0xd1;
	    command[4] = 0xaa;
	    WriteToUart(command,5);
	    LOG_INFO("UpdateZigbeeInfoCtrl \n");
		/*for ( int i = 0; i < 20; i++)
			print_info("%02X ",command[i]);
		print_info("\n");*/
		/*int ret = write_data(fd, (char*)command, 5);
	    if (ret < 0) {
	        perror("write");
	        return ;
	    }
	   // sleep(1);

		/*ret = read_data(fd, (char *)command1, 100, 10);
		printf("ret = %d\n",ret);
	    if (ret <= 4) {
	        printf("info get error!\n");
	        return ;
	    }
	    UpdateZigbeeInfo((char*)command1);*/
}

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 = atoi(buff);

    memset(buff, 0, 8);
    sprintf(buff, "%02d", pData[37]&0xFF);
    GlobalConfig::ZigbeeInfo_G.Channel = atoi(buff);

    memset(buff, 0, 8);
    sprintf(buff, "%02x%02x", pData[38]&0xFF, pData[39]&0xFF);
    GlobalConfig::ZigbeeInfo_G.PanID = std::string(buff);

    memset(buff, 0, 8);
    sprintf(buff, "%02x%02x", pData[40]&0xFF, pData[41]&0xFF);
    GlobalConfig::ZigbeeInfo_G.MyAddr = std::string(buff);

    
    memset(buff, 0, 8);
    sprintf(buff, "%02x%02x", pData[50]&0xFF, pData[51]&0xFF);
    GlobalConfig::ZigbeeInfo_G.DstAddr = std::string(buff);

    memset(buff, 0, 8);
   sprintf(buff, "%d", pData[62]);
   GlobalConfig::ZigbeeInfo_G.RetryNum = std::string(buff);

   memset(buff, 0, 8);
   sprintf(buff, "%d", pData[63]);
   GlobalConfig::ZigbeeInfo_G.TranTimeout = std::string(buff);

    LOG_INFO("local zigbee module info Mode : %d Chan : %d PanID : %s MyAddr : %s DstAddr : %s,RetryNum:%s,TranTimeout:%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(),GlobalConfig::ZigbeeInfo_G.RetryNum.c_str(),GlobalConfig::ZigbeeInfo_G.TranTimeout.c_str());
//    if(GlobalConfig::ZigbeeInfo_G.MyAddr != "8888"){
//    	modify_LocalAddr(0x8888);
//
//    	LOG_INFO("zigbee Update \n");
//    	GlobalConfig::ZigbeeInfo_G.MyAddr = "8888";
//    }
    LOG_INFO("PanID = %s,MacAddr_G= %s\n",GlobalConfig::ZigbeeInfo_G.PanID.c_str(),GlobalConfig::MacAddr_G.c_str());
//    if(GlobalConfig::ZigbeeInfo_G.PanID != GlobalConfig::MacAddr_G.substr(8)){
//    	string strPanId = GlobalConfig::MacAddr_G.substr(8);
//    	long lShortAddr = strtol(strPanId.c_str(), NULL, 16);
//    	unsigned short panid = lShortAddr & 0xffff;
//    	//modify_LocalPanID(panid);
//    	WritePanId2Zigbee(panid);
//    	mssleep(100000);
//    	LOG_ERROR("PanID error");
//    }


    std::string strchan = ReadStrByOpt(ZIGBEECONFIG, "Zigbee", "channel");
    LOG_INFO("Channel = %d,strchan = %s\n",GlobalConfig::ZigbeeInfo_G.Channel,strchan.c_str());
//    if(GlobalConfig::ZigbeeInfo_G.Channel != atoi(strchan.c_str())){
//    	unsigned short Chan = (unsigned short)strtol(strchan.c_str(), NULL, 10);
//    	if(Chan > 10 && Chan < 27)
//    	{
//    		//modify_Localchannel(Chan);
//    		WriteChanl2Zigbee(Chan);
//    		mssleep(100000);
//    	}
//    	LOG_ERROR("channel error");
//    }

    std::string strType = ReadStrByOpt(SYSTEMINFOFILE, "ZigbeeType", "type");
    print_info("TranTimeout = %02x,strType = %s \n",GlobalConfig::Zigbee_G.TranTimeout,strType.c_str());
    if(strType == "aw21"){
    	unsigned short TranTimeout = 0x0A;
    	WriteTranTimeout2Zigbee(TranTimeout);
    }
    if( strType == "zm5161"){
    	unsigned short TranTimeout = 0x03;
    	WriteTranTimeout2Zigbee(TranTimeout);
    }
//    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);
}
bool Uart::ReadUpdatePackge(unsigned char* pDestShortAddr)
{
	//compare hardversion in update list
	std::vector<std::string> strHWversion;
	std::string strFileName = "",strSoftVersion = "";
	std::vector <DataNodeUpdate> vecDataNodeUpdate;
	vecDataNodeUpdate = ReadStrUpdate("/opt/DataNode/config.json");
	char gethardVersion_sql[32] = { 0 };
	char selectsql[1024]={ 0 };
	sprintf(gethardVersion_sql, "zigbeeShortAddr='%02x%02x'", pDestShortAddr[0],pDestShortAddr[1]);
	sprintf(selectsql,"%s,%s",T_SENSOR_INFO(HARDVERSION),T_SENSOR_INFO(SOFTVERSION));
	vec_t vecResult = sql_ctl->GetDataSingleLine(T_SENSOR_INFO(TNAME), selectsql, gethardVersion_sql);
	if(vecResult.size() < 1){
		return false;
	}
	print_info("hardversion %s,softversion %s\n",vecResult[0].c_str(),vecResult[1].c_str());
	int thisindex = -1;
	int flag = -1;
	for(int j = 0; j < vecDataNodeUpdate.size();j++){
		for(int i = 0; i < vecDataNodeUpdate[j].hwVersion.size();i++){
			if(vecResult[0] == vecDataNodeUpdate[j].hwVersion[i]){
				if(vecResult[1] == vecDataNodeUpdate[j].strSoftVersion){
					flag = 0;
					break;
				}else{
					thisindex = i;
					strFileName = vecDataNodeUpdate[j].strUpdataFileName;
					break;
				}
			}
		}
		if(thisindex >= 0 || flag == 0)
			break;
	}

	if(thisindex < 0)
		return false;

//	if(!strncmp(vecResult[0].c_str(),"3",1)){
//		WriteTranTimeout2Zigbee(0x03);
//	}else if(!strncmp(vecResult[0].c_str(),"4",1)){
//		WriteTranTimeout2Zigbee(0x0A);
//	}

	print_info("thisindex = %d\n",thisindex);

	FILE * pFile=NULL;
	int thisSize = 0;
	DataNodeUpdateFile = "/opt/DataNode/" + strFileName;
	print_info("strFileName = %s\n",DataNodeUpdateFile.c_str());
	pFile = fopen (DataNodeUpdateFile.c_str(),"rb");
	if (pFile==NULL){
		return false;
	}
	else
	{
		while (fgetc(pFile) != EOF) {
			++thisSize;
		}
		fclose (pFile);
	}

//	WriteShortAddr_DistAddr2Zigbee(localAddr,pDestShortAddr);//永久参数配置
/*	char tmpbuf[8] = {0x00};
 * unsigned short localAddr = 0x9999;
	sprintf(tmpbuf,"%02x%02x",pDestShortAddr[0],pDestShortAddr[1]);
	m_strDestShortAddr = std::string(tmpbuf);
	modify_distaddr_info(localAddr,"",pDestShortAddr);//临时参数配置
	GlobalConfig::Zigbee_G.MyAddr = 0x9999;*/

	unsigned char Data[12]={0x00};
	unsigned char size[4]={0x00};
	print_info("thisSize = %d\n",thisSize);
	//帧头[3byte]	节点地址[2byte]	数据类型[1byte]	序号[1byte]	升级包大小[4byte]	CRC校验[1byte]
	Data[0]=0xAA;
	Data[1]=0x55;
	Data[2]=0xAA;
	Data[3]=pDestShortAddr[0];
	Data[4]=pDestShortAddr[1];
	Data[5]=0x20;
	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;
	sleep(1);
	WriteToUart((const char*)Data,12);
	int iRet = CheckZigbeeACK();
	if(iRet == 0){
		LOG_DEBUG("Packge ACK send success,shortAddr = %02x%02x\n",pDestShortAddr[0],pDestShortAddr[1]);
	}else{
		LOG_ERROR("Packge ACK send failed,shortAddr = %02x%02x\n",pDestShortAddr[0],pDestShortAddr[1]);
	}
	string strTime = GetLocalTimeWithMs();
	LOG_INFO("ReadUpdatePackge strTime = %s\n",strTime.c_str());
	return true;
}
void Uart::UpdateWirelessNode(unsigned short  shortAdd)
{
		string strTime = GetLocalTimeWithMs();
		LOG_INFO("UpdateWirelessNode start = %s UpdateWirelessNode id = %02x %02x\n",strTime.c_str(),UINT16_HIGH(shortAdd),UINT16_LOW(shortAdd));
		/*std::string strFileName = "",strSoftVersion = "";
		std::vector <DataNodeUpdate> vecDataNodeUpdate;
		vecDataNodeUpdate = ReadStrUpdate("/opt/DataNode/config.json");

		char gethardVersion_sql[32] = { 0 };
		sprintf(gethardVersion_sql, "zigbeeShortAddr='%02x%02x'", UINT16_HIGH(shortAdd),UINT16_LOW(shortAdd));
		std::string SoftVersion = sql_ctl->GetData(T_SENSOR_INFO(TNAME), "softVersion", gethardVersion_sql);

		print_info("SoftVersion = %s\n",SoftVersion.c_str());
		LOG_INFO(" NOW SoftVersion = %s\n",SoftVersion.c_str());*/
		//////
		//////
		//strFileName = "/opt/DataNode/" + strFileName;
		FILE * pFile=NULL;
		int thisSize = 0;
		char *buffer=NULL;
		int resendCount = 0;
		pFile = fopen (DataNodeUpdateFile.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);

			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);
			unsigned char tmp = 0x00;
			gpio_set(GlobalConfig::GPIO_G.zigAckreset,0);
			//boost::this_thread::sleep(boost::posix_time::milliseconds(1));
			mssleep(1000);
			gpio_set(GlobalConfig::GPIO_G.zigAckreset,1);
			for(int j = 0; j < Count;j++){
				int time ,value;
				UpdateData[0]=0xAA;
				UpdateData[1]=0x55;
				UpdateData[2]=0xAA;
				UpdateData[3]=UINT16_HIGH(shortAdd);
				UpdateData[4]=UINT16_LOW(shortAdd);
				UpdateData[5]=0x21;
				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;
//			RESEND:
				WriteToUart((const char*)UpdateData,100);
				if(gpio_read(GlobalConfig::GPIO_G.zigAckrep) == 48)
					gpio_set(GlobalConfig::GPIO_G.zigAckreset,1);
				time = 0;
				do{
					value = gpio_read(GlobalConfig::GPIO_G.zigAckrep);
					if(value == 49)
						break;
					mssleep(10000);
					time += 1;
				}while(time < 150);
				if(time >= 150){
					resendCount++;
					if(resendCount < 5){
						LOG_INFO(" RESEND gpio_read failed shortAdd %x %x,error index %d\n",UINT16_HIGH(shortAdd),UINT16_LOW(shortAdd),j);
					}else{
						LOG_INFO("gpio_read failed shortAdd %x %x,error index %d\n",UINT16_HIGH(shortAdd),UINT16_LOW(shortAdd),j);
						print_red("gpio_read failed \n");
						GlobalConfig::EnterZigBeeWaveTransmittingFlag_G  = NO_ENTER_TRANSMITTING_STATUS;
						GlobalConfig::EnterZigBeeWaveTransmittingCnt_G   = 0;
						bUpdate = false;
						goto endUpdate;
					}
				}
				gpio_set(GlobalConfig::GPIO_G.zigAckreset,0);
				mssleep(2000);
//				if(gpio_read(GlobalConfig::GPIO_G.zigAckrep) == 48)
//					gpio_set(GlobalConfig::GPIO_G.zigAckreset,1);
				memset(UpdateData,0x00,sizeof(UpdateData));
				//boost::this_thread::sleep(boost::posix_time::milliseconds(5));
				mssleep(5000);
			}
			if(gpio_read(GlobalConfig::GPIO_G.zigAckrep) == 48)
				gpio_set(GlobalConfig::GPIO_G.zigAckreset,1);
	//		printf("Count =%d,lastSize = %d\n",Count,lastSize);
			if(lastSize > 0){
				UpdateData[0]=0xAA;
				UpdateData[1]=0x55;
				UpdateData[2]=0xAA;
				UpdateData[3]=UINT16_HIGH(shortAdd);
				UpdateData[4]=UINT16_LOW(shortAdd);
				UpdateData[5]=0x21;
				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);
				boost::this_thread::sleep(boost::posix_time::milliseconds(10));
//				if(gpio_read(GlobalConfig::GPIO_G.zigAckrep) == 49){
//					gpio_set(GlobalConfig::GPIO_G.zigAckreset,0);
//					boost::this_thread::sleep(boost::posix_time::milliseconds(1));
//					if(gpio_read(GlobalConfig::GPIO_G.zigAckrep) == 48)gpio_set(GlobalConfig::GPIO_G.zigAckreset,1);
//				}
				int time = 0;
				do{
					int value = gpio_read(GlobalConfig::GPIO_G.zigAckrep);
					if(value == 49){
						gpio_set(GlobalConfig::GPIO_G.zigAckreset,0);
						mssleep(10000);
						if(gpio_read(GlobalConfig::GPIO_G.zigAckrep) == 48)
							gpio_set(GlobalConfig::GPIO_G.zigAckreset,1);
							break;
						}
					mssleep(10000);
					time += 1;
				}while(time < 150);
				if(time >= 150){
					LOG_INFO("gpio_read failed shortAdd %x %x\n",UINT16_HIGH(shortAdd),UINT16_LOW(shortAdd));
					print_info("gpio_read failed \n");
					GlobalConfig::EnterZigBeeWaveTransmittingFlag_G  = NO_ENTER_TRANSMITTING_STATUS;
					GlobalConfig::EnterZigBeeWaveTransmittingCnt_G   = 0;
					bUpdate = false;
					goto endUpdate;
				}
				memset(UpdateData,0x00,sizeof(UpdateData));
			}
			print_info("Update END!!! file Size = %d\n",thisSize);
		}
	endUpdate:
		resendCount = 0;
		free(buffer);
		tcflush(fd,TCIFLUSH);
		boost::this_thread::sleep(boost::posix_time::seconds(1));
		bUpdate = false;
		bSendTimeStamp = false;
		modify_LocalAddr(0x8888);
		bModifyAddr = true;
		boost::this_thread::sleep(boost::posix_time::milliseconds(100));
		GlobalConfig::Zigbee_G.MyAddr = 0x8888;
		DataNodeUpdateFile = "";
	//	std::vector<RecvData>().swap(m_VecWaveData);
	//	WriteShortAddr2Zigbee(shortAddr);
	//	UpdateZigbeeInfoCtrl();
		GlobalConfig::EnterZigBeeWaveTransmittingFlag_G  = NO_ENTER_TRANSMITTING_STATUS;
		GlobalConfig::EnterZigBeeWaveTransmittingCnt_G   = 0;
		LOG_INFO("UpdateWirelessNode end");
}


int Uart::UpdateConfig(unsigned char* pDestShortAddr)
{
	char whereCon[64] = { 0 };
	char selCon[100]={0x00};
	sprintf(whereCon, "zigbeeShortAddr='%02x%02x'", pDestShortAddr[0],pDestShortAddr[1]);
	//std::string strUpdate = sql_ctl->GetData(T_SENSOR_INFO(TNAME), "UpdateFlag", whereCon);
	vec_t vecResultNode = sql_ctl->GetDataSingleLine(T_SENSOR_INFO(TNAME), "*", whereCon);
	if(vecResultNode.size() <= 0)
		return -1;
	if(vecResultNode[41] == "0")
	{
//			if(!strncmp(vecResult[1].c_str(),"3",1)){//zm5161
//				WriteTranTimeout2Zigbee(0x03);
//			}else if(!strncmp(vecResult[1].c_str(),"4",1)){//aw21
//				WriteTranTimeout2Zigbee(0x0A);
//			}
			print_info("UpdateConfig\n");
			LOG_INFO("UpdateConfig\n");
			bUpdateconfig = true;
			unsigned short localAddr = 0x9999;
			GlobalConfig::EnterZigBeeWaveTransmittingFlag_G = ENTER_TRANSMITTING_STATUS;
        	GlobalConfig::EnterZigBeeWaveTransmittingCnt_G  = 0;
		//	WriteShortAddr_DistAddr2Zigbee(localAddr,pDestShortAddr);//永久参数配置
			char tmpbuf[8] = {0x00};
			sprintf(tmpbuf,"%02x%02x",pDestShortAddr[0],pDestShortAddr[1]);
			m_strDestShortAddr = std::string(tmpbuf);
			//modify_distaddr_info(localAddr,"",pDestShortAddr);//临时参数配置
			GlobalConfig::Zigbee_G.MyAddr = 0x9999;
			boost::this_thread::sleep(boost::posix_time::milliseconds(500));
		vec_t vecResult;
		sprintf(selCon,"featureInterVal,waveInterVal,range,samplingRate,ACCSampleTime,startBrands,stopBrands,\
				envelopeBandPass,faultFrequency,timeStamp,viff,ZigbeePower,ZigbeeRetry,MeasurementID,NodeWaveSend");
		vecResult = sql_ctl->GetDataSingleLine(T_SENSOR_INFO(TNAME),selCon,whereCon);
		print_info("vecResult size = %d\n",vecResult.size());
		if(vecResult.size() < 1){
			return -1;
		}
		unsigned char UpdateData[100]={0x00};
		//帧头[3byte]	节点地址[2byte]	数据类型[1byte]	序号[1byte]	数据包[92byte]	CRC校验[1byte]
		UpdateData[0]=0xAA;
		UpdateData[1]=0x55;
		UpdateData[2]=0xAA;
		UpdateData[3]=pDestShortAddr[0];
		UpdateData[4]=pDestShortAddr[1];
		UpdateData[5]=0x22;
		UpdateData[6]=0x00;
		UpdateData[7]=0x01;
		UpdateData[8]=UINT16_LOW(atoi(vecResult[0].c_str()));
		UpdateData[9]=UINT16_HIGH(atoi(vecResult[1].c_str()));
		UpdateData[10]=UINT16_LOW(atoi(vecResult[1].c_str()));
		int y = 0;
		if(vecResultNode[17] == "01"){
			if(vecResult[3]=="3200"){
				y = 0;
			}else if(vecResult[3]=="6400"){
				y = 1;
			}else if(vecResult[3]=="12800"){
				y = 2;
			}else if(vecResult[3]=="25600"){
				y = 3;
			}
		}else if(vecResultNode[17] == "02"){
			if(vecResult[3]=="8000"){
				y = 0;
			}else if(vecResult[3]=="16000"){
				y = 1;
			}else if(vecResult[3]=="24000"){
				y = 2;
			}else if(vecResult[3]=="32000"){
				y = 3;
			}else if(vecResult[3]=="48000"){
				y = 4;
			}else if(vecResult[3]=="96000"){
				y = 5;
			}else if(vecResult[3]=="192000"){
				y = 6;
			}
		}
		UpdateData[18] = atoi(vecResult[11].c_str()) & 0xFF;;
		UpdateData[19] = atoi(vecResult[12].c_str()) & 0xFF;;
		int x = atoi(vecResult[2].c_str());
		UpdateData[21] = BUILD_UINT2(x,y);
		UpdateData[22] = atoi(vecResult[4].c_str()) & 0xFF;
		print_info("vecResult size = %s==%s==%s==%s=%s\n",vecResult[5].c_str(),vecResult[6].c_str(),vecResult[7].c_str(),vecResult[8].c_str(),vecResult[14].c_str());
		vector<string> vStart,vStop,vEnvelopeBandPass,vfaultFrequency,vNodeWaveSend;
		boost::split( vStart, vecResult[5], boost::is_any_of( "," ), boost::token_compress_on );
		boost::split( vStop, vecResult[6], boost::is_any_of( "," ), boost::token_compress_on );
		boost::split( vEnvelopeBandPass, vecResult[7], boost::is_any_of( "," ), boost::token_compress_on );
		boost::split( vfaultFrequency, vecResult[8], boost::is_any_of( "," ), boost::token_compress_on );
		if(vecResult[14] != "")
			boost::split( vNodeWaveSend, vecResult[14], boost::is_any_of( "," ), boost::token_compress_on );

		UpdateData[23] = UINT16_HIGH(atoi(vStart[0].c_str()));
		UpdateData[24] = UINT16_LOW(atoi(vStart[0].c_str()));
		UpdateData[25] = UINT16_HIGH(atoi(vStop[0].c_str()));
		UpdateData[26] = UINT16_LOW(atoi(vStop[0].c_str()));

		UpdateData[27] = UINT16_HIGH(atoi(vStart[1].c_str()));
		UpdateData[28] = UINT16_LOW(atoi(vStart[1].c_str()));
		UpdateData[29] = UINT16_HIGH(atoi(vStop[1].c_str()));
		UpdateData[30] = UINT16_LOW(atoi(vStop[1].c_str()));

		UpdateData[31] = UINT16_HIGH(atoi(vStart[2].c_str()));
		UpdateData[32] = UINT16_LOW(atoi(vStart[2].c_str()));
		UpdateData[33] = UINT16_HIGH(atoi(vStop[2].c_str()));
		UpdateData[34] = UINT16_LOW(atoi(vStop[2].c_str()));

		UpdateData[35] = UINT16_HIGH(atoi(vStart[3].c_str()));
		UpdateData[36] = UINT16_LOW(atoi(vStart[3].c_str()));
		UpdateData[37] = UINT16_HIGH(atoi(vStop[3].c_str()));
		UpdateData[38] = UINT16_LOW(atoi(vStop[3].c_str()));

		UpdateData[39] = UINT16_HIGH(atoi(vStart[4].c_str()));
		UpdateData[40] = UINT16_LOW(atoi(vStart[4].c_str()));
		UpdateData[41] = UINT16_HIGH(atoi(vStop[4].c_str()));
		UpdateData[42] = UINT16_LOW(atoi(vStop[4].c_str()));

		UpdateData[43] = UINT16_HIGH(atoi(vEnvelopeBandPass[0].c_str()));
		UpdateData[44] = UINT16_LOW(atoi(vEnvelopeBandPass[0].c_str()));
		UpdateData[45] = UINT16_HIGH(atoi(vEnvelopeBandPass[1].c_str()));
		UpdateData[46] = UINT16_LOW(atoi(vEnvelopeBandPass[1].c_str()));

		UpdateData[47] = UINT16_HIGH(atoi(vfaultFrequency[0].c_str()));
		UpdateData[48] = UINT16_LOW(atoi(vfaultFrequency[0].c_str()));
		UpdateData[49] = UINT16_HIGH(atoi(vfaultFrequency[1].c_str()));
		UpdateData[50] = UINT16_LOW(atoi(vfaultFrequency[1].c_str()));

		UpdateData[51] = UINT16_HIGH(atoi(vfaultFrequency[2].c_str()));
		UpdateData[52] = UINT16_LOW(atoi(vfaultFrequency[2].c_str()));
		UpdateData[53] = UINT16_HIGH(atoi(vfaultFrequency[3].c_str()));
		UpdateData[54] = UINT16_LOW(atoi(vfaultFrequency[3].c_str()));

		UpdateData[55] = UINT32_HIGH_1(atoi(vecResult[9].c_str()));
		UpdateData[56] = UINT32_HIGH_2(atoi(vecResult[9].c_str()));
		UpdateData[57] = UINT32_LOW_1(atoi(vecResult[9].c_str()));
		UpdateData[58] = UINT32_LOW_2(atoi(vecResult[9].c_str()));

		UpdateData[59] = (atoi(vecResult[10].c_str())) & 0xFF;
		
    	size_t bytesSize = strlen(vecResult[13].c_str()) / 2;
    	unsigned char* bytes = (unsigned char*)malloc(bytesSize);

    	if (hexStringToBytes(vecResult[13].c_str(), bytes, bytesSize) != 0) {
        	free(bytes);
    	}else{
			UpdateData[60] = bytes[0];
			UpdateData[61] = bytes[1];
			UpdateData[62] = bytes[2];
			UpdateData[63] = bytes[3];
			UpdateData[64] = bytes[4];
			UpdateData[65] = bytes[5];
			UpdateData[66] = bytes[6];
			UpdateData[67] = bytes[7];
		}
		unsigned char byte = 0;
		if(vNodeWaveSend.size() > 0){
			if (vNodeWaveSend[0] == "0")
			{
				Binary_Bit(&byte,0,0);
			}
			if (vNodeWaveSend[0] == "1")
			{
				Binary_Bit(&byte,0,1);
			}
			if (vNodeWaveSend[1] == "0")
			{
				Binary_Bit(&byte,1,0);
			}
			if (vNodeWaveSend[1] == "1")
			{
				Binary_Bit(&byte,1,1);
			}
			if (vNodeWaveSend[2] == "0")
			{
				Binary_Bit(&byte,2,0);
			}
			if (vNodeWaveSend[2] == "1")
			{
				Binary_Bit(&byte,2,1);
			}
		}
		UpdateData[68] = byte;
		free(bytes);
		unsigned char tmp1 = 0x00;
		for(int k = 0; k < 99;k++){
			tmp1 +=UpdateData[k];
		}
		UpdateData[99] = tmp1;
		tcflush(fd,TCIFLUSH);
		WriteToUart((const char*)UpdateData,100);
		int iRet = CheckZigbeeACK();
	 	if(iRet == 0){
			LOG_DEBUG("updataconfig ACK send success,shortAddr = %02x%02x\n",pDestShortAddr[0],pDestShortAddr[1]);
	 	}else{
			LOG_ERROR("updataconfig ACK send failed,shortAddr = %02x%02x\n",pDestShortAddr[0],pDestShortAddr[1]);
	 	}
		return 0;
	}else if(vecResultNode[41] == "-1"){

		bUpdateconfig = true;
		unsigned short localAddr = 0x9999;
		GlobalConfig::EnterZigBeeWaveTransmittingFlag_G = ENTER_TRANSMITTING_STATUS;
        GlobalConfig::EnterZigBeeWaveTransmittingCnt_G  = 0;
		string strName = sql_ctl->GetData(T_SENSOR_INFO(TNAME)," dataNodeName ",whereCon);

		unsigned char UpdateData[100]={0x00};
		//帧头[3byte]	节点地址[2byte]	数据类型[1byte]	序号[1byte]	数据包[92byte]	CRC校验[1byte]
		UpdateData[0]=0xAA;
		UpdateData[1]=0x55;
		UpdateData[2]=0xAA;
		UpdateData[3]=pDestShortAddr[0];
		UpdateData[4]=pDestShortAddr[1];
		UpdateData[5]=0x22;
		UpdateData[6]=0x00;
		UpdateData[7]=0x02;
		char hex[200]={0X00};
		stringToHex(strName.c_str(),hex);
		size_t bytesSize = strlen(hex) / 2;
    	unsigned char* bytes = (unsigned char*)malloc(bytesSize);

    	if (hexStringToBytes(hex, bytes, bytesSize) != 0) {
        	free(bytes);
    	}else{
			for (size_t i = 0; i < bytesSize; i++)
			{
				UpdateData[8 + i] = bytes[i];
			}
			free(bytes);
			unsigned char tmp1 = 0x00;
			for(int k = 0; k < 99;k++){
				tmp1 += UpdateData[k];
			}
			UpdateData[99] = tmp1;
			tcflush(fd,TCIFLUSH);
			WriteToUart((const char*)UpdateData,100);
			int iRet = CheckZigbeeACK();
	 		if(iRet == 0){
				LOG_DEBUG("updataname ACK send success,shortAddr = %02x%02x\n",pDestShortAddr[0],pDestShortAddr[1]);
	 		}else{
				LOG_ERROR("updataname ACK send failed,shortAddr = %02x%02x\n",pDestShortAddr[0],pDestShortAddr[1]);
	 		}
			return 0;
			
		}



	}else{
		return -1;
	}

}
int Uart::UpdateWirelessNodeTime(unsigned char* pDestShortAddr,int modifyaddr/*,int nodewaveindex,int nodetime,int nodeindex*/)
{
	if(modifyaddr)
		modify_DistAddr(pDestShortAddr);
	mssleep(10000);
	//print_info("nodewaveindex = %d,nodetime = %d,nodeindex = %d\n",nodewaveindex,nodetime,nodeindex);
	char  localtimestamp[32]={0x00};
    int millisecond = 0;

    string  rtcTime = GetRTC(localtimestamp,millisecond);
	LOG_INFO("ShortAddr  = %02x%02x,rtcTime = %s,localtimestamp = %s,millisecond = %d,bSendTimeStamp = %d \n",pDestShortAddr[0],pDestShortAddr[1],rtcTime.c_str(),localtimestamp,millisecond,bSendTimeStamp);
	//  struct timeval tv;
    // gettimeofday(&tv, NULL);
    // int millisecond = tv.tv_usec / 1000;

    // sprintf(localtimestamp, "%ld", tv.tv_sec);
   
	 unsigned char UpdateData[100]={0x00};
	 UpdateData[0]=0xAA;
	 UpdateData[1]=0x55;
	 UpdateData[2]=0xAA;
	 UpdateData[3]=pDestShortAddr[0];
	 UpdateData[4]=pDestShortAddr[1];
	 UpdateData[5]=0x23;
	 UpdateData[6]=0x00;
	 UpdateData[7]=0x00;
	 UpdateData[8]=UINT32_LOW_2(atol(localtimestamp));
	 UpdateData[9]=UINT32_LOW_1(atol(localtimestamp));
	 UpdateData[10]=UINT32_HIGH_2(atol(localtimestamp));
	 UpdateData[11]=UINT32_HIGH_1(atol(localtimestamp));
	 UpdateData[12]=UINT16_LOW(millisecond);
	 UpdateData[13]=UINT16_HIGH(millisecond);
	 //UpdateData[13]=UINT16_HIGH(nodetime);
	 //UpdateData[14]=UINT16_LOW(nodetime);
	 //UpdateData[15]=UINT16_LOW(nodewaveindex);
	 //UpdateData[16]=UINT16_LOW(nodeindex);
	 unsigned char tmp = 0x00;
	 for(int k = 0; k < 99;k++){
		 tmp += UpdateData[k];
	 }
	 UpdateData[99] = tmp;
	 WriteToUart((const char*)UpdateData,100);
	 int iRet = CheckZigbeeACK();
	 if(iRet == 0){
		LOG_DEBUG("NodeTime ACK send success,shortAddr = %02x%02x\n",pDestShortAddr[0],pDestShortAddr[1]);
	 }else{
		LOG_ERROR("NodeTime ACK send failed,shortAddr = %02x%02x\n",pDestShortAddr[0],pDestShortAddr[1]);
	 }
	 return iRet;
}
void Uart::DealRecvData(const char *pData)
{
    char buf[8];
    char shortAdd[8]={0x00};
    sprintf(buf, "%02d", pData[5]&0xFF);
    sprintf(shortAdd, "%02x%02x", pData[3]&0xFF,pData[4]&0xFF);
    unsigned short ushortAdd = BUILD_UINT16(pData[3]&0xFF,pData[4]&0xFF);
    int flag = atoi(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:特征值+长波形
        	//LOG_INFO("DealDataNodeFeature 06");
            DealDataNodeFeature(pData, 1);
        }
            break;
        case 32:{//升级

        	UpdateWirelessNode(ushortAdd);
        }
            break;
        case 7:{
        	DealDataNodeName(pData);
           }
          break;
        default:
            break;
    }
}

void Uart::DealDataNodeName(const char* pData)
{
	bSendTimeStamp = false;
	print_info("DealDataNodeName \n");
	string strTime = GetLocalTimeWithMs();
	//LOG_INFO("DealDataNodeName Time = %s\n",strTime.c_str());
	char szShortAdd[8]={0x00};
	char shortAdd[8]={0x00};
	char NodeName[64]={0x00};
	sprintf(szShortAdd, "%02x%02x", pData[3]&0xFF,pData[4]&0xFF);
	memcpy(NodeName,&pData[7],64);
	memcpy(shortAdd,&pData[3],2);
	char whereCon[64] = { 0 };
	char uplCon[200]={0x00};
	int iRet = -1;
	char nodeWaveSend[10]={0x00};
	
	UpdateWirelessNodeTime((unsigned char*)shortAdd,1);

	for(int i = 0; i < 64;i++){
		sprintf(&NodeName[i * 2], "%02X", pData[7 + i]&0xFF);
	}
	char MeasurementID[100]={0x00};
	sprintf(MeasurementID, "%02x%02x%02x%02x%02x%02x%02x%02x", pData[71], pData[72], pData[73], pData[74],
    pData[75], pData[76], pData[77],pData[78]);
	sprintf(nodeWaveSend,"%d,%d,%d",GET_BIT(pData[79], 0 ),GET_BIT(pData[79], 1 ),GET_BIT(pData[79], 2 ));
	char gbkNodeName[128]={0x00};
	sprintf(whereCon, "zigbeeShortAddr='%s'", szShortAdd);
	print_info("whereCon = %s\n",whereCon);
	array_t vecRes = sql_ctl->GetDataMultiLine(T_SENSOR_INFO(TNAME)," dataNodeNo, MeasurementID,hardVersion,softVersion",whereCon);
	if(vecRes.size() > 1){
		for(int i = 0; i < vecRes.size();i++){
			if(vecRes[i][1] != ""){
				char whereCon1[64] = { 0 };
				sprintf(whereCon1, " dataNodeNo='%s' ", vecRes[i][0].c_str());
				sql_ctl->DeleteTableData(T_SENSOR_INFO(TNAME), whereCon1);
				sql_ctl->DeleteTableData(T_DATA_INFO(TNAME), whereCon1);
        		sql_ctl->DeleteTableData(T_DATASTATIC_INFO(TNAME), whereCon1);
        		sql_ctl->DeleteTableData(T_DATANODE_TIME(TNAME), whereCon1);
				char szTableName[50]={0x00};
				sprintf(szTableName,"DROP TABLE t_data_%s",vecRes[i][0].c_str());
				sql_ctl->CreateTable(szTableName, 0);
				memset(szTableName,0x00,sizeof(szTableName));
				sprintf(szTableName,"DROP TABLE t_dataStatic_%s",vecRes[i][0].c_str());
				sql_ctl->CreateTable(szTableName, 0);
			}
		}	
	}
	string hardVersion = vecRes[0][2];
	string softVersion = vecRes[0][3];
	if((hardVersion == "3.0" && compareVersions(softVersion,"3.6") == -1) || 
		(hardVersion == "4.0" && compareVersions(softVersion,"4.6") == -1) || 
		(hardVersion == "1.0" && compareVersions(softVersion,"1.2") == -1)){
		memcpy(MeasurementID , vecRes[0][0].c_str(),sizeof(MeasurementID));
	}
	std::string strNodeName(NodeName);
	print_info("strNodeName = %s\n",strNodeName.c_str());
	solve(gbkNodeName,NodeName);
	print_info("gbkNodeName = %s\n",gbkNodeName);
	string utfNodeName = GBKToUTF8(gbkNodeName);
	print_info("NodeName = %s\n",NodeName);
	print_info("whereCon = %s\n",whereCon);
	sprintf(uplCon,"dataNodeName = '%s' , MeasurementID = '%s',NodeWaveSend = '%s'",gbkNodeName,MeasurementID,nodeWaveSend);
	iRet = sql_ctl->UpdateTableData(T_SENSOR_INFO(TNAME),uplCon,whereCon,0);
	string strData = sql_ctl->GetNodeConfigureInfor(whereCon);
	iRet = data_publish(strData.c_str(), GlobalConfig::Topic_G.mPubConfig.c_str());

}

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];//设备状态标志 1 byte
    DataNodeInfo dataNodeInfo;
    dataNodeInfo.EquipSta   = GET_BIT(chTemp, 2 );
    dataNodeInfo.TemTopFlag = GET_BIT(chTemp, 3 );
    dataNodeInfo.TemBotFlag = GET_BIT(chTemp , 4);
    dataNodeInfo.ZigbeeFlag = GET_BIT(chTemp , 5);
    dataNodeInfo.AccFlag = GET_BIT(chTemp ,6);
    dataNodeInfo.InitFlag = GET_BIT(chTemp ,7);

    sprintf(buf, "%02x%02x%02x%02x%02x%02x%02x%02x", pRecvData->Data[1], pRecvData->Data[2], pRecvData->Data[3], pRecvData->Data[4],
    pRecvData->Data[5], pRecvData->Data[6], pRecvData->Data[7],pRecvData->Data[8]);
    dataNodeInfo.ZigbeeLongAddr = std::string(buf);//Zigbee MAC 8 byte
    
    chTemp = pRecvData->Data[9];//硬件版本 1 byte
    memset(buf, 0, 32);
    sprintf(buf, "%.1f", 0.1*chTemp);
    dataNodeInfo.HardVersion = std::string(buf);

    chTemp = pRecvData->Data[10];//软件版本 1 byte
    memset(buf, 0, 32);
    //sprintf(buf, "%02x", chTemp);
	sprintf(buf, "%.1f", 0.1*chTemp);
    dataNodeInfo.SoftVersion = std::string(buf);

    memset(buf, 0, 32);
    sprintf(buf, "%d", BUILD_UINT32(pRecvData->Data[11], pRecvData->Data[12], pRecvData->Data[13], pRecvData->Data[14]));
    dataNodeInfo.BpNo = std::string(buf);//生产批号 4 byte

    memset(buf, 0, 32);
    sprintf(buf, "%d", BUILD_UINT32(pRecvData->Data[15], pRecvData->Data[16], pRecvData->Data[17], pRecvData->Data[18]));
    dataNodeInfo.SerialNo = std::string(buf);//生产序列号 4 byte

    memset(buf, 0, 32);
    sprintf(buf, "%d", BUILD_UINT32(pRecvData->Data[19], pRecvData->Data[20], pRecvData->Data[21], pRecvData->Data[22]));
    dataNodeInfo.FirstPowerTime = std::string(buf);//首次上电日期 4 byte

    //23 24 25 26     27 28 29 30    31 32 33 34   35 36   37 38=>序号13 无线信号强度

    memset(buf, 0, 32);
    sprintf(buf, "%d", BUILD_UINT32(pRecvData->Data[23], pRecvData->Data[24], pRecvData->Data[25], pRecvData->Data[26]));
    dataNodeInfo.WakeupTime = atoi(buf);//唤醒次数 4 byte
    printf("WakeupTime = %d\n",dataNodeInfo.WakeupTime);
    memset(buf, 0, 32);
    sprintf(buf, "%d", BUILD_UINT32(pRecvData->Data[27], pRecvData->Data[28], pRecvData->Data[29], pRecvData->Data[30]));
    dataNodeInfo.StaticTime = atoi(buf);//特征值发送次数 4 byte
    printf("StaticTime = %d\n",dataNodeInfo.StaticTime);
    memset(buf, 0, 32);
//    sprintf(buf, "%d", BUILD_UINT32(pRecvData->Data[31], pRecvData->Data[32], pRecvData->Data[33], pRecvData->Data[34]));

    dataNodeInfo.WaveTime = BUILD_UINT32(pRecvData->Data[31], pRecvData->Data[32], pRecvData->Data[33], pRecvData->Data[34]);//原始波形发送次数 4 byte

    memset(buf, 0, 32);
//    sprintf(buf, "%02x%02x", pRecvData->Data[35], pRecvData->Data[36]);
    dataNodeInfo.BateryV = BUILD_UINT16(pRecvData->Data[35],pRecvData->Data[36]);//电池电压 2 byte

    memset(buf, 0, 32);
    sprintf(buf, "%02x", pRecvData->Data[37]);
    dataNodeInfo.ProductNo = std::string(buf);//产品型号 1 byte

    // 获取 RSSI
    chTemp = pRecvData->Data[38];
	memset(buf, 0, 32);
	sprintf(buf, "%d", chTemp);
	dataNodeInfo.RSSI = atoi(buf); //无线信号强度 1 byte

    chTemp = pRecvData->Data[39];
    memset(buf, 0, 32);
    sprintf(buf, "%02x", chTemp);
    dataNodeInfo.ConfigFlag = ((0 == std::string(buf).compare("aa")) ? 1 : 0); //配置标志 1 byte

    chTemp = pRecvData->Data[40];
    memset(buf, 0, 32);
    sprintf(buf, "%d", chTemp);
	dataNodeInfo.FeatureInterVal = atoi(buf); //唤醒周期 1 byte
    memset(buf, 0, 32);
           // yxq
    sprintf(buf, "%u%u", pRecvData->Data[41],pRecvData->Data[42]);
    dataNodeInfo.WaveInterVal = atoi(buf);//原始波形发送周期 2 byte
    memset(buf, 0, 32);
    sprintf(buf, "%02x%02x", pRecvData->Data[43], pRecvData->Data[44]); //Zigbee PID 2 byte
    dataNodeInfo.ZigbeePanId = std::string(buf);

    chTemp = pRecvData->Data[45];
    memset(buf, 0, 32);
    sprintf(buf, "%d", chTemp);
    dataNodeInfo.ZigbeeChannel = atoi(buf);//Zigbee 信道 1 byte

    memset(buf, 0, 32);
    sprintf(buf, "%02x%02x", pRecvData->Data[46], pRecvData->Data[47]);//Zigbee 本地地址 2 byte

    dataNodeInfo.ZigbeeShortAddr = std::string(buf);
    unsigned char shortAddr[2] = {0x00};
    memcpy(shortAddr,(unsigned char*)&pRecvData->Data[46],2);
    modify_DistAddr(shortAddr);//修改目标地址
    string strTime = GetLocalTimeWithMs();
    //LOG_INFO("DealDataNodeInfo modify_DistAddr Time = %s\n",strTime.c_str());

    //LOG_INFO("ZigbeeShortAddr = %s,SoftVersion = %s\n",dataNodeInfo.ZigbeeShortAddr.c_str(),dataNodeInfo.SoftVersion.c_str());
    memset(buf, 0, 32);
    sprintf(buf, "%02x%02x", pRecvData->Data[48], pRecvData->Data[49]);//Zigbee 目标地址 2 byte
    dataNodeInfo.ZigbeeDesAddr = std::string(buf);
    //print_info("ZigbeeDesAddr = %s\n",buf);
    //50 51 52=》序号23 zigbee重试间隔

    memset(buf, 0, 32);
    sprintf(buf, "%02x", pRecvData->Data[50]);//Zigbee 发射功率 1 byte
    dataNodeInfo.ZigbeePower = atoi(buf);
    //print_info("ZigbeePower = %s\n",buf);

    memset(buf, 0, 32);
    sprintf(buf, "%d", BUILD_UINT16(00,pRecvData->Data[51]));//Zigbee   重试次数 1 byte
    dataNodeInfo.ZigbeeRetry = atoi(buf);
    //print_info("ZigbeeRetry = %s\n",buf);

    memset(buf, 0, 32);
    sprintf(buf, "%d", BUILD_UINT16(00,pRecvData->Data[52]));//Zigbee 重试间隔 1 byte
    dataNodeInfo.ZigbeeRetryGap = atoi(buf);
    //print_info("ZigbeeRetryGap = %s\n",buf);


	if(dataNodeInfo.ProductNo == "01"){
		chTemp = pRecvData->Data[53];
		unsigned char range = (chTemp >> 2) & 0x3;
		dataNodeInfo.Range = range;
		int SamplingRate = (chTemp & 0x3);
		print_info("SamplingRate = %d\n",SamplingRate);
		if(SamplingRate == 0){
			dataNodeInfo.SamplingRate = 3200;
		}else if(SamplingRate == 1){
			dataNodeInfo.SamplingRate = 6400;
		}else if(SamplingRate == 2){
			dataNodeInfo.SamplingRate = 12800;
		}else if(SamplingRate == 3){
			dataNodeInfo.SamplingRate = 25600;
		}
	}else if(dataNodeInfo.ProductNo == "02"){
		chTemp = pRecvData->Data[53];
		unsigned char range = (chTemp >> 3) & 0x7;
		dataNodeInfo.Range = range;
		int SamplingRate = (chTemp & 0x7);
		print_info("SamplingRate = %d\n",SamplingRate);
		if(SamplingRate == 0){
			dataNodeInfo.SamplingRate = 8000;
		}else if(SamplingRate == 1){
			dataNodeInfo.SamplingRate = 16000;
		}else if(SamplingRate == 2){
			dataNodeInfo.SamplingRate = 24000;
		}else if(SamplingRate == 3){
			dataNodeInfo.SamplingRate = 32000;
		}else if(SamplingRate == 4){
			dataNodeInfo.SamplingRate = 48000;
		}else if(SamplingRate == 5){
			dataNodeInfo.SamplingRate = 96000;
		}else if(SamplingRate == 6){
			dataNodeInfo.SamplingRate = 192000;
		}
	}
    // 54=》序号25 ACC采样时间
	memset(buf, 0, 32);
	sprintf(buf, "%u", pRecvData->Data[54]);//ACC 采样时间 1 byte
	dataNodeInfo.ACCSampleTime = atoi(buf);

    int iTemp = 0;
    //使用了55 56 59 60 63 64 67 68 71 72
    for (int i = 0; i < 5; i++) {
        memset(buf, 0, 32);
        sprintf(buf, "%02x%02x", pRecvData->Data[55 + i * 4], pRecvData->Data[55 + i * 4 + 1]);        
        iTemp = (int)strtol(buf, NULL, 16);

        if (0 == i) {
            dataNodeInfo.StartBrands = to_string(iTemp);
        } else {
            dataNodeInfo.StartBrands += ("," + to_string(iTemp));
        }
    }
    //使用了57 58    61 62 65 66  69 70  73 74
    for (int j = 0; j < 5; j++) {
        memset(buf, 0, 32);
        sprintf(buf, "%02x%02x", pRecvData->Data[57 + j * 4], pRecvData->Data[57 + j * 4 + 1]);        
        iTemp = (int)strtol(buf, NULL, 16);
        if (0 == j) {
            dataNodeInfo.StopBrands = to_string(iTemp);
        } else {
            dataNodeInfo.StopBrands += ("," + to_string(iTemp));
        }        
    }
    
    
    memset(buf, 0, 32);
    sprintf(buf, "%02x%02x", pRecvData->Data[75], pRecvData->Data[76]);        
    iTemp = (int)strtol(buf, NULL, 16);
    dataNodeInfo.EnvelopeBandPass = to_string(iTemp);


    memset(buf, 0, 32);
    sprintf(buf, "%02x%02x", pRecvData->Data[77], pRecvData->Data[78]);        
    iTemp = (int)strtol(buf, NULL, 16);
    dataNodeInfo.EnvelopeBandPass += ("," + to_string(iTemp));
    //使用了79 80 81 82 83 84 85 86
    for (int j = 0; j < 4; j++) {
        memset(buf, 0, 32);
        sprintf(buf, "%02x%02x", pRecvData->Data[79 + j * 2], pRecvData->Data[79 + j * 2 + 1]);      
        iTemp = (int)strtol(buf, NULL, 16);
        
        if (0 == j) {
            dataNodeInfo.FaultFrequency = to_string(iTemp);
        } else {
            dataNodeInfo.FaultFrequency += ("," + to_string(iTemp));
        }        
    }

    memset(buf, 0, 32);
    sprintf(buf, "%02x%02x%02x%02x", pRecvData->Data[87], pRecvData->Data[88], pRecvData->Data[89],pRecvData->Data[90]);
    long lTimeStamp = strtol(buf, NULL, 16);
    dataNodeInfo.ConfigDate = to_string(lTimeStamp);

    chTemp = pRecvData->Data[91];
	memset(buf, 0, 32);
	sprintf(buf, "%d", chTemp);
	dataNodeInfo.VIntegralFilterFrequency = atoi(buf);

    char whereCon[64] = {0};
    sprintf(whereCon, "dataNodeNo='%s'", dataNodeInfo.ZigbeeLongAddr.c_str());
    if (sql_ctl->GetTableRows(T_SENSOR_INFO(TNAME), whereCon) > 0) {

        char updateSql[1024] = { 0 };
		sprintf(updateSql, "  initFlag = '%d',accFlag = '%d',zigbeeFlag = '%d',temTopFlag = '%d',temBotFlag = '%d',equipSta = '%d',\
				hardVersion = '%s',softVersion = '%s',bpNo = '%s',serialNo = '%s',firstPowerTime = '%s',WakeupTime = '%d',\
				StaticTime = '%d',WaveTime = '%d',BateryV = '%d',ProductNo = '%s',configFlag = '%d',startBrands = '%s',\
				stopBrands = '%s',featureInterVal = '%u',waveInterVal = '%d',samplingRate = '%d',scope = '%s',range = '%d',envelopeBandPass = '%s',faultFrequency = '%s',\
				zigbeePanId = '%s',zigbeeChannel = '%d',zigbeeShortAddr = '%s',zigbeeLongAddr = '%s',zigbeeDesAddr = '%s',\
				ZigbeePower = '%d',ZigbeeRetry = '%d',ZigbeeRetryGap = '%d',ACCSampleTime = '%d',status = '%s',timeStamp = '%s',viff = '%d',RSSI = '0,%d',UpdateFlag = 1",
		dataNodeInfo.InitFlag, dataNodeInfo.AccFlag, dataNodeInfo.ZigbeeFlag, dataNodeInfo.TemTopFlag, dataNodeInfo.TemBotFlag,dataNodeInfo.EquipSta,\
		dataNodeInfo.HardVersion.c_str(), dataNodeInfo.SoftVersion.c_str(), dataNodeInfo.BpNo.c_str(), dataNodeInfo.SerialNo.c_str(), dataNodeInfo.FirstPowerTime.c_str(), dataNodeInfo.WakeupTime,\
		dataNodeInfo.StaticTime,dataNodeInfo.WaveTime,dataNodeInfo.BateryV,dataNodeInfo.ProductNo.c_str(),dataNodeInfo.ConfigFlag, dataNodeInfo.StartBrands.c_str(), \
		dataNodeInfo.StopBrands.c_str(), dataNodeInfo.FeatureInterVal, dataNodeInfo.WaveInterVal, dataNodeInfo.SamplingRate,"",dataNodeInfo.Range, dataNodeInfo.EnvelopeBandPass.c_str(), dataNodeInfo.FaultFrequency.c_str(),\
		dataNodeInfo.ZigbeePanId.c_str(), dataNodeInfo.ZigbeeChannel, dataNodeInfo.ZigbeeShortAddr.c_str(), dataNodeInfo.ZigbeeLongAddr.c_str(), dataNodeInfo.ZigbeeDesAddr.c_str(), \
		dataNodeInfo.ZigbeePower,dataNodeInfo.ZigbeeRetry,dataNodeInfo.ZigbeeRetryGap,dataNodeInfo.ACCSampleTime,"1", dataNodeInfo.ConfigDate.c_str(),dataNodeInfo.VIntegralFilterFrequency,dataNodeInfo.RSSI);
		sprintf(whereCon,"dataNodeNo = '%s'",dataNodeInfo.ZigbeeLongAddr.c_str());
		sql_ctl->UpdateTableData(T_SENSOR_INFO(TNAME), updateSql, whereCon);
    }else{
		char insertSql[1024] = { 0 };
		sprintf(insertSql, " '%s','%s','%d','%d','%d','%d','%d','%d',\
				'%s','%s','%s','%s','%s','%d',\
				'%d','%d','%d','%s','%d','%s',\
				'%s','%u','%d','%d','%s','%d', '%s', '%s',\
				'%s','%d','%s','%s','%s',\
				'%d','%d','%d','%d','%s','%s', '%d', '0,%d','1','0,0','','',''",
		dataNodeInfo.ZigbeeLongAddr.c_str(), " ", dataNodeInfo.InitFlag, dataNodeInfo.AccFlag, dataNodeInfo.ZigbeeFlag, dataNodeInfo.TemTopFlag, dataNodeInfo.TemBotFlag,dataNodeInfo.EquipSta,\
		dataNodeInfo.HardVersion.c_str(), dataNodeInfo.SoftVersion.c_str(), dataNodeInfo.BpNo.c_str(), dataNodeInfo.SerialNo.c_str(), dataNodeInfo.FirstPowerTime.c_str(), dataNodeInfo.WakeupTime,\
		dataNodeInfo.StaticTime,dataNodeInfo.WaveTime,dataNodeInfo.BateryV,dataNodeInfo.ProductNo.c_str(),dataNodeInfo.ConfigFlag, dataNodeInfo.StartBrands.c_str(), \
		dataNodeInfo.StopBrands.c_str(), dataNodeInfo.FeatureInterVal, dataNodeInfo.WaveInterVal, dataNodeInfo.SamplingRate,"",dataNodeInfo.Range, dataNodeInfo.EnvelopeBandPass.c_str(), dataNodeInfo.FaultFrequency.c_str(),\
		dataNodeInfo.ZigbeePanId.c_str(), dataNodeInfo.ZigbeeChannel, dataNodeInfo.ZigbeeShortAddr.c_str(), dataNodeInfo.ZigbeeLongAddr.c_str(), dataNodeInfo.ZigbeeDesAddr.c_str(), \
		dataNodeInfo.ZigbeePower,dataNodeInfo.ZigbeeRetry,dataNodeInfo.ZigbeeRetryGap,dataNodeInfo.ACCSampleTime,"1", dataNodeInfo.ConfigDate.c_str(),dataNodeInfo.VIntegralFilterFrequency,dataNodeInfo.RSSI);
		sql_ctl->InsertData(T_SENSOR_INFO(TNAME), insertSql);
    }
    char szTableName[50]={0x00};
    sprintf(szTableName,"t_data_%s",dataNodeInfo.ZigbeeLongAddr.c_str());
    sql_ctl->Createtable(szTableName);
    memset(szTableName,0x00,sizeof(szTableName));
    sprintf(szTableName,"t_dataStatic_%s",dataNodeInfo.ZigbeeLongAddr.c_str());
    sql_ctl->CreatedataStatictable(szTableName);
    Json::Value jsonVal;
    jsonVal.clear();   
    jsonVal["cmd"] = "26";

    Json::Value jsBody;
    jsBody["dataNodeGatewayNo"] = GlobalConfig::MacAddr_G;
    jsBody["dataNodeNo"] = dataNodeInfo.ZigbeeLongAddr;
    jsBody["type"] = "insert";

    Json::Value jsSensorData;
    jsSensorData["dataNodeNo"] = dataNodeInfo.ZigbeeLongAddr;
    jsSensorData["dataNodeName"] = "";
    jsSensorData["initFlag"] = dataNodeInfo.InitFlag;
    jsSensorData["accFlag"] = dataNodeInfo.AccFlag;
    jsSensorData["zigbeeFlag"] = dataNodeInfo.ZigbeeFlag;
    jsSensorData["temTopFlag"] = dataNodeInfo.TemTopFlag;
    jsSensorData["temBotFlag"] = dataNodeInfo.TemBotFlag;
    jsSensorData["equipsta"] = dataNodeInfo.EquipSta;
    jsSensorData["hardVersion"] = dataNodeInfo.HardVersion;
    jsSensorData["softVersion"] = dataNodeInfo.SoftVersion;
    jsSensorData["bpNo"] = dataNodeInfo.BpNo;
    jsSensorData["serialNo"] = dataNodeInfo.SerialNo;
    jsSensorData["firstPowerTime"] = dataNodeInfo.FirstPowerTime;
    jsSensorData["configFlag"] = dataNodeInfo.ConfigFlag;
    jsSensorData["startBrands"] = dataNodeInfo.StartBrands;
    jsSensorData["stopBrands"] = dataNodeInfo.StopBrands;
    jsSensorData["featureInterVal"] = dataNodeInfo.FeatureInterVal;
    jsSensorData["waveInterVal"] = dataNodeInfo.WaveInterVal;
    jsSensorData["samplingRate"] = dataNodeInfo.SamplingRate;
    jsSensorData["range"] = dataNodeInfo.Range;
    jsSensorData["envelopeBandPass"] = dataNodeInfo.EnvelopeBandPass;
    jsSensorData["faultFrequency"] = dataNodeInfo.FaultFrequency;
    jsSensorData["zigbeePanId"] = dataNodeInfo.ZigbeePanId;
    jsSensorData["zigbeeChannel"] = dataNodeInfo.ZigbeeChannel;
    jsSensorData["zigbeeAddr"] = dataNodeInfo.ZigbeeLongAddr;
    jsSensorData["zigbeeDesAddr"] = dataNodeInfo.ZigbeeDesAddr;
    jsSensorData["status"] = 1;
    jsSensorData["timeStamp"] = dataNodeInfo.ConfigDate;
    jsSensorData["VIntegralFilterFrequency"] = dataNodeInfo.VIntegralFilterFrequency;
    jsSensorData["RSSI"] = dataNodeInfo.RSSI;
    
    jsBody["dataNodeInfo"] = jsSensorData;

    Json::FastWriter showValue;
    std::string dataBody = showValue.write(jsBody);
    jsonVal["cmdBody"] = dataBody;
    std::string strCmd26 = showValue.write(jsonVal);
	//传感器发来的数据包中的表示设备信息的数据转化为json格式后，通过调用data_publish将数据传给mqttclient  ： Topic：wireless/cmd/60294D203717
    data_publish(strCmd26.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);

	if (g_mapCompress.find(dataNodeInfo.ZigbeeShortAddr) == g_mapCompress.end()){

		compressWaveChannel tempchannel;
        g_mapCompress.insert(std::make_pair(dataNodeInfo.ZigbeeShortAddr,tempchannel));	
		print_info("new Node,size = %d\n",g_mapCompress.size());
	}
	LOG_INFO("DealDataNodeInfo %s \n",dataNodeInfo.ZigbeeShortAddr.c_str());
}

void Uart::RecordBattery(string & strLongAddr,DataRecvStatic& dataStatic,string& nowTimetamp)
{
	char insertSql[1024] = { 0 };
    sprintf(insertSql, "'%s','%d','%f','%f','%f','%d','','','%s'",
      strLongAddr.c_str(), dataStatic.Dip, dataStatic.TemBot,dataStatic.nodeWorkTime,dataStatic.nodeSendTime, dataStatic.Voltage,nowTimetamp.c_str());
    sql_ctl->InsertData(T_BATTERY_INFO(TNAME), insertSql);
}
void Uart::DealDataNodeFeature(const char *pData, int flag)
{
	print_info("recv feature\n");
	RecvData * pRecvData = (RecvData *)pData;
	char whereCon[1024] = {0};
	char updateSql[1024] = { 0 };
	char buf[20] = {0x00};
	int nodeResend = 0,timing = 0;
	sprintf(buf, "%02x%02x", pRecvData->ShortAddr[0], pRecvData->ShortAddr[1]);
	if (flag == 1)
	{
		LOG_INFO("DealDataNodeFeature %02x%02x, %d\n",pRecvData->ShortAddr[0], pRecvData->ShortAddr[1],flag);
	}
	
	
	if (bSendTimeStamp)//波形处理中
		return;
	std::string strShortAddr = std::string(buf);
	print_info("zigbeeShortAddr='%s'\n", strShortAddr.c_str());
	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);
	vec_t vecResult = sql_ctl->GetDataSingleLine(T_SENSOR_INFO(TNAME)," softVersion,dataNodeNo,MeasurementID,ProductNo ",getLongAddr_sql);

	if (vecResult.size()  < 1) {
	   LOG_ERROR("device info not found  %02x%02x\n",pRecvData->ShortAddr[0], pRecvData->ShortAddr[1]);
	   print_error("device info not found\n");
	   return;
	}
	print_info("--------->the remote sensor short addr:%s strLongAddr=%s,softVersion = %s\n",buf,vecResult[1].c_str(),vecResult[0].c_str());

	std::string strLongAddr = vecResult[1];
	std::string strMeasurementID = vecResult[2];
	std::string strProductNo = vecResult[3];
    if (1 == flag) {
		
		tcflush(fd,TCIOFLUSH);
		
		if (!bSendTimeStamp)
		{
		 	bSendTimeStamp = true;
			modify_distaddr_info(0x9999,"",pRecvData->ShortAddr);//临时参数配置
			mssleep(10000);

			LOG_DEBUG("Zigbee Signal !\n");
			int Times = 0;
			mssleep(20000);
			while(Times < 3 ){
					getZigbeeSignal(pRecvData->ShortAddr);
					Times ++ ;
					mssleep(20000);
			}
			mssleep(10000);
		 	timing = UpdateWirelessNodeTime((unsigned char*)pRecvData->ShortAddr,0);
		}else
		{
			return;
		}
		
		//modify_distaddr_info(0x9999,"",pRecvData->ShortAddr);//临时参数配置
		
		GlobalConfig::ZigbeeInfo_G.MyAddr = "9999";
        GlobalConfig::Zigbee_G.MyAddr = 0x9999;
        string strTime = GetLocalTimeWithMs();
		
        m_strDestShortAddr = std::string(buf);
		
        bool isUpdate = ReadUpdatePackge(pRecvData->ShortAddr);
        bUpdatePre = isUpdate;
        if(!isUpdate){
        	int iRet = UpdateConfig(pRecvData->ShortAddr);
        }
        if(isUpdate || bUpdateconfig){

		}else{
        	LOG_DEBUG("DealDataNodeFeature %02x%02x,localaddr %02x%02x \n",pRecvData->ShortAddr[0], pRecvData->ShortAddr[1],\
        		UINT16_HIGH(GlobalConfig::Zigbee_G.MyAddr),UINT16_LOW(GlobalConfig::Zigbee_G.MyAddr));
        	// 进入传输原始数据状态，启动计数 60秒
        	GlobalConfig::EnterZigBeeWaveTransmittingFlag_G = ENTER_TRANSMITTING_STATUS;
        	GlobalConfig::EnterZigBeeWaveTransmittingCnt_G  = 0;
		}
		unsigned char compressChannel = pRecvData->Data[34];
		compressWaveChannel tempchannel;
		tempchannel.compressChannelX = GET_BIT(compressChannel ,0);
		tempchannel.compressChannelY = GET_BIT(compressChannel ,2);
		tempchannel.compressChannelZ = GET_BIT(compressChannel ,4);
		if (strProductNo == "01")
		{
			tempchannel.CountX = BUILD_UINT16(pRecvData->Data[55],pRecvData->Data[54]);
			tempchannel.CountY = BUILD_UINT16(pRecvData->Data[57],pRecvData->Data[56]);
			tempchannel.CountZ = BUILD_UINT16(pRecvData->Data[59],pRecvData->Data[58]);
		}else if (strProductNo == "02")
		{
			int CountX = 0;
			int CountY = 0;
			int CountZ = 0;
			unsigned char buffer[6]={0x00};

			memcpy(buffer,&pRecvData->Data[55],1);
			memcpy(buffer + 1,&pRecvData->Data[54],1);
			memcpy(buffer + 2,&pRecvData->Data[57],1);
			memcpy(buffer + 3,&pRecvData->Data[56],1);
			memcpy(buffer + 4,&pRecvData->Data[59],1);
			memcpy(buffer + 5,&pRecvData->Data[58],1);

			uint64_t packed_data = 0;
			for (int i = 0; i < 6; i++) {
        		packed_data |= (uint64_t)buffer[i] << (8 * (5 - i));  // 从高位开始组合
    		}
    		// 输出结果
    		printf("Resulting 48-bit integer: 0x%012llX\n", packed_data);
			// 提取 15 位的第一个数据
			tempchannel.CountX = (packed_data >> 33) & 0x7FFF;  // 提取最高的 15 位

    		// 提取 15 位的第二个数据
    		tempchannel.CountY = (packed_data >> 18) & 0x7FFF;  // 提取中间的 15 位
    		// 提取 18 位的第三个数据
    		tempchannel.CountZ = packed_data & 0x3FFFF;         // 提取最低的 18 位


		}
		
		g_mapCompress[strShortAddr] = tempchannel;

		print_info("count X = %d,Y = %d,Z = %d\n",tempchannel.CountX,tempchannel.CountY,tempchannel.CountZ);
		print_info("compress X = %d,Y = %d,Z = %d \n",tempchannel.compressChannelX,tempchannel.compressChannelY,tempchannel.compressChannelZ);
    }else{
    	 memset(whereCon,0x00,sizeof(whereCon));
    	 memset(updateSql,0x00,sizeof(updateSql));
    	 sprintf(whereCon, "zigbeeShortAddr='%s'", strShortAddr.c_str());
    	 sprintf(updateSql, " StaticTime = StaticTime + 1");
    	 sql_ctl->UpdateTableData(T_SENSOR_INFO(TNAME), updateSql, whereCon);
    	 //string strData = sql_ctl->GetNodeConfigureInfor(whereCon);
    	 //data_publish(strData.c_str(), GlobalConfig::Topic_G.mPubConfig.c_str());
    }

   if (vecResult[0] == "3.0" || vecResult[0] == "4.0"){
	   return;
   }
    long staticIndex = BUILD_UINT32(pRecvData->Data[29], pRecvData->Data[28],pRecvData->Data[27], pRecvData->Data[26]);

    print_info("staticIndex = %d\n",staticIndex);


    //LOG_INFO("staticIndex = %d\n",staticIndex);

    char localtimestamp[32] = { 0 };
    GetTimeNet(localtimestamp, 1);
    std::string nowTimetamp = std::string(localtimestamp);
    strTimetamp = nowTimetamp;
    
    int iTemp = 0;
	unsigned char highbit = 0;
	unsigned int lowbit = 0;
    float n = 0;

    DataRecvStatic dataStatic;
    memset(buf, 0, sizeof(buf));
    sprintf(buf, "%02x%02x", pRecvData->Data[5], pRecvData->Data[4]);
	print_blue("!!!!!!!!!!!!!!!!!!!!!!%s\n",buf);
    iTemp = (int)strtol(buf, NULL, 16);
    dataStatic.Dip = iTemp;

    int fTemp = 0;
    memset(buf, 0, sizeof(buf));
    sprintf(buf, "%02x%02x", pRecvData->Data[1], pRecvData->Data[0]);
	print_blue("@@@@@@@@@@@@@@@@@%s\n",buf);
    iTemp = (int)strtol(buf, NULL, 16);
    if (iTemp < 0x8000) {
          fTemp = iTemp ;
     } else {
          fTemp = (((~iTemp)&0xffff) + 1)* (-1);
     }
    dataStatic.TemBot = fTemp * 0.0625;//设备温度

    fTemp = 0;
    memset(buf, 0, sizeof(buf));
    sprintf(buf, "%02x%02x", pRecvData->Data[3], pRecvData->Data[2]);        
    iTemp = (int)strtol(buf, NULL, 16);
    if (iTemp < 0x8000) {
         fTemp = iTemp ;
    } else {
         fTemp = (((~iTemp)&0xffff) + 1) * (-1);
     }
    dataStatic.TemTop = fTemp * 0.0625;//环境温度

    memset(buf, 0, sizeof(buf));
    sprintf(buf, "%02x%02x", pRecvData->Data[7], pRecvData->Data[6]);        
    iTemp = (int)strtol(buf, NULL, 16);
    dataStatic.Voltage = iTemp;

	memset(buf, 0, sizeof(buf));
    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;
    }   
    dataStatic.nodeWorkTime = lowbit * n;

	print_info("workTime = %f\n",dataStatic.nodeWorkTime);

	memset(buf, 0, sizeof(buf));
    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;
    }   
    dataStatic.nodeSendTime = lowbit * n;
	print_info("SendTime = %f\n",dataStatic.nodeSendTime );
	dataStatic.nodeWorkTime = dataStatic.nodeWorkTime - dataStatic.nodeSendTime;

	RecordBattery(strLongAddr,dataStatic,nowTimetamp);
    
    char szTableName[50]={0x00},szTableNameStatic[50]={0x00},szTableNameData[50]={0x00};
    sprintf(szTableName,"t_dataStatic_%s",strLongAddr.c_str());
    memcpy(szTableNameStatic,szTableName,sizeof(szTableNameStatic));
    memset(whereCon,0x00,sizeof(whereCon));

    sprintf(whereCon,"StaticIndex = %d",staticIndex);
    int count = sql_ctl->GetTableRows(szTableNameStatic, whereCon);//避免重复数据
    sprintf(szTableNameData,"t_data_%s",strLongAddr.c_str());

    int count2 = sql_ctl->GetTableRows(szTableNameData, whereCon);
    if(count > 0 || count2 > 0){
    	char logInfo[20]={0x00};
    	sprintf(logInfo,"ShortAddr = %s,staticIndex = %d,staticData = %d, data = %d",strShortAddr.c_str(),staticIndex,count,count2);
    	LOG_DEBUG(logInfo);
    	return;
    }
    memset(whereCon,0x00,sizeof(whereCon));
    ///////////////////////////////////////////////////////////// for V2.0.3 upgrade to V3.0
    std::string strTmp = "";
    char sztmp[100]={0x00};
    strTmp = "name = '" + string(szTableNameStatic)+ "' and sql LIKE '%nodeResend%' ";

    int row = sql_ctl->GetTableRows(" sqlite_master ",strTmp.c_str());
    print_info("row1 = %d\n",row);
	if(row == 0){
		memset(sztmp,0x00,sizeof(sztmp));
		sprintf(sztmp,"ALTER TABLE %s ADD COLUMN 'nodeResend'",szTableNameStatic);
		sql_ctl->CreateTable(sztmp);
	}
	// strTmp = "name = '" + string(szTableNameStatic)+ "' and sql LIKE '%zigbeeRSSIType%' ";
	// row = sql_ctl->GetTableRows(" sqlite_master ",strTmp.c_str());
	// print_info("row2 = %d\n",row);
	// if(row == 0){
	// 	memset(sztmp,0x00,sizeof(sztmp));
	// 	sprintf(sztmp,"ALTER TABLE %s ADD COLUMN 'zigbeeRSSIType'",szTableNameStatic);
	// 	sql_ctl->CreateTable(sztmp);
	// }
	strTmp = "name = '" + string(szTableNameData)+ "' and sql LIKE '%nodeResend%' ";
	row = sql_ctl->GetTableRows(" sqlite_master ",strTmp.c_str());
	print_info("row2 = %d\n",row);
	if(row == 0){
		memset(sztmp,0x00,sizeof(sztmp));
		sprintf(sztmp,"ALTER TABLE %s ADD COLUMN 'nodeResend'",szTableNameData);
		sql_ctl->CreateTable(sztmp);
	}
	
    ////////////////////////////////////////////////////////////更换电池判断
	sprintf(whereCon," dataNodeNo = '%s' and StaticIndex > 0 order by StaticIndex desc LIMIT 0 , 1 ",strLongAddr.c_str());
    std::string strStaticIndex = sql_ctl->GetData(szTableNameStatic, "StaticIndex", whereCon);
    if(atol(strStaticIndex.c_str()) - staticIndex > 100){
    	sql_ctl->Deletetable(szTableNameStatic);
    	sql_ctl->Deletetable(szTableNameData);
		LOG_INFO("staticIndexNOW = %d,strStaticIndexLast = %s\n",staticIndex,strStaticIndex.c_str());
    }
    print_info("NowstaticIndex = %d,RecordStaticIndex = %d",staticIndex,atol(strStaticIndex.c_str()));
    if(staticIndex != atol(strStaticIndex.c_str() + 1) &&
    		strStaticIndex != "" &&
			staticIndex <  atol(strStaticIndex.c_str()))
    {
    	sprintf(whereCon,"StaticIndex = %d  order by StaticIndex desc LIMIT 0 , 1",atol(strStaticIndex.c_str()));
    	vec_t vecResult = sql_ctl->GetDataSingleLine(szTableNameStatic, "timeStamp,StaticIndex", whereCon);
		if(vecResult.size() > 0){
			memset(whereCon,0x00,sizeof(whereCon));
			sprintf(whereCon,"dataNodeNo = '%s'",strLongAddr.c_str());
			string staticInterval = sql_ctl->GetData(T_SENSOR_INFO(TNAME), "featureInterval", whereCon);
			long nNowTimetamp = atol(vecResult[0].c_str()) -  (atol(staticInterval.c_str()) * \
					(atol(vecResult[1].c_str()) - staticIndex)) * 60;
			char tmp[10]={0x00};
			sprintf(tmp,"%ld",nNowTimetamp);
			nowTimetamp = string(tmp);
			nodeResend = 1;
		}
    }
    print_info("nowTimetamp = %s",nowTimetamp.c_str());
    // save dataStatic of 7 days
    char selectCon[128] = { 0 };
    sprintf(selectCon, "channelID='%s'  ORDER BY timeStamp ASC  LIMIT 0,1",(strMeasurementID + "-S").c_str());
    std::string  strTime = sql_ctl->GetData(szTableName, "timeStamp", selectCon);
	sprintf(whereCon,"channelID='%s' ",(strMeasurementID + "-S").c_str());
    int Count = sql_ctl->GetTableRows(szTableName, whereCon);
    if(Count == -1){
    	sql_ctl->CreatedataStatictable(szTableName);
    }
    print_info("strLongAddr = %s,strTime = %s\n",strLongAddr.c_str(),strTime.c_str());
    long lTime = atol(nowTimetamp.c_str())-atol(strTime.c_str());
    print_info("lTime = %d,OneWeek = %d\n",lTime,OneWeek);

    print_info("dataStatic.TemTop : %f dataStatic.TemBot : %f dataStatic.Dip :%d dataStatic.Voltage : %d\n", dataStatic.TemTop\
    , dataStatic.TemBot, dataStatic.Dip, dataStatic.Voltage);

    sprintf(updateSql, "temTop='%f',temBot='%f',dip='%d',voltage='%d',timeStamp='%s',StaticIndex = %d, nodeResend = %d,zigbeeSignal = '',zigbeeSignalNode = '',statisticType = '%d',timing = '%d' ",\
            dataStatic.TemTop, dataStatic.TemBot, dataStatic.Dip, dataStatic.Voltage, nowTimetamp.c_str(),staticIndex,nodeResend,flag,timing);
    sprintf(whereCon, "channelID='%s' ", (strMeasurementID + "-S").c_str());
    if ( /*0 == sql_ctl->GetTableRows(T_DATASTATIC_INFO(TNAME), whereCon)*/ (Count * 3 < SAVE_COUNT &&  lTime < OneWeek ) || strTime.size() == 0 ) {
        print_info("insert static data to sql\n");
        char insertSql[1024] = { 0 };
        sprintf(insertSql, "'%s','%s','%f','%f','%d','%d','',%d,'%s','1',%d,'','%d','%d'",
                        strLongAddr.c_str(), (strMeasurementID + "-S").c_str(), dataStatic.TemTop, dataStatic.TemBot, dataStatic.Dip, dataStatic.Voltage, staticIndex,nowTimetamp.c_str(),nodeResend,flag,timing);
        sql_ctl->InsertData(szTableName, insertSql);

        if(0 == sql_ctl->GetTableRows(T_DATASTATIC_INFO(TNAME), whereCon)){ // First Connect
			char insertSql[1024] = { 0 };
        	sprintf(insertSql, "'%s','%s','%f','%f','%d','%d','',%d,'%s','1',%d",
                        strLongAddr.c_str(), (strMeasurementID + "-S").c_str(), dataStatic.TemTop, dataStatic.TemBot, dataStatic.Dip, dataStatic.Voltage, staticIndex,nowTimetamp.c_str(),nodeResend);
        	sql_ctl->InsertData(T_DATASTATIC_INFO(TNAME), insertSql);
        	sql_ctl->CalculateBattery();
        }
        else{
			memset(updateSql,0x00,sizeof(updateSql));
			sprintf(updateSql, "temTop='%f',temBot='%f',dip='%d',voltage='%d',timeStamp='%s',StaticIndex = %d ",\
            dataStatic.TemTop, dataStatic.TemBot, dataStatic.Dip, dataStatic.Voltage, nowTimetamp.c_str(),staticIndex);
        	sql_ctl->UpdateTableData(T_DATASTATIC_INFO(TNAME), updateSql, whereCon);
		}
    } else {
    	memset(whereCon,0x00,sizeof(whereCon));
    	sprintf(whereCon, "channelID='%s'  and timeStamp = '%s'", (strMeasurementID + "-S").c_str(),strTime.c_str());
        print_info("update static data to sql\n");
        sql_ctl->UpdateTableData(szTableName, updateSql, whereCon);
        memset(whereCon,0x00,sizeof(whereCon));
        sprintf(whereCon, "channelID='%s' ", (strMeasurementID + "-S").c_str());
		memset(updateSql,0x00,sizeof(updateSql));
		sprintf(updateSql, "temTop='%f',temBot='%f',dip='%d',voltage='%d',timeStamp='%s',StaticIndex = %d ",\
        dataStatic.TemTop, dataStatic.TemBot, dataStatic.Dip, dataStatic.Voltage, nowTimetamp.c_str(),staticIndex);
        sql_ctl->UpdateTableData(T_DATASTATIC_INFO(TNAME), updateSql, whereCon);
    }
    memset(szTableName,0x00,sizeof(szTableName));
    sprintf(szTableName,"t_data_%s",strLongAddr.c_str());
    if(Count == -1){
        sql_ctl->Createtable(szTableName);
     }
    DataRecvDym dataDymX;
    memset(buf, 0, sizeof(buf));
    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, sizeof(buf));
    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, sizeof(buf));
    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, sizeof(buf));
    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, sizeof(buf));
    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, sizeof(buf));
    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, sizeof(buf));
    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, sizeof(buf));
    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, sizeof(buf));
    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, sizeof(buf));
//    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;

    dataDymX.EnvelopEnergy = 0;

    memset(buf, 0, sizeof(buf));
//    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;

    dataDymX.Phase1 = 0;

    memset(buf, 0, sizeof(buf));
//    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 = 0;

    memset(buf, 0, sizeof(buf));

    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 = 0;

    memset(buf, 0, sizeof(buf));
    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 = 0;

    memset(whereCon, 0, 1024);
    sprintf(whereCon, "channelID='%s' ", (strMeasurementID + "-X").c_str());
    memset(updateSql, 0, 1024);
    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',StaticIndex = %d,nodeResend = %d ",\
    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(),staticIndex,nodeResend);
    if ( /*0 == sql_ctl->GetTableRows(T_DATA_INFO(TNAME), whereCon)*/(Count * 3 < SAVE_COUNT &&  lTime < OneWeek ) || strTime.size() == 0) {//1 week
        char insertSql[1024] = { 0 };
        memset(insertSql,0x00,sizeof(insertSql));
        sprintf(insertSql, "'%s','%s','%f','%f','%f','%f','%f','%f','%f','%f','%f','%f','%f','%f','%f','%f',%d,'%s','1',%d",
        strLongAddr.c_str(), (strMeasurementID + "-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, staticIndex,nowTimetamp.c_str(),nodeResend);
        sql_ctl->InsertData(szTableName, insertSql);

        if(0 == sql_ctl->GetTableRows(T_DATA_INFO(TNAME), whereCon))
        	sql_ctl->InsertData(T_DATA_INFO(TNAME), insertSql);
        else
        	sql_ctl->UpdateTableData(T_DATA_INFO(TNAME), updateSql, whereCon);
    } else {
    	memset(whereCon,0x00,sizeof(whereCon));
    	sprintf(whereCon, "channelID='%s' and timeStamp = '%s'", (strMeasurementID + "-X").c_str(),strTime.c_str());
//    	sprintf(whereCon, "channelID='%s' and sendMsg = '1' ", (strLongAddr + "-X").c_str());
    	sql_ctl->UpdateTableData(szTableName, updateSql, whereCon);
    	memset(whereCon,0x00,sizeof(whereCon));
    	sprintf(whereCon, "channelID='%s' ", (strMeasurementID + "-X").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(), (strMeasurementID + "-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"] = strMeasurementID;
    valNodeFeature["ChannelId"] = strMeasurementID + "-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, sizeof(buf));
    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, sizeof(buf));
    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, sizeof(buf));
    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, sizeof(buf));
    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, sizeof(buf));
    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, sizeof(buf));
    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, sizeof(buf));
    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, sizeof(buf));
    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, sizeof(buf));
    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, sizeof(buf));
//    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;

    dataDymY.EnvelopEnergy = 0;

    memset(buf, 0, sizeof(buf));
//    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 = 0;

    memset(buf, 0, sizeof(buf));
//    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 = 0;

    memset(buf, 0, sizeof(buf));
//    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 = 0;

    memset(buf, 0, sizeof(buf));
//    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 = 0;

    memset(whereCon, 0, 1024);
    sprintf(whereCon, "channelID='%s' ", (strMeasurementID + "-Y").c_str());
    memset(updateSql, 0, 1024);
    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',StaticIndex = %d,nodeResend = %d ",\
    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(),staticIndex,nodeResend);
    if ( /*0 == sql_ctl->GetTableRows(T_DATA_INFO(TNAME), whereCon)*/ (Count * 3 < SAVE_COUNT &&  lTime < OneWeek ) || strTime.size() == 0) {
        char insertSql[1024] = { 0 };
        memset(insertSql,0x00,sizeof(insertSql));
        sprintf(insertSql, "'%s','%s','%f','%f','%f','%f','%f','%f','%f','%f','%f','%f','%f','%f','%f','%f',%d,'%s','1',%d",
        strLongAddr.c_str(), (strMeasurementID + "-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,staticIndex, nowTimetamp.c_str(),nodeResend);
        sql_ctl->InsertData(szTableName, insertSql);

        if(0 == sql_ctl->GetTableRows(T_DATA_INFO(TNAME), whereCon))
        	sql_ctl->InsertData(T_DATA_INFO(TNAME), insertSql);
        else
        	sql_ctl->UpdateTableData(T_DATA_INFO(TNAME), updateSql, whereCon);
    } else {

        memset(whereCon,0x00,sizeof(whereCon));
        sprintf(whereCon, "channelID='%s' and timeStamp = '%s'", (strMeasurementID + "-Y").c_str(),strTime.c_str());
//        sprintf(whereCon, "channelID='%s' and sendMsg = '1' ", (strLongAddr + "-Y").c_str());
        sql_ctl->UpdateTableData(szTableName, updateSql, whereCon);
        memset(whereCon,0x00,sizeof(whereCon));
        sprintf(whereCon, "channelID='%s' ", (strMeasurementID + "-Y").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(), (strMeasurementID + "-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"] = strMeasurementID;
     valNodeFeature["ChannelId"] = strMeasurementID + "-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, sizeof(buf));
    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, sizeof(buf));
    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, sizeof(buf));
    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, sizeof(buf));
    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, sizeof(buf));
    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, sizeof(buf));
    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, sizeof(buf));
    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, sizeof(buf));
    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, sizeof(buf));
    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, sizeof(buf));
    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, sizeof(buf));
    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, sizeof(buf));
    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, sizeof(buf));
    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;

    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, 1024);
    sprintf(whereCon, "channelID='%s' ", (strMeasurementID + "-Z").c_str());
    memset(updateSql, 0, 1024);
	
    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',StaticIndex = %d,nodeResend = %d ",\
    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(),staticIndex,nodeResend);
    if ( /*0 == sql_ctl->GetTableRows(T_DATA_INFO(TNAME), whereCon)*/ Count *3 < SAVE_COUNT && (lTime < OneWeek || strTime.size() == 0)) {
        char insertSql[1024] = { 0 };
        memset(insertSql,0x00,sizeof(insertSql));
        sprintf(insertSql, "'%s','%s','%f','%f','%f','%f','%f','%f','%f','%f','%f','%f','%f','%f','%f','%f',%d,'%s','1',%d",
        strLongAddr.c_str(), (strMeasurementID + "-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, staticIndex,nowTimetamp.c_str(),nodeResend);
        sql_ctl->InsertData(szTableName, insertSql);

        if(0 == sql_ctl->GetTableRows(T_DATA_INFO(TNAME), whereCon))
        	sql_ctl->InsertData(T_DATA_INFO(TNAME), insertSql);
        else
        	sql_ctl->UpdateTableData(T_DATA_INFO(TNAME), updateSql, whereCon);
    } else {

        memset(whereCon,0x00,sizeof(whereCon));
        sprintf(whereCon, "channelID='%s' and timeStamp = '%s'", (strMeasurementID + "-Z").c_str(),strTime.c_str());
//        sprintf(whereCon, "channelID='%s' and sendMsg = '1'", (strLongAddr + "-Z").c_str());
        sql_ctl->UpdateTableData(szTableName, updateSql, whereCon);
        memset(whereCon,0x00,sizeof(whereCon));
        sprintf(whereCon, "channelID='%s' ", (strMeasurementID + "-Z").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(), (strMeasurementID + "-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());

    memset(whereCon,0x00,sizeof(whereCon));
    sprintf(whereCon, "dataNodeNo='%s'", strLongAddr.c_str());
    sql_ctl->UpdateTableData(T_SENSOR_INFO(TNAME), "status='1'", whereCon);
    //string strData = sql_ctl->GetNodeConfigureInfor(whereCon);
    //data_publish(strData.c_str(), GlobalConfig::Topic_G.mPubConfig.c_str());
    //无线传感器Z信息
    valNodeFeature["dataNodeNo"] = strMeasurementID;
    valNodeFeature["ChannelId"] = strMeasurementID + "-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);

    memset(whereCon, 0, 1024);
    sprintf(whereCon, "dataNodeNo='%s'", strLongAddr.c_str());

    string strBattery = sql_ctl->GetData(T_SENSOR_INFO(TNAME),"batteryPower",whereCon);
    vector<string> vBattery;
    vBattery.push_back("0");
    vBattery.push_back("0");
    if(strBattery.length() > 0){

    	boost::split( vBattery, strBattery, boost::is_any_of( "," ), boost::token_compress_on );
    }

    //无线传感器信息
    Json::Value root;
    Json::Value valdatastatic;
	valdatastatic["TemperatureTop"] = dataStatic.TemTop;
    valdatastatic["TemperatureBot"] = dataStatic.TemBot;
	valdatastatic["WorkTime"] = dataStatic.nodeWorkTime;
	valdatastatic["SendTime"] = dataStatic.nodeSendTime;
    valdatastatic["Dip"] = dataStatic.Dip;
    valdatastatic["Voltage"] = dataStatic.Voltage;
    valdatastatic["ChannelType"] = "STATUS";
    valdatastatic["ChannelId"] = strMeasurementID + "-S";
    valdatastatic["TimeStamp"] = nowTimetamp;
    valdatastatic["bateryProportion"] = atof(vBattery[1].c_str())/atof(vBattery[0].c_str());
    valdatastatic["batteryRemainDay"] = atof(vBattery[1].c_str());
    valdatastatic["dataNodeNo"] = strMeasurementID;
    valNodeData.append(valdatastatic);

    root["data"] = valNodeData;
    root["TimeStamp"] = nowTimetamp;
    root["dataNodeNo"] = strMeasurementID;
    root["dataNodeGatewayNo"] = GlobalConfig::MacAddr_G;
    Json::FastWriter featureValue;
    std::string strstatisticData = featureValue.write(root);
    //传感器发来的数据包中的表示设备信息的数据转化为json格式后，通过调用data_publish将数据传给mqttclient  ： Topic：wireless/cmd/60294D203717
     int iRet = data_publish(strstatisticData.c_str(), GlobalConfig::Topic_G.mPubData.c_str());
     print_info("dataNodeNo = '%s' and TimeStamp = '%s',MQTT ret = %d\n",strLongAddr.c_str(),nowTimetamp.c_str(),iRet);
     if(iRet != 0){
    	 char updateSql[1024] = { 0 };
    	 memset(whereCon, 0, 64);
    	 sprintf(whereCon, "dataNodeNo = '%s' and TimeStamp = '%s'", strLongAddr.c_str(),nowTimetamp.c_str());
    	 memcpy(updateSql, "sendMsg='0'",sizeof(updateSql));
    	 sql_ctl->UpdateTableData(szTableNameStatic, updateSql, whereCon);
    	 sql_ctl->UpdateTableData(szTableNameData, updateSql, whereCon);
     }
    //综上代码，把静态数据，x y z轴的特征值存放到sql数据库中（如果数据原来不存在，则插入新数据；如果存在，则更新数据）

    print_info("Dip : %d TemBot : %f TemBot : %f Voltage : %d\n", dataStatic.Dip, dataStatic.TemBot, dataStatic.TemTop, dataStatic.Voltage);
    
    memset(selectCon,0x00,sizeof(selectCon));
    sprintf(selectCon, "zigbeeSignal <> '' ORDER BY timeStamp desc  LIMIT 0,1");
    strTime = sql_ctl->GetData(szTableNameStatic, "timeStamp", selectCon);
    
	if (flag == 1)
	{
		LOG_INFO("DealDataNodeFeature end %02x%02x\n",pRecvData->ShortAddr[0], pRecvData->ShortAddr[1]);
	}
	
}

void Uart::DealDataNodeWave(const char *pData,int comand)
{
    //print_info("recv wave\n");
    RecvData * pRecvData = (RecvData *)pData;
	if (m_waveTrans)
	{
		if (comand == 3)
		{
			VecWaveDataX.push_back(*pRecvData);
		}else if(comand == 4){
			VecWaveDataY.push_back(*pRecvData);
		}else if(comand == 5){
			VecWaveDataZ.push_back(*pRecvData);
		}
	}else{
		if (comand == 3)
		{
			g_VecWaveDataX[m_waveCountX] = *pRecvData;
			m_waveCountX++;
		}else if(comand == 4){
			g_VecWaveDataY[m_waveCountY] = *pRecvData;
			m_waveCountY++;
		}else if(comand == 5){
			g_VecWaveDataZ[m_waveCountZ] = *pRecvData;
			m_waveCountZ++;
		}
	}
    //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) {
//         	sleep(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;
//             offSize = 0;
// 			GlobalConfig::EnterZigBeeWaveTransmittingFlag_G = NO_ENTER_TRANSMITTING_STATUS;
// 			GlobalConfig::EnterZigBeeWaveTransmittingCnt_G  = 0;
// 			// 准备重新恢复到 8888 PanID，正常接收特征数据
// 			mPackgeIndex = -1;
// 			//WriteLocalAddr(0x8888);
// 			//GlobalConfig::Zigbee_G.MyAddr = 0x8888;

// //			WriteShortAddr2Zigbee(0x8888);
// //			UpdateZigbeeInfoCtrl();

//         } else { 
//             print_info("NO! The time difference is less than 3,nowTimeStamp : %ld  m_TimeStamp : %ld\n", nowTimeStamp, m_TimeStamp); 
//         }
		DealWave();
		sleep(1);
    }  
	
}
std::vector<float> Uart::DealData(int iChannel,float coe,int sampleRate,int ACCSampleTime,string strProduct)
{

	int waveCount = 0 ;
	unsigned char data[1024*100]={0x00};
	unsigned char outdata[1024*100]={0x00};
	unsigned char dealdata[1024*100]={0x00};
	long unsigned int new_len = 0,deallen = 0;
	int compress = 0,count = 0;
	long iTemp = 0;
	char buf[8] = {0x00};
	std::vector<float> vecData;
	print_info("data1 = %02x\n",g_VecWaveDataX[0].Data[0]);
	print_info("data2 = %02x\n",g_VecWaveDataY[0].Data[0]);
	print_info("data3 = %02x\n",g_VecWaveDataZ[0].Data[0]);
	size_t j = 0;
	std::string strShortAddr = "";
	if (iChannel == 3)
	{
		if (VecWaveDataX.size() > 0 )
		{
			g_VecWaveDataX.assign(VecWaveDataX.begin(), VecWaveDataX.end()); 
			waveCount = VecWaveDataX.size();
		}
		waveCount = m_waveCountX;
		for (; j < waveCount; j++)
		{
			RecvData recvData = g_VecWaveDataX[j];
			memcpy(data + j * 92 ,recvData.Data,92);
		}
		memset(buf,0x00,sizeof(buf));
		sprintf(buf, "%02x%02x", g_VecWaveDataX[0].ShortAddr[0], g_VecWaveDataX[0].ShortAddr[1]);
		strShortAddr = std::string(buf);
		compress = g_mapCompress[strShortAddr].compressChannelX;
		count = g_mapCompress[strShortAddr].CountX;
	}
	if (iChannel == 4)
	{
		if (VecWaveDataY.size() > 0 )
		{
			g_VecWaveDataY.assign(VecWaveDataY.begin(), VecWaveDataY.end()); 
			waveCount = VecWaveDataY.size();
		}
		waveCount = m_waveCountY;
		for (; j < waveCount; j++)
		{
			RecvData recvData = g_VecWaveDataY[j];
			memcpy(data + j * 92 ,recvData.Data,92);
		}
		memset(buf,0x00,sizeof(buf));
		sprintf(buf, "%02x%02x", g_VecWaveDataY[0].ShortAddr[0], g_VecWaveDataY[0].ShortAddr[1]);
		strShortAddr = std::string(buf);
		compress = g_mapCompress[strShortAddr].compressChannelY;
		count = g_mapCompress[strShortAddr].CountY;
	}
	if (iChannel == 5)
	{
		if (VecWaveDataZ.size() > 0 )
		{
			g_VecWaveDataZ.assign(VecWaveDataZ.begin(), VecWaveDataZ.end()); 
			waveCount = VecWaveDataZ.size();
		}
		waveCount = m_waveCountZ;
		for (; j < waveCount; j++)
		{
			RecvData recvData = g_VecWaveDataZ[j];
			memcpy(data + j * 92 ,recvData.Data,92);
		}
		memset(buf,0x00,sizeof(buf));
		sprintf(buf, "%02x%02x", g_VecWaveDataZ[0].ShortAddr[0], g_VecWaveDataZ[0].ShortAddr[1]);
		strShortAddr = std::string(buf);
		compress = g_mapCompress[strShortAddr].compressChannelZ;
		count = g_mapCompress[strShortAddr].CountZ;
	}
	print_info("len = %d,data = %02x,iChannel = %d,compress = %d,count = %d\n",j,data[0],iChannel,compress,count);
	if(j * 92 < count)
		return vecData;
	
	if(compress){
		print_info("iChannel = %d,compress = %d\n",iChannel,compress);
		int r = lzo1x_decompress(data,count,outdata,&new_len,NULL);
		print_info("lzo1x_decompress end\n");
    	if (r == LZO_E_OK ){
        	printf("decompressed %lu bytes back into %lu bytes\n",
            (unsigned long) j * 92, (unsigned long) new_len);
			LOG_INFO("iChannel = %d ,ShortAddr = %s decompressed %lu bytes back into %lu bytes\n",iChannel,strShortAddr.c_str(),
            (unsigned long) j * 92, (unsigned long) new_len);
		}
    	else
    	{
			/* this should NEVER happen */
			printf("internal error - decompression failed: %d\n", r);
			LOG_ERROR("internal error - decompression failed: %d,channel = %d,ShortAddr = %s\n", r,iChannel,strShortAddr.c_str());
			return vecData;
		}
		memcpy(dealdata,outdata,new_len);
		deallen = new_len;
	}else{
		memcpy(dealdata,data,j * 92);
		deallen = j * 92;
	}
	print_info("len = %d,dealdata = %02x\n",deallen,dealdata[0]);
	for (int i = 0; i < deallen; i++) {
		float fTemp = 0.0;
		memset(buf, 0, 8);
		sprintf(buf, "%02x%02x", dealdata[2*i+1],dealdata[i*2]);
		iTemp = strtol(buf, NULL, 16);
		if (iTemp < 0x8000) {
			fTemp = iTemp * coe * 9.8; //convert to m/s2
		} else {
			fTemp = (((~iTemp)&0xffff) + 1) * - coe * 9.8; //convert to m/s2
		}
		vecData.push_back(fTemp);
		if(strProduct == "01"){
			//print_blue("vecData.size() = %d,sampleRate * ACCSampleTime = %d,iChannel = %d\n",vecData.size(),sampleRate * ACCSampleTime,iChannel);
			if(vecData.size() == sampleRate * ACCSampleTime && iChannel == 3 ){//过滤数据包结尾空数据
				print_blue("%d vecData.size() == %d,sampleRate * ACCSampleTime = %d\n",iChannel,vecData.size(),sampleRate * ACCSampleTime);
				break;
			}
			if(vecData.size() == sampleRate * ACCSampleTime && iChannel == 4 ){//过滤数据包结尾空数据
				print_blue("%d vecData.size() == %d,sampleRate * ACCSampleTime = %d\n",iChannel,vecData.size(),sampleRate * ACCSampleTime);
				break;
			}
			if(vecData.size() == sampleRate * ACCSampleTime && iChannel == 5 ){//过滤数据包结尾空数据
				print_blue("%d vecData.size() == %d,sampleRate * ACCSampleTime = %d\n",iChannel,vecData.size(),sampleRate * ACCSampleTime);
				
				break;
			}
		}else if(strProduct == "02"){
			if(vecData.size() == 8192 && iChannel == 3 ){//过滤数据包结尾空数据
				break;
			}
			if(vecData.size() == 8192 && iChannel == 4 ){//过滤数据包结尾空数据
				break;
			}
			if(vecData.size() == sampleRate * ACCSampleTime && iChannel == 5 ){//过滤数据包结尾空数据
				break;
			}
		}
	}
	return vecData;
}
void Uart::DealWave()
{
	//LOG_DEBUG("begin deal Wave data !\n");
	//print_blue("wave data size is(m_VecWaveData.size) : %d\n",m_VecWaveData.size());
    std::string strShortAddr = "";
    std::string strShortAddrTemp;
    std::string strLongAddr = "";
	std::string strMeasurementID= "";
    std::string strFileName = "";
	std::string strProduct = "";
    int iChannel = 0;
    int iChannelTemp = 0;
    
    std::vector<float> vecData;
    
    RecvData recvTemp;
    if (m_waveTrans) {     //对每个传感器的每个通道进行遍历然后处理数据，例如：传感器1x轴的数据处理完后，再去处理y轴的。传感器1的所有数据处理完后，再处理传感器2的    
		char getLongAddr_sql[32] = { 0 };
		sprintf(getLongAddr_sql, "zigbeeShortAddr='%s'", m_strDestShortAddr.c_str());
		vec_t res = sql_ctl->GetDataSingleLine(T_SENSOR_INFO(TNAME)," * ",getLongAddr_sql);
		strLongAddr = res[0];
		strMeasurementID = res[44];
		if ( 0 == strLongAddr.length() ) {
			sleep(1);
			return;
		}
		std::string ran = "";
		int n = 0;
		int range = 0;
		float coe = 0;
		int sampleRate = 0,ACCSampleTime = 0;
		char getrange[32] = {0};
		std::string str = "range";
		sprintf(getrange, "zigbeeShortAddr='%s'", strShortAddr.c_str());
		//ran = sql_ctl->GetData(T_SENSOR_INFO(TNAME), T_SENSOR_INFO(RANGE), getrange);
		ran = res[25];
		sampleRate = atoi(res[23].c_str());
		ACCSampleTime = atoi(res[36].c_str());
		strProduct = res[17];
		memset(getrange, 0, 32);
		sprintf(getrange, "%s", ran.c_str());
		n = (int)strtol(getrange, NULL, 32);
		if (m_waveCountX > 0 || VecWaveDataX.size() > 0)
		{
			print_info("m_waveCountX = %d,VecWaveData = %d\n",m_waveCountX,VecWaveDataX.size());
			coe = Calcoe(n,3,strProduct,range);
			vecData = DealData(3,coe,sampleRate,ACCSampleTime,strProduct);
			WriteDatFile(sampleRate, strMeasurementID, 3,vecData);
			m_waveCountX = 0;
			g_VecWaveDataX.clear();
			VecWaveDataX.clear();
		}
		if (m_waveCountY > 0 || VecWaveDataY.size() > 0)
		{
			print_info("m_waveCountY = %d,VecWaveData = %d\n",m_waveCountY,VecWaveDataY.size());
			coe = Calcoe(n,4,strProduct,range);
			vecData = DealData(4,coe,sampleRate,ACCSampleTime,strProduct);
			WriteDatFile(sampleRate, strMeasurementID, 4,vecData);
			m_waveCountY = 0;
			g_VecWaveDataY.clear();
			VecWaveDataY.clear();
		}
		if (m_waveCountZ > 0 || VecWaveDataZ.size() > 0)
		{
			print_info("m_waveCountZ = %d,VecWaveDataZ = %d\n",m_waveCountZ,VecWaveDataZ.size());
			coe = Calcoe(n,5,strProduct,range);
			vecData = DealData(5,coe,sampleRate,ACCSampleTime,strProduct);
			WriteDatFile(sampleRate, strMeasurementID, 5,vecData);
			m_waveCountZ = 0;
			g_VecWaveDataZ.clear();
			VecWaveDataZ.clear();

		}
    	char whereCon[1024] = {0x00};
    	char updateSql[1024] = {0x00};
    	sprintf(whereCon, "dataNodeNo='%s'", strLongAddr.c_str());
    	sprintf(updateSql, "WaveTime = WaveTime + 1");
    	sql_ctl->UpdateTableData(T_SENSOR_INFO(TNAME), updateSql, whereCon);
		m_waveTrans = false;
	}
	
		


    //string strData = sql_ctl->GetNodeConfigureInfor(whereCon);
    //data_publish(strData.c_str(), GlobalConfig::Topic_G.mPubConfig.c_str());
    // memset(buf, 0, 8);
    // sprintf(buf, "%02x%02x", recvTemp.ShortAddr[0], recvTemp.ShortAddr[1]);
    // std::string strShortAddr = std::string(buf);
    
}
float Uart::Calcoe(int ran,int iChannel,string& product,int range)
{
	float coe = 0.0;
	if(product== "01"){
		switch (ran)
		{
			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;				
		}
	}else if(product == "02"){
		if(iChannel == 3 || iChannel == 4){
			coe = 0.00048828125;
		}
		if(iChannel == 5){
			/*if(res[8] == "0.1"){
				coe = 0.0034521484375;//0.03265968810083316;
			}else*/
			{
				coe = 0.00172607421875;
			}
		}
	}
	return coe;
}
void Uart::WriteDatFile(int sampleRate,string& strMeasurementID,int iChannel,std::vector<float>& vecData)
{
		if(vecData.size() <= 0)
			return;
		std::string strFileName = "";
		char localtimestamp[32] = { 0 };
        GetTimeNet(localtimestamp, 1);
        std::string nowTimetamp = std::string(localtimestamp);
        std::string strChannelID = "";
        switch (iChannel)
        {
        case 3:{
            strFileName = "/opt/data/" + strMeasurementID + "-X.dat";
            strChannelID = strMeasurementID + "-X";
        }
            break;
        case 4:{
            strFileName = "/opt/data/" + strMeasurementID + "-Y.dat";
            strChannelID = strMeasurementID + "-Y";
        }
            break;
        case 5:{
            strFileName = "/opt/data/" + strMeasurementID + "-Z.dat";
            strChannelID = strMeasurementID + "-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");
        fwrite(localtimestamp,sizeof(localtimestamp),1,fp);
        print_info("fopen FIle vecData.size : %d\n", vecData.size());
        float mean = pCalculation->mean(vecData);
        float frTemp;
        char buf[33]={0x00};
        std::string strWaveData	= "";
        for (int i = 0; i < vecData.size(); i++) { 
            frTemp = vecData[i] - mean;
            fwrite(&frTemp,sizeof(float),1,fp);
            memset(buf,0x00,sizeof(buf));
            sprintf(buf, "%.2f", frTemp);
            std::string waveTemp(buf);
            if(i == 0)
            	strWaveData =  waveTemp;
			else
            	strWaveData = strWaveData + "," + waveTemp;

			if (i % 100  == 0)
			{
				mssleep(5000);
			}
        }

        fclose(fp);
        //
        Json::Value valWaveData;
        int length = vecData.size();
        valWaveData["number"] = sampleRate;
		valWaveData["channelId"] = strChannelID;
		valWaveData["dataNodeNo"] = strMeasurementID;
		valWaveData["dataNodeGatewayNo"] = GlobalConfig::MacAddr_G;
		valWaveData["SensorEngineeringUnit"] = "";
		valWaveData["timeStamp"] = nowTimetamp;
		valWaveData["waveData"] = strWaveData;
		valWaveData["mean"] = mean;
		Json::FastWriter WaveValue;
		std::string WaveData = WaveValue.write(valWaveData);

		char selectCon[128] = { 0 };
		sprintf(selectCon, "channelID='%s' ORDER BY timeStamp ASC  LIMIT 0,1",strChannelID.c_str());
		std::string  strTime = sql_ctl->GetData("t_data_waveSend", "timeStamp", selectCon);
		long lTime = atol(nowTimetamp.c_str())-atol(strTime.c_str());
		int Count = sql_ctl->GetTableRows("t_data_waveSend", NULL);
		std::string strFileName_Record = strFileName + "_" + nowTimetamp;
		if ((Count * 3 < SAVE_COUNT &&  lTime < OneWeek ) || strTime.size() == 0 ) {
			char insertSql[128]={0x00};
			sprintf(insertSql,"'%s','%s','%s',1,0",strChannelID.c_str(),strFileName_Record.c_str(),nowTimetamp.c_str());
			sql_ctl->InsertData("t_data_waveSend", insertSql);
		}else{
			char updateSql[128] = { 0 },whereCon[128] = {0};
			sprintf(updateSql, "waveName='%s',timeStamp='%s'",strFileName_Record.c_str(),nowTimetamp.c_str());
			memset(whereCon,0x00,sizeof(whereCon));
			sprintf(whereCon, "channelID='%s' and timeStamp = '%s'", strChannelID.c_str(),strTime.c_str());
			print_info("update static data to sql\n");
			sql_ctl->UpdateTableData("t_data_waveSend", updateSql, whereCon);
		}
        //传感器发来的数据包中的表示设备信息的数据转化为json格式后，通过调用data_publish将数据传给mqttclient  ： Topic：wireless/cmd/60294D203717

		int iRet = data_publish(WaveData.c_str(), GlobalConfig::Topic_G.mPubWaveData.c_str());
		if(iRet != 0){
			char whereCon[1024] = {0x00};
			char updateSql[1024] = {0x00};
			char tmpWhere[128]={0x00};
			sprintf(tmpWhere,"channelID = '%s' and sendMsg = 0 ",strChannelID.c_str());
			int count = sql_ctl->GetTableRows("t_data_waveSend", tmpWhere);
			LOG_ERROR("save channlID %s dat count = %d\n",strChannelID.c_str(),count);
			if(count <= 12)
			{
				sprintf(whereCon, "channelID='%s' and timeStamp = '%s' ", strChannelID.c_str(),nowTimetamp.c_str());
				sprintf(updateSql, "SendMsg = 0 ");
				sql_ctl->UpdateTableData("t_data_waveSend", updateSql, whereCon);
				LOG_ERROR("send failed,filename %s,iRet = %d\n",strFileName.c_str(),iRet);
				string strFileName_failed = strFileName + "_" + nowTimetamp;
				char tmpCmd[128]={0x00};
				sprintf(tmpCmd,"cp %s %s",strFileName.c_str(),strFileName_failed.c_str());
				system(tmpCmd);
			}else {
				memset(tmpWhere,0x00,sizeof(tmpWhere));
				memset(updateSql,0x00,sizeof(updateSql));
				sprintf(tmpWhere, " sendMsg = 0 and channelID='%s' ORDER BY timeStamp ASC  LIMIT 0,1",strChannelID.c_str());
				vec_t vecRet = sql_ctl->GetDataSingleLine("t_data_waveSend","*",tmpWhere);
				memset(tmpWhere,0x00,sizeof(tmpWhere));
				sprintf(tmpWhere, " sendMsg = 0 and timeStamp = '%s' and channelID = '%s' ",vecRet[2].c_str(),vecRet[0].c_str());
				sprintf(updateSql, "sendMsg = 3 ");
				int iRet = sql_ctl->UpdateTableData("t_data_waveSend", updateSql, tmpWhere);
				memset(tmpWhere,0x00,sizeof(tmpWhere));
				memset(updateSql,0x00,sizeof(updateSql));
				sprintf(whereCon, "channelID='%s' and timeStamp = '%s' ", strChannelID.c_str(),nowTimetamp.c_str());
				sprintf(updateSql, "sendMsg = 0");
				int iRet2 = sql_ctl->UpdateTableData("t_data_waveSend", updateSql, whereCon);

				string strFileName_failed = strFileName + "_" + nowTimetamp;
				char tmpCmd[128]={0x00};
				sprintf(tmpCmd,"cp %s %s",strFileName.c_str(),strFileName_failed.c_str());
				system(tmpCmd);
				LOG_ERROR("cp dat file %s \n",tmpCmd);

				memset(tmpWhere,0x00,sizeof(tmpWhere));
				sprintf(tmpWhere," channelID = '%s' and sendMsg = 0 ",strChannelID.c_str());
				int count = sql_ctl->GetTableRows("t_data_waveSend", tmpWhere);

				memset(tmpCmd,0x00,sizeof(tmpCmd));
				sprintf(tmpCmd,"rm %s ",vecRet[1].c_str());
				system(tmpCmd);
				LOG_ERROR("rm dat file %s \n",tmpCmd);

			}

		}else{
			LOG_DEBUG("send data , filename %s,size = %d\n", strFileName.c_str(),vecData.size());
		}
#ifdef G2UL_GATEWAY//存储6条波形数据
		char whereCon[1024] = {0x00};
		char updateSql[1024] = {0x00};
		char tmpWhere[128]={0x00};
		sprintf(tmpWhere,"channelID = '%s' and save = 1 ",strChannelID.c_str());
		int count = sql_ctl->GetTableRows("t_data_waveSend", tmpWhere);
		LOG_INFO("save channlID %s dat count = %d\n",strChannelID.c_str(),count);
		if(count <= 5)
		{
			sprintf(whereCon, "channelID='%s' and timeStamp = '%s' ", strChannelID.c_str(),nowTimetamp.c_str());
			sprintf(updateSql, "save = 1 ");
			sql_ctl->UpdateTableData("t_data_waveSend", updateSql, whereCon);
			string strFileName_save = strFileName + "_" + nowTimetamp + "_save";
			char tmpCmd[128]={0x00};
			sprintf(tmpCmd,"cp %s %s",strFileName.c_str(),strFileName_save.c_str());
			system(tmpCmd);
		}else {
			memset(tmpWhere,0x00,sizeof(tmpWhere));
			memset(updateSql,0x00,sizeof(updateSql));
			sprintf(tmpWhere, " save = 1 and channelID='%s' ORDER BY timeStamp ASC  LIMIT 0,1",strChannelID.c_str());
			vec_t vecRet = sql_ctl->GetDataSingleLine("t_data_waveSend","*",tmpWhere);
			memset(tmpWhere,0x00,sizeof(tmpWhere));
			sprintf(tmpWhere, " save = 1 and timeStamp = '%s' and channelID = '%s' ",vecRet[2].c_str(),vecRet[0].c_str());
			sprintf(updateSql, "save = 0 ");
			int iRet = sql_ctl->UpdateTableData("t_data_waveSend", updateSql, tmpWhere);
			memset(tmpWhere,0x00,sizeof(tmpWhere));
			memset(updateSql,0x00,sizeof(updateSql));
			sprintf(whereCon, "channelID='%s' and timeStamp = '%s' ", strChannelID.c_str(),nowTimetamp.c_str());
			sprintf(updateSql, "save = 1");
			int iRet2 = sql_ctl->UpdateTableData("t_data_waveSend", updateSql, whereCon);

			string strFileName_save = strFileName + "_" + nowTimetamp + "_save";
			char tmpCmd[128]={0x00};
			sprintf(tmpCmd,"cp %s %s",strFileName.c_str(),strFileName_save.c_str());
			system(tmpCmd);

			memset(tmpWhere,0x00,sizeof(tmpWhere));
			sprintf(tmpWhere," channelID = '%s' and save = 1 ",strChannelID.c_str());
			int count = sql_ctl->GetTableRows("t_data_waveSend", tmpWhere);

			memset(tmpCmd,0x00,sizeof(tmpCmd));
			sprintf(tmpCmd,"rm %s ",(vecRet[1]+"_save").c_str());
			system(tmpCmd);
			LOG_INFO("rm dat file %s \n",tmpCmd);
		}

#endif
        print_info("write data to filename %s\n", strFileName.c_str());
        std::vector<float>().swap(vecData);
        sleep(1);
		
}
void Uart::DealNodeSendTime(unsigned char* shortaddr)
{
	
		/*char updateSql[1024]={0x00},whereCon[1024]={0x00},insertSql[1024]={0x00};
	    memset(whereCon,0x00,sizeof(whereCon));
	    memset(insertSql,0x00,sizeof(insertSql));
	    sprintf(whereCon,"dataNodeNo = '%s'",dataNodeInfo.ZigbeeLongAddr.c_str());
	    int nodegroup = 0;
	    int staticStartTime = 0;
	    int nodeindex = 0;
	    int statictime = 0;
	    int nodewaveindex = 1;
	    if(0 == sql_ctl->GetTableRows(T_DATANODE_TIME(TNAME), whereCon)){

	    	sprintf(whereCon,"staticcycle = '%d' and wavecycle = '%d' order by nodeindex desc LIMIT 0 , 1",dataNodeInfo.FeatureInterVal,dataNodeInfo.WaveInterVal);
	    	vec_t vecResult = sql_ctl->GetDataSingleLine(T_DATANODE_TIME(TNAME),"*",whereCon);
	    	if(vecResult.size() == 0){
	    		string strResult = sql_ctl->GetData(T_DATANODE_TIME(TNAME),"nodegroup"," nodegroup > 0 order by nodegroup desc LIMIT 0 , 1");
	    		if(atoi(strResult.c_str()) > 0){
	    			print_info("strResult = %s\n",strResult.c_str());
	    			nodegroup = atoi(strResult.c_str()) + 1;
	    		}else{
	    			nodegroup = 1;
	    		}
	    		staticStartTime = 0;
	    	}else{
	    		nodegroup = atoi(vecResult[4].c_str());
	    		nodewaveindex = atoi(vecResult[6].c_str()) + 1;
	    		statictime = atoi(vecResult[7].c_str()) + atoi(vecResult[2].c_str());
	    		if(statictime > atoi(vecResult[3].c_str())){
	    			staticStartTime = ceil(atof(vecResult[2].c_str()) / 2 );
	    			statictime = staticStartTime;
	    			nodewaveindex = 1;
	    		}else{
	    			staticStartTime = atoi(vecResult[8].c_str());
	    		}
	    	}
	    	std::string strnodeinex = sql_ctl->GetData(T_DATANODE_TIME(TNAME), "nodeindex", "nodeindex > 0 order by nodeindex desc LIMIT 0 , 1");
	    	LOG_INFO("DealNodeSendTime strnodeinex = %s\n",strnodeinex.c_str());
	    	nodeindex = atoi(strnodeinex.c_str())+1;
	    	sprintf(insertSql,"'%s','%s','%d','%d',%d,%d,%d,%d,%d",dataNodeInfo.ZigbeeLongAddr.c_str(),dataNodeInfo.ZigbeeShortAddr.c_str(),\
	    	    			dataNodeInfo.FeatureInterVal,dataNodeInfo.WaveInterVal,nodegroup,nodeindex,nodewaveindex,statictime,staticStartTime);
	        sql_ctl->InsertData(T_DATANODE_TIME(TNAME), insertSql);
	        LOG_INFO("DealNodeSendTime InsertData = %s\n",insertSql);
	        UpdateWirelessNodeTime(shortaddr,nodewaveindex,staticStartTime,nodeindex);//更新时间戳
	    }else{
	    	sprintf(whereCon,"staticcycle = '%d' and wavecycle = '%d' order by nodeindex desc LIMIT 0 , 1",
	    		    		    		dataNodeInfo.FeatureInterVal,dataNodeInfo.WaveInterVal);

	    	vec_t vecResult = sql_ctl->GetDataSingleLine(T_DATANODE_TIME(TNAME),"*",whereCon);
	    	if(vecResult.size() == 0){
	    		string strResult = sql_ctl->GetData(T_DATANODE_TIME(TNAME),"nodegroup"," nodegroup > 0 order by nodeindex desc LIMIT 0 , 1");
	    		if(atoi(strResult.c_str()) > 0){
	    			nodegroup = atoi(strResult.c_str()) + 1;
	    		}else{
	    			nodegroup = 1;
	    		}
	    		staticStartTime = 0;
	    		statictime = 0;
	    		memset(whereCon,0x00,sizeof(whereCon));
	    		sprintf(whereCon,"dataNodeNo = '%s'",dataNodeInfo.ZigbeeLongAddr.c_str());
	    		sprintf(updateSql," staticcycle = '%d',wavecycle = '%d',nodegroup = %d,nodewaveindex = %d,statictime = %d, staticstarttime = %d",dataNodeInfo.FeatureInterVal,dataNodeInfo.WaveInterVal,\
	    			nodegroup,nodewaveindex,statictime,staticStartTime);
	    		sql_ctl->UpdateTableData(T_DATANODE_TIME(TNAME), updateSql, whereCon);
	    		LOG_INFO("DealNodeSendTime updateSql = %s\n",updateSql);
	    		LOG_DEBUG("DealNodeSendTime1");
	    		UpdateWirelessNodeTime(shortaddr,nodewaveindex,staticStartTime,nodeindex);//更新时间戳
	    	}else{
	    		print_info("=======Send Time======\n");
	    		LOG_DEBUG("DealNodeSendTime2");
	    		UpdateWirelessNodeTime(shortaddr,atoi(vecResult[6].c_str()),atoi(vecResult[8].c_str()),atoi(vecResult[5].c_str()));//更新时间戳
	    	}
	    }
	    memset(whereCon,0x00,sizeof(whereCon));
	    sprintf(whereCon,"dataNodeNo = '%s' and staticcycle <> '%d' and wavecycle <> '%d'",dataNodeInfo.ZigbeeLongAddr.c_str(),\
	    	    		dataNodeInfo.FeatureInterVal,dataNodeInfo.WaveInterVal);
	    sql_ctl->DeleteTableData(T_DATANODE_TIME(TNAME),whereCon);*/


}
bool Uart::CheckCrc(char* pCheckBuff,int No)
{
	unsigned char tmp = 0x00;
	for(int i = 0 ; i < No;i++){
		tmp +=  (unsigned char)pCheckBuff[i];
//		printf("%02x ",pCheckBuff[i]);
	}

	if((unsigned char)pCheckBuff[No] != (unsigned char)tmp)
		return false;
	return true;

}
void Uart::modify_distaddr_info(unsigned short id, char * zigbee,unsigned char* distAddr)
{
	char command[6] = {0x00};
	command[0] = 0xDE;
	command[1] = 0xDF;
	command[2] = 0xEF;
	command[3] = 0xDC;
	command[4] = ((char *)&id)[1];
	command[5] = ((char *)&id)[0];
	WriteToUart(command, 6);

	mssleep(10000);
	memset(command,0x00,sizeof(command));
	command[0] = 0xDE;
	command[1] = 0xDF;
	command[2] = 0xEF;
	command[3] = 0xD2;
	command[4] = distAddr[0];
	command[5] = distAddr[1];
	WriteToUart(command, 6);


}
void Uart::getZigbeeSignal(unsigned char* distAddr)
{
	mssleep(10000);
	char command[6] = {0x00};
	command[0] = 0xDE;
	command[1] = 0xDF;
	command[2] = 0xEF;
	command[3] = 0xDA;
	command[4] = distAddr[0];
	command[5] = distAddr[1];
	WriteToUart(command, 6);
}
void Uart::modify_DistAddr(unsigned char* distAddr)
{
	char command[6] = {0x00};
	memset(command,0x00,sizeof(command));
	command[0] = 0xDE;
	command[1] = 0xDF;
	command[2] = 0xEF;
	command[3] = 0xD2;
	command[4] = distAddr[0];
	command[5] = distAddr[1];
	WriteToUart(command, 6);
}
void Uart::modify_LocalAddr(unsigned short id)
{
	char command[6] = {0x00};


	command[0] = 0xDE;
	command[1] = 0xDF;
	command[2] = 0xEF;
	command[3] = 0xDC;
	command[4] = ((char *)&id)[1];
	command[5] = ((char *)&id)[0];
	WriteToUart(command, 6);
//	ReadFromUart();

}
void Uart::modify_Localchannel(unsigned char pad)
{
	char command[6] = {0x00};
	command[0] = 0xDE;
	command[1] = 0xDF;
	command[2] = 0xEF;
	command[3] = 0xD1;
	command[4] = pad & 0xff;
	WriteToUart(command, 5);
//	ReadFromUart();

}
void Uart::modify_LocalPanID(unsigned short padID)
{
	char command[6] = {0x00};
	command[0] = 0xDE;
	command[1] = 0xDF;
	command[2] = 0xEF;
	command[3] = 0xDB;
	command[4] = ((char *)&padID)[1];
	command[5] = ((char *)&padID)[0];
	WriteToUart(command, 6);
//	ReadFromUart();

}
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)[0];
    command[5] = ((char *)&id)[1];
    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] = 0xaa;
    WriteToUart(command, i+1);
    sleep(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);

    gpio_set(GlobalConfig::GPIO_G.zigReset,0);
    mssleep(10000);
    gpio_set(GlobalConfig::GPIO_G.zigReset,1);
}

void Uart::WritePanId2Zigbee(unsigned short pad)
{
    print_info("WritePanId2Zigbee : %d\n", pad);
	unsigned short pad1 = pad,tmp; 
	tmp = GlobalConfig::Zigbee_G.MyAddr;
	print_info("MyAddr : %d\n", GlobalConfig::Zigbee_G.MyAddr);
	swap((char *)&pad1);
	//swap((char *)&tmp);
	GlobalConfig::Zigbee_G.PanID = pad1;
	modify_info(tmp, (char *)&GlobalConfig::Zigbee_G);

	gpio_set(GlobalConfig::GPIO_G.zigReset,0);
	mssleep(10000);
	gpio_set(GlobalConfig::GPIO_G.zigReset,1);
}
void Uart::WriteSpeed2Zigbee()
{
	GlobalConfig::Zigbee_G.Serial_Rate = 0x07;
	GlobalConfig::Zigbee_G.Serial_DataB = 0x08;
	GlobalConfig::Zigbee_G.Serial_StopB = 0x01;
	unsigned short tmp;
	tmp = GlobalConfig::Zigbee_G.MyAddr;
	modify_info(tmp, (char *)&GlobalConfig::Zigbee_G);
	gpio_set(GlobalConfig::GPIO_G.zigReset,0);
	mssleep(10000);
	gpio_set(GlobalConfig::GPIO_G.zigReset,1);
}
/*void Uart::WriteLocalAddr(unsigned short id)
{
	gpio_set(116,0);
	mssleep(10000);
	gpio_set(116,1);
	sleep(1);
	char command[8]={0x00};
	command[0] = 0xab;
	command[1] = 0xbc;
	command[2] = 0xcd;
	command[3] = 0xdc;
	command[4] = ((char *)&id)[1];
	command[5] = ((char *)&id)[0];
	command[6] = 0x00;
	command[7] = 0xaa;
	WriteToUart(command, 8);
	mssleep(600000);
	gpio_set(116,0);
	mssleep(10000);
	gpio_set(116,1);
}*/
void Uart::WriteTranTimeout2Zigbee(unsigned char Time)
{
	print_info("WriteTranTimeout2Zigbee : %d\n", Time);

	unsigned short  tmp = GlobalConfig::Zigbee_G.MyAddr;
	//print_info("MyAddr : %d\n", GlobalConfig::Zigbee_G.MyAddr);
	GlobalConfig::Zigbee_G.PowerLevel = 0x03;
	GlobalConfig::Zigbee_G.RetryNum = 0x64;
	GlobalConfig::Zigbee_G.TranTimeout = Time;
	modify_info(tmp, (char *)&GlobalConfig::Zigbee_G);

	gpio_set(GlobalConfig::GPIO_G.zigReset,0);
	mssleep(10000);
	gpio_set(GlobalConfig::GPIO_G.zigReset,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);

    gpio_set(GlobalConfig::GPIO_G.zigReset,0);
    mssleep(10000);
    gpio_set(GlobalConfig::GPIO_G.zigReset,1);
    sleep(1);
}

void Uart::WriteShortAddr_DistAddr2Zigbee(unsigned short pad,unsigned char* pDestShortAddr)
{
    print_info("WriteShortAddr2Zigbee : %4x\n", (unsigned short)pad);
    unsigned short pad1 = pad,tmp;
    tmp =  GlobalConfig::Zigbee_G.MyAddr;
    swap((char *)&pad1);
    swap((char *)&tmp);
    char tmpDest[8]={0x00};
    sprintf(tmpDest,"%02x%02x",pDestShortAddr[0],pDestShortAddr[1]);
    memcpy(&GlobalConfig::Zigbee_G.DstAddr,pDestShortAddr,2);
    GlobalConfig::Zigbee_G.MyAddr = pad1;
//    GlobalConfig::Zigbee_G.DstAddr = (short)atoi((char*)tmpDest);
    print_info("DstAddr = %x\n",GlobalConfig::Zigbee_G.DstAddr);
    GlobalConfig::ZigbeeInfo_G.MyAddr = "9999";
    modify_info(tmp, (char *)& GlobalConfig::Zigbee_G);

    gpio_set(GlobalConfig::GPIO_G.zigReset,0);
    mssleep(10000);
    gpio_set(GlobalConfig::GPIO_G.zigReset,1);
}
int Uart::CheckZigbeeACK()
{
	if(gpio_read(GlobalConfig::GPIO_G.zigAckrep) == 48)
		gpio_set(GlobalConfig::GPIO_G.zigAckreset,1);
	int time = 0,value = 0,iRet = -1;
	do{
		value = gpio_read(GlobalConfig::GPIO_G.zigAckrep);
		if(value == 49)
		{
			iRet = 0;
			break;
		}
		time += 1;
		mssleep(10000);
	}while(time < 150);
	return iRet;
}
void Uart::ZigbeeInit()
{
	std::string strPanId = sql_ctl->GetData("t_gateway_info","zigbeePanID",NULL);

	{
	     unsigned short shortAddr = 0x8888;
	      //GlobalConfig::Zigbee_G.MyAddr = shortAddr;
	      //WriteLocalAddr(shortAddr);
	      WriteShortAddr2Zigbee(shortAddr);
	      mssleep(100000);
	      // 更新GlobalConfig::ZigbeeInfo_G.MyAddr，用于外部显示

	}

    //std::string strPanId = GlobalConfig::MacAddr_G.substr(8);
    print_info("strPanId : %s\n", strPanId.c_str());
    print_info("MacAddr_G : %s\n", GlobalConfig::MacAddr_G.c_str());
	// 新增管理ZigBee代码
	std::string strchan = ReadStrByOpt(ZIGBEECONFIG, "Zigbee", "channel");

	unsigned short Chan = (unsigned short)strtol(strchan.c_str(), NULL, 10);
	print_info("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%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)
    	{
				WriteChanl2Zigbee(Chan);
				//modify_Localchannel(Chan);
				mssleep(100000);
		}
	}
	print_info("PanID1 = %s,strPanId = %s\n",GlobalConfig::ZigbeeInfo_G.PanID.c_str(),strPanId.c_str());
    //if (0 != GlobalConfig::ZigbeeInfo_G.PanID.compare(strPanId.c_str()))
    {
        long lShortAddr = strtol(strPanId.c_str(), NULL, 16);
        unsigned short panid = lShortAddr & 0xffff;
        //modify_LocalPanID(panid);

        WritePanId2Zigbee(panid);
        mssleep(100000);
    }

    //if (0 != GlobalConfig::ZigbeeInfo_G.MyAddr.compare("8888"))

	print_info("ZigbeeInfo_G.MyAddr=%s\n",GlobalConfig::ZigbeeInfo_G.MyAddr.c_str());

}