对应发货标签V1.6，更改版本号为V1.1，与一期标签分开，更改了tag的uwb测距配置与DW1000通讯,并将测距接包逻辑单次接包改为打开循环接收

chen

2024-09-20 681567d6d1bd2894eccde5b22a948eac7d3a22a5

 keil/include/drivers/serial_at_cmd_app.c

@@ -19,17 +19,8 @@
#define Lora_TXD_bff_MAX  220   //发送缓存区大小  >4+8+4*基站数量+2=14+4*基站数量

uint8_t mUsartReceivePack[100] = {0};
uint8_t mUsart2ReceivePack[150] = {0};
double jd,wd;
int analysis_num,pos_state;
uint8_t state5V_prase_flag=1,gps_prase_flag=1;
extern void IO_LED_control_change(uint8_t data);
extern void IO_control_init(void);
extern void blink_led(uint8_t*state);
extern void updata_led_power_state(void);
extern uint8_t gps_success_state;
extern uint8_t gps_success_state,gps_enable_flag,gps_need_data_flag,gps_timeout_flag;
extern uint16_t gps_wait_count;
uint8_t mUsart2ReceivePack[100] = {0};

typedef enum
{
    BLE_RECV_STATE_IDLE = 0,
@@ -37,12 +28,6 @@
    BLE_RECV_STATE_RSSI,
    //BLE_RECV_STATE_LF,
} E_BLERecvState;
static char gps_header[20];
typedef struct
{
    char m_pData[100];
    uint32_t m_u32Len;
} GGA_DataStruct;
typedef struct
{
    E_BLERecvState m_eState;
@@ -57,7 +42,7 @@
uint8_t  mUsart2ReceivePack_before , mUsart2ReceivePack_now;
uint8_t j_ct=0,CT_satrt_temp=0,CT_satrt=0,numb_base=0   ;

uint8_t id_cmpare[12]= {0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x30, 0x30, 0x30, 0x31}; //123456780001//测试//RC2202A：
uint8_t id_cmpare[12]={0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x30, 0x30, 0x30, 0x31};//123456780001//测试//RC2202A：
uint32_t CT_sum=0;
char char_broadcast_data[80];//广播数据

@@ -70,7 +55,7 @@
uint16_t temp_16,temp_16_id,temp_16_distance,data_buff_start;


uint16_t Checksum_u16(uint8_t* pdata, uint32_t len)
uint16_t Checksum_u16(uint8_t* pdata, uint32_t len) 
{
    uint16_t sum = 0;
    uint32_t i;
@@ -79,27 +64,47 @@
    sum = ~sum;
    return sum;
}

void SendComMap0(uint8_t data_length, uint8_t index)//表示成功读取的回应包
   {
   static uint8_t send_frame[EUART_RX_BUF_SIZE];
   uint16_t checksum = 0;
   send_frame[0] = 0x55;
   send_frame[1] = 0xAA;
   send_frame[2] = 0x03;
   send_frame[3] = data_length+5;
   send_frame[4] = CMD_REPLY;
   send_frame[5] = index;
   send_frame[6] = data_length;
   memcpy(&send_frame[7], &g_com_map[index], data_length);
   for(int i = 0; i<(data_length+5); i++)
   {
      checksum += send_frame[2+i];
   }
   checksum = Checksum_u16(&send_frame[2],5+data_length);
   memcpy(&send_frame[7+data_length],&checksum,2);
	
    uart_send(UART_ID0, send_frame,data_length+9, NULL);	
}
void SendComMap(uint8_t data_length, uint8_t index)//表示成功读取的回应包
{
    static uint8_t send_frame[EUART_RX_BUF_SIZE];
    uint16_t checksum = 0;
    send_frame[0] = 0x55;
    send_frame[1] = 0xAA;
    send_frame[2] = 0x03;
    send_frame[3] = data_length+5;
    send_frame[4] = CMD_REPLY;
    send_frame[5] = index;
    send_frame[6] = data_length;
    memcpy(&send_frame[7], &g_com_map[index], data_length);
    for(int i = 0; i<(data_length+5); i++)
    {
        checksum += send_frame[2+i];
    }
    checksum = Checksum_u16(&send_frame[2],5+data_length);
    memcpy(&send_frame[7+data_length],&checksum,2);

    uart_send(UART_ID1, send_frame,data_length+9, NULL);
   static uint8_t send_frame[EUART_RX_BUF_SIZE];
   uint16_t checksum = 0;
   send_frame[0] = 0x55;
   send_frame[1] = 0xAA;
   send_frame[2] = 0x03;
   send_frame[3] = data_length+5;
   send_frame[4] = CMD_REPLY;
   send_frame[5] = index;
   send_frame[6] = data_length;
   memcpy(&send_frame[7], &g_com_map[index], data_length);
   for(int i = 0; i<(data_length+5); i++)
   {
      checksum += send_frame[2+i];
   }
   checksum = Checksum_u16(&send_frame[2],5+data_length);
   memcpy(&send_frame[7+data_length],&checksum,2);
	
    uart_send(UART_ID1, send_frame,data_length+9, NULL);	
}
void UpdateProcess(uint8_t index)
{
@@ -110,171 +115,327 @@
        __disable_irq();
        result = flash_open(FLASH_ID0,NULL);
        if(!result)//打开成功
            flash_erase(FLASH_ID0,APP_CONFIG_IAPFLAG_SECTOR_ADDR,FLASH_SECTOR_SIZE);
        result = flash_write_nbytes(FLASH_ID0,APP_CONFIG_IAPFLAG_MAP,(uint8_t*)&tmp,2);
               flash_erase(FLASH_ID0,APP_CONFIG_IAPFLAG_SECTOR_ADDR,FLASH_SECTOR_SIZE);
          result = flash_write_nbytes(FLASH_ID0,APP_CONFIG_IAPFLAG_MAP,(uint8_t*)&tmp,2);
        __enable_irq();
        Serial0PutString("进入升级模式\r\n");
        g_com_map[CNT_UPDATE]=0;
        save_com_map_to_flash();
        delay_us(100000);
        NVIC_SystemReset(); //软复位回到bootloader
       NVIC_SystemReset(); //软复位回到bootloader   
    }
    if(index == 2*CNT_REBOOT)
    {   g_com_map[CNT_REBOOT]=0;
    {      g_com_map[CNT_REBOOT]=0;
        g_com_map[MAP_SIGN_INDEX]=0;
        save_com_map_to_flash();
        delay_us(100000);
        NVIC_SystemReset(); //软复位回到bootloader
         delay_us(100000);
        NVIC_SystemReset(); //软复位回到bootloader   
    }
    if(index == 2*CNT_RESTART)
    {
        g_com_map[CNT_RESTART]=0;
        save_com_map_to_flash();
        delay_us(100000);
        NVIC_SystemReset(); //软复位回到bootloader
         delay_us(100000);
       NVIC_SystemReset(); //软复位回到bootloader   
    }

}
double d_value;
void UsartParseDataHandler(uint8_t data)
{
    if(state5V_prase_flag&&!g_com_map[MODBUS_MODE])
    {   //升级程序
        static UsartRecvPackState usart_receive_state = UsartReceiveWaitHead0;
        uint16_t checksum = 0;
        static uint8_t pack_datalen = 0,pack_length = 0,pack_index = 0,pack_msgtype = 0,pack_cmd = CMD_READ;
        static uint8_t index = 0;
   static UsartRecvPackState usart_receive_state = UsartReceiveWaitHead0;
   uint16_t checksum = 0;
   static uint8_t pack_datalen = 0,pack_length = 0,pack_index = 0,pack_msgtype = 0,pack_cmd = CMD_READ;
   static uint8_t index = 0;



	
   if(usart_receive_state == UsartReceiveWaitChecksum) {         //若收到校验和包
      checksum = 0;
      for(int i = 0; i<pack_length-5; i++) { 
         checksum += mUsartReceivePack[i];
      }
      checksum += pack_cmd;
      checksum += pack_length;
      checksum += pack_index;
      checksum += pack_datalen;
      checksum += pack_msgtype;
      if(((data + checksum)&0xff) == 0xFF)            //校验通过
      {
         switch(pack_cmd)
         {
            case CMD_WRITE:
               //从mUsartReceivePack中读取pack_length长度的字节，放到全局变量中,赋值保存的参数并且存入flash
				
               memcpy((uint8_t*)&g_com_map + pack_index, mUsartReceivePack, pack_datalen);
				
               if(mUsartReceivePack[0]==1)
          UpdateProcess(pack_index);
               //返回一个error状态
               //SendComMap(pack_datalen,pack_index);
               save_com_map_to_flash();
               //delay_ms(100);
               NVIC_SystemReset();
               break;
            case CMD_READ:
               //read包中data字节，即mUsartReceivePack[0]表示数据长度；
            //从g_com_data结构体中的第index位置读取长度为mUsartReceivePack[0]的字节，发送出来
               SendComMap0(pack_datalen,pack_index>>1);		
               break;
            default:
               break;
         }
      }
      usart_receive_state = UsartReceiveWaitHead0;
      pack_index = 0;
      pack_length = 0;
      index=0;
   } else if((usart_receive_state == UsartReceiveWaitData) ) {   //若果收到的是正常通讯包
      mUsartReceivePack[index] = data;
      index++;
      if(index == pack_length-5) {      //如果收到的index与长度相等
         usart_receive_state = UsartReceiveWaitChecksum;
      }
   } else if(usart_receive_state == UsartReceiveWaitDataLen) {                  //收到指令类型字节
      pack_datalen = data;
      usart_receive_state = UsartReceiveWaitData;
   }else if(usart_receive_state == UsartReceiveWaitIndex) {                  //收到指令类型字节
      pack_index = data;
      usart_receive_state = UsartReceiveWaitDataLen;
   } else if(usart_receive_state == UsartReceiveWaitCMD) {                     //收到指令类型字节
      pack_cmd = data;
      usart_receive_state = UsartReceiveWaitIndex;
   } else if(usart_receive_state == UsartReceiveWaitLength) {                  //收到长度字节
		
         pack_length = data;
         pack_index = 0;			
         usart_receive_state = UsartReceiveWaitCMD;
		
   } else if((usart_receive_state == UsartReceiveWaitHead0) && (data == 0x55)) {   //收到第一个包头
      usart_receive_state = UsartReceiveWaitHead1;
   } else if((usart_receive_state == UsartReceiveWaitHead1) && (data == 0xAA)) {   //收到第二个包头
      usart_receive_state = UsartReceiveWaitMsgType;
   }else if ((usart_receive_state == UsartReceiveWaitMsgType) && (data == 0x3)) {
      usart_receive_state = UsartReceiveWaitLength;
      pack_msgtype = data;
   }
   else {
      usart_receive_state = UsartReceiveWaitHead0;
      pack_index = 0;
      pack_length = 0;
   }

        if(usart_receive_state == UsartReceiveWaitChecksum)
        {   //若收到校验和包
            checksum = 0;
            for(int i = 0; i<pack_length-5; i++) {
                checksum += mUsartReceivePack[i];
            }
            checksum += pack_cmd;
            checksum += pack_length;
            checksum += pack_index;
            checksum += pack_datalen;
            checksum += pack_msgtype;
            if(((data + checksum)&0xff) == 0xFF)            //校验通过
            {
                switch(pack_cmd)
                {
                case CMD_WRITE:
                  if(pack_index==MODBUS_MODE*2)
                  {
                      Uart1GpsRecDebugSend();                    
                      g_com_map[MODBUS_MODE] = 1;
                      return;
                  }
                    //从mUsartReceivePack中读取pack_length长度的字节，放到全局变量中,赋值保存的参数并且存入flash
                    memcpy((uint8_t*)&g_com_map + pack_index, mUsartReceivePack, pack_datalen);
                    if(mUsartReceivePack[0]==1)
                        UpdateProcess(pack_index);
                    //返回一个error状态
                    //SendComMap(pack_datalen,pack_index);
                    save_com_map_to_flash();
                    //delay_ms(100);
                    NVIC_SystemReset();
                    break;
                case CMD_READ:
                    //read包中data字节，即mUsartReceivePack[0]表示数据长度；
                    //从g_com_data结构体中的第index位置读取长度为mUsartReceivePack[0]的字节，发送出来
                    SendComMap(pack_datalen,pack_index>>1);
                    break;
                default:
                    break;
                }
            }
            usart_receive_state = UsartReceiveWaitHead0;
            pack_index = 0;
            pack_length = 0;
            index=0;
        } else if((usart_receive_state == UsartReceiveWaitData) ) {   //若果收到的是正常通讯包
            mUsartReceivePack[index] = data;
            index++;
            if(index == pack_length-5) {      //如果收到的index与长度相等
                usart_receive_state = UsartReceiveWaitChecksum;
            }
        } else if(usart_receive_state == UsartReceiveWaitDataLen) {                  //收到指令类型字节
            pack_datalen = data;
            usart_receive_state = UsartReceiveWaitData;
        } else if(usart_receive_state == UsartReceiveWaitIndex) {                  //收到指令类型字节
            pack_index = data;
            usart_receive_state = UsartReceiveWaitDataLen;
        } else if(usart_receive_state == UsartReceiveWaitCMD) {                     //收到指令类型字节
            pack_cmd = data;
            usart_receive_state = UsartReceiveWaitIndex;
        } else if(usart_receive_state == UsartReceiveWaitLength) {                  //收到长度字节

            pack_length = data;
            pack_index = 0;
            usart_receive_state = UsartReceiveWaitCMD;

        } else if((usart_receive_state == UsartReceiveWaitHead0) && (data == 0x55)) {   //收到第一个包头
            usart_receive_state = UsartReceiveWaitHead1;
        } else if((usart_receive_state == UsartReceiveWaitHead1) && (data == 0xAA)) {   //收到第二个包头
            usart_receive_state = UsartReceiveWaitMsgType;
        } else if ((usart_receive_state == UsartReceiveWaitMsgType) && (data == 0x3)) {
            usart_receive_state = UsartReceiveWaitLength;
            pack_msgtype = data;
        }
        else {
            usart_receive_state = UsartReceiveWaitHead0;
            pack_index = 0;
            pack_length = 0;
        }
    } else if(gps_prase_flag)
    {
        static uint8_t index = 0;
//GPS解析数据
//   static ST_BLERecv BLE_recvive;
        GGA_DataStruct jdrecv,wdrecv,Posstate;
        
        //接收数据开始分析
        mUsart2ReceivePack[index]  =  data; //char数组传进来参数data
        mUsart2ReceivePack_before  =  mUsart2ReceivePack_now;
        mUsart2ReceivePack_now=data;
        index++;
        if( mUsart2ReceivePack_before == 0x0D && mUsart2ReceivePack_now==0x0A )//接收数据到“0x0D 0x0A”结束
        {
            //解析该条GPS报文
           
            analysis_num=sscanf((char*)mUsart2ReceivePack,"$%[^,],%*[^,],%[^,],%*[^,],%[^,],%*[^,],%[^,],%*[^,],%*[^,],%*[^,],%*[^,],%*[^,],%*[^,],%*[^,],%*s",gps_header,wdrecv.m_pData,jdrecv.m_pData,Posstate.m_pData);
            if(!memcmp(gps_header,"GNGGA",5))
            { 
                if(g_com_map[MODBUS_MODE])
                    LOG_INFO(TRACE_MODULE_APP,"%s", mUsart2ReceivePack);
                    d_value = strtod(wdrecv.m_pData,NULL);
                if(d_value>1)
                {
                     blink_led(&gps_success_state);
                    wd=strtod(wdrecv.m_pData,NULL);
                    jd=strtod(jdrecv.m_pData,NULL);
                    pos_state=atoi(Posstate.m_pData);
                }
            } 
            index = 0;
            if(pos_state!=0)
            {
                //4g.jd=jd;
                //4g.wd=wd;
                gps_timeout_flag=1;//不超时接收状态
                gps_need_data_flag=0;//接收数据完成
                gps_wait_count=0;//清0接收状态
//      gps_enable_flag=0;//收到有效数据关闭GPS
            }
            memset(mUsart2ReceivePack,0,sizeof(mUsart2ReceivePack));
            memset(wdrecv.m_pData,0,sizeof(wdrecv.m_pData));
            memset(jdrecv.m_pData,0,sizeof(jdrecv.m_pData));
            memset(Posstate.m_pData,0,sizeof(Posstate.m_pData));
            index=0;
            mUsart2ReceivePack_before=0;
            mUsart2ReceivePack_now=0;
        }
    }
}

void Usart2ParseDataHandler(uint8_t data)//UART蓝牙数据分析处理
{
   //打印接收到的蓝牙模块信息
   //printf("这个是传入的数据%c",data);
//   static UsartRecvPackState usart2_receive_state = UsartReceiveWaitHead0;
   //static UsartRecvPackState usart2_receive_state = UsartReceiveWaitData;
	
   static ST_BLERecv BLE_recvive;//创建蓝牙状态结构体
	
	
   uint16_t checksum = 0;

   static uint8_t pack_datalen = 0,pack_length = 0,pack_index = 0,pack_msgtype = 0,pack_cmd = CMD_READ;
   static uint8_t index = 0;
	
//   uint8_t dev_id[14],dev_ssi[5],i,k=0;
//   //char  char_mac[14],char_ssi[6];
//   int j=0;
//   //uint16_t temp_16,temp_16_id,temp_16_distance;
//   uint8_t temp8_H,temp8_L;
//   //float temp_float;
//   //double ssi_double;//,distance_double;
//   //int32_t distance_int;
//   uint16_t Label_id=0;  //标签id
	

   //接收数据开始分析
  mUsart2ReceivePack[index]  =  data; //char数组传进来参数data
   mUsart2ReceivePack_before  =  mUsart2ReceivePack_now;
   mUsart2ReceivePack_now=data;
   index++;
   if( mUsart2ReceivePack_before == 0x0D && mUsart2ReceivePack_now==0x0A )//接收数据到“0x0D 0x0A”结束
   {
      mUsart2ReceivePack[index]=0;
      //printf("0D0A进入后的数据为%s到此结束",mUsart2ReceivePack);
//      if(strncmp("RF-CRAZY",(char*)mUsart2ReceivePack,8)==0)
//      {
//      BLE_recvive.m_eState=BLE_RECV_STATE_MAC;//如果为名字后判断并改为MAC接收状态
//      }
//		
      switch(BLE_recvive.m_eState)
         {   case BLE_RECV_STATE_IDLE:
            if(strncmp("RF-CRAZY",(char*)mUsart2ReceivePack,8)==0)
            BLE_recvive.m_eState=BLE_RECV_STATE_MAC;//如果为名字后判断并改为MAC接收状态
            break;
         case BLE_RECV_STATE_MAC://MAC接受处理状态
            strcpy(BLE_recvive.m_macHeader,(char*)mUsart2ReceivePack+5);//复制到蓝牙结构体中,+5是为了跳过MAC字符和冒号未处理0D0A
            //处理MAC字符不让换行
           char*p=BLE_recvive.m_macHeader+strlen(BLE_recvive.m_macHeader)-2;
            *p='\0';
            //printf("处理过后的MAC为%s",BLE_recvive.m_macHeader);
            BLE_recvive.m_eState=BLE_RECV_STATE_RSSI;
            break;
         case BLE_RECV_STATE_RSSI://RSSI接收处理状态
            strcpy(BLE_recvive.m_rssiHeader2,(char*)mUsart2ReceivePack+6);//复制到蓝牙结构体中,+5是为了跳过MAC字符和冒号未处理0D0A
            //printf("  处理过后的RSSI为%s",BLE_recvive.m_rssiHeader2);
            BLE_recvive.m_eState=BLE_RECV_STATE_IDLE;
            break;
      }
		
//      if(mUsart2ReceivePack[0] ==0x2B )             //“+”扫描到开始或结束字符串的首个字符
//      {
//         if (mUsart2ReceivePack[5] ==0x20)	
//         {				
//            printf("UART扫描结束   :+SCAN END\r\n");   //本次扫描结束				
//            CT_sum++;                                 //包序值
//            if(CT_sum>255) CT_sum=0;
//					
//         //发送数据缓存		
//            Lora_TXD_bff[0] = 0x55;
//            Lora_TXD_bff[1] = 0xAA;
//            Lora_TXD_bff[2] = 0x12;			
//            Lora_TXD_bff[3] = 8+4*numb_base;          //数据长度 8+4*基站数量						
//				
//            Label_id=Label_id_local;                  //标签id
//            memcpy(&Lora_TXD_bff[4],&Label_id ,2); 						
//				
//            Lora_TXD_bff[6] = CT_sum;                 //标签包序
//            Lora_TXD_bff[7] = 0x32;                   //按键/电量,测试数据50					
//            Lora_TXD_bff[8] = 0;                        //LORA等待应答

//            Lora_TXD_bff[9]= numb_base;               //基站数量

//            for(i=10;i<(10+numb_base*2);i=i+2)
//            {	         
//          memcpy(&Lora_TXD_bff[i+0]          ,&data_buff[(i-10)/2][0] ,2);         //基站ID	
//          memcpy(&Lora_TXD_bff[i+numb_base*2],&data_buff[(i-10)/2][1] ,2);         //基站距离									
//            }					
//            for( i = 2;i<(4+8+4*numb_base); i++)                  //去包头后  校验    累加取反
//         {
//               checksum += Lora_TXD_bff[i];
//            }
//            checksum = ~checksum;
//        memcpy(&Lora_TXD_bff[2+8+4*numb_base],&checksum ,2); //和取反 校验				
//				
//            Radio_init();                                        //唤醒 为发送状态
//            Radio.Send( Lora_TXD_bff, (4+8+4*numb_base));        //LORA模块上传数据
//				

//            //基站距离  清零    
//            for(i=0;i<numb_base;i++)
//            {
//               //for(k=1;k<2;k++)                                 //清距离数据
//               for(k=0;k<2;k++)                                   //清ID号和距离数据
//              {				
//                 data_buff[i][k]=0;
//               }
//            } 
//        numb_base =0;
//            data_buff_start =0;				
//        				
//            printf("\r\n");		
//         //delay_ms(5);
//         Uart2_SendString(  Uart2_str);                         //发下一次扫描指令																				
//         }
//			
//         else if(mUsart2ReceivePack[5] ==0x5F)                   //“_"下划线
//         {				
//        printf("UART扫描开始   :+SCAN_MANU:\r\n");				
//         }		  																			
//      }		
//    else
//      {				
//         j=memcmp(id_cmpare,mUsart2ReceivePack,8);               //比较目标蓝牙地址 前4个字节		
//         if(j==0)//跟目标蓝牙mac地址相同
//         {
//				
//            //拷贝mac地址
//            for(i=0;i<12;i++)
//           {
//             char_mac[i] = mUsart2ReceivePack[i];         				
//           }
//            char_mac[12]='\0';	
//				
//				
//            //拷贝信号
//            for(i=15;i<18;i++)
//           {
//             char_ssi[i-15] = mUsart2ReceivePack[i];			
//           }
//           if(mUsart2ReceivePack[18]==0x0D || mUsart2ReceivePack[18]==0x20)          //信号是-两位数
//           {		                                         
//               char_ssi[3]= '\0'   ;
//               char_broadcast_data[0]= '\0';
//               if (mUsart2ReceivePack[18]==0x0D)                                      //信号是-两位数，无广播内容
//               {
//                  CT_satrt=0;
//               }
//               else if(mUsart2ReceivePack[18]==0x20)                                  //信号是-两位数，有广播内容,空格后一位开始，到0x0D 结束。
//               {
//                  CT_satrt=19;																								
//               }
//               ssi_double = -((char_ssi[1]-0x30)*10 + (char_ssi[2]-0x30));            //2位信号值int	
//           }
//           else if(mUsart2ReceivePack[18]>=0x30  &&  mUsart2ReceivePack[18]<=0x39 ) //信号是-三位数
//            {			                                      
//              char_ssi[3]=mUsart2ReceivePack[18];						                                     
//               char_ssi[4]= '\0'   ;	
//          char_broadcast_data[0]= '\0';	
//               if (mUsart2ReceivePack[19]==0x0D)                                      //信号是-三位数，无广播内容
//               {
//                  CT_satrt=0;
//               }
//               else if(mUsart2ReceivePack[19]==0x20)                                  //信号是-三位数，有广播内容,空格后一位开始，到0x0D 结束。
//               {
//                  CT_satrt=20;																								
//               }	 
//          ssi_double = -((char_ssi[1]-0x30)*100 + (char_ssi[2]-0x30)*10 + (char_ssi[3]-0x30));//3位信号值int			
//          }																								
//			
//            printf("mac= %s  ",char_mac);	
//        printf("ssi= %s  ",char_ssi);      

//            //基站ID处理
//        temp_16_id = (char_mac[8]-0x30)*1000 + (char_mac[9]-0x30)*100   + (char_mac[10]-0x30)*10 + (char_mac[11]-0x30);	
//            printf("ID = %d  ",temp_16_id );		
//            //基站距离处理
//            temp_16_distance = 0.003083 * exp(-0.09909*ssi_double)*100;//单位cm
//            printf("距离 = %d cm  \r\n",temp_16_distance );		

//        //比较ID号并拷贝数据到缓存区	      				
//            for(i=0;i<data_buff_MAX;i++)
//            {
//              if(data_buff[i][0] == temp_16_id)     //检测到已存ID
//               {
//                  data_buff[i][1] = temp_16_distance;	
//                  data_buff_start=0;
//                  break;				
//               }
//          else if   (data_buff[i][0]==0)
//               {
//                  data_buff_start=i+1;
//                 numb_base=data_buff_start;           //拷贝扫描到基站的数量
//                 break;
//               }	
//            }	
//            if(data_buff_start!=0)
//            {
//               data_buff[data_buff_start-1][0] = temp_16_id;			
//          data_buff[data_buff_start-1][1] = temp_16_distance;	
//          			
//            }
//         }	
//      }     
      index=0;
      mUsart2ReceivePack_before=0;
      mUsart2ReceivePack_now=0;		
   }
//printf("处理过后的数组为%s\n",mUsart2ReceivePack);
}