电池标签L051工程
blame | 历史 | 补丁 | 提交 | 提交对比 | 忽略空白
WXK
2023-09-15 671f59b69396b30ee80c3ddb57e4cd11b979d642 
 Src/application/dw_app.c


@@ -29,7 +29,9 @@


#include <stdio.h>


#include "beep.h"


#include "modbus.h"


#include "CRC.h"




//#define USART_INTEGRATE_OUTPUT


/*------------------------------------ Marcos ------------------------------------------*/


/* Inter-ranging delay period, in milliseconds. */


#define RNG_DELAY_MS 100


@@ -47,13 +49,14 @@


#define POLL_TX_TO_RESP_RX_DLY_UUS 150


/* This is the delay from Frame RX timestamp to TX reply timestamp used for calculating/setting the DW1000's delayed TX function. This includes the


 * frame length of approximately 2.66 ms with above configuration. */


#define RESP_RX_TO_FINAL_TX_DLY_UUS 850


#define RESP_RX_TO_FINAL_TX_DLY_UUS 410




/* Receive response timeout. See NOTE 5 below. */


#define RESP_RX_TIMEOUT_UUS 600




#define DELAY_BETWEEN_TWO_FRAME_UUS 240


#define DELAY_BETWEEN_TWO_FRAME_UUS 400




#define POLL_RX_TO_RESP_TX_DLY_UUS 420


//#define POLL_RX_TO_RESP_TX_DLY_UUS 470


/* This is the delay from the end of the frame transmission to the enable of the receiver, as programmed for the DW1000's wait for response feature. */


#define RESP_TX_TO_FINAL_RX_DLY_UUS 200


/* Receive final timeout. See NOTE 5 below. */


@@ -68,30 +71,29 @@


#define FINAL_MSG_FINAL_TX_TS_IDX 18


#define FINAL_MSG_TS_LEN 4




//#define _UWB_4G




enum enumtagstate


{


   DISCPOLL,


   GETNEARMSG,


   NEARPOLL,


}tag_state;


static dwt_config_t config = {


#ifdef _UWB_4G


   2,               /* Channel number. */


#else


    5,


#endif


   DWT_PRF_64M,     /* Pulse repetition frequency. */


   DWT_PLEN_128,    /* Preamble length. */


   DWT_PLEN_64,    /* Preamble length. */


   DWT_PAC8,        /* Preamble acquisition chunk size. Used in RX only. */


   9,               /* TX preamble code. Used in TX only. */


   9,               /* RX preamble code. Used in RX only. */


   0,               /* Use non-standard SFD (Boolean) */


   1,               /* Use non-standard SFD (Boolean) */


   DWT_BR_6M8,      /* Data rate. */


   DWT_PHRMODE_STD, /* PHY header mode. */


   (129 + 8 - 8)    /* SFD timeout (preamble length + 1 + SFD length - PAC size). Used in RX only. */


   (65 + 8 - 8)    /* SFD timeout (preamble length + 1 + SFD length - PAC size). Used in RX only. */


};


static uint8_t tx_poll_msg[20] = {0};


static uint8_t tx_sync_msg[14] = {0};


static uint8_t tx_final_msg[60] = {0};


static uint8_t tx_resp_msg[22] = {0};


static uint8_t tx_near_msg[80] = {0};


 uint8_t tx_near_msg[80] = {0};




static uint32_t frame_seq_nb = 0;   


static uint32_t status_reg = 0;


@@ -102,7 +104,6 @@


static uint64_t poll_rx_ts;


static uint64_t resp_tx_ts;


static uint64_t final_rx_ts;


static double tof;


int32_t anchor_dist_last_frm[TAG_NUM_IN_SYS],his_dist[TAG_NUM_IN_SYS];   ;   


uint32_t tag_id = 0;


uint32_t tag_id_recv = 0;


@@ -162,25 +163,30 @@


        *ts += ts_field[i] << (i * 8);


    }


}




uint32_t uwbid=0;


void Dw1000_Init(void)


{


   /* Reset and initialise DW1000.


     * For initialisation, DW1000 clocks must be temporarily set to crystal speed. After initialisation SPI rate can be increased for optimum


     * performance. */


    Reset_DW1000();//重启DW1000 /* Target specific drive of RSTn line into DW1000 low for a period. */


   Spi_ChangePrescaler(SPIx_PRESCALER_SLOW);   //设置为快速模式


    dwt_initialise(DWT_LOADUCODE);//初始化DW1000


   Spi_ChangePrescaler(SPIx_PRESCALER_FAST);   //设置为快速模式




    /* Configure DW1000. See NOTE 6 below. */


    dwt_configure(&config);//配置DW1000


   


//    dwt_setinterrupt(  DWT_INT_RFCG | (DWT_INT_ARFE | DWT_INT_RFSL | DWT_INT_SFDT | DWT_INT_RPHE | DWT_INT_RFCE | DWT_INT_RFTO | DWT_INT_RXPTO), 1);




   


    /* Apply default antenna delay value. See NOTE 1 below. */


    dwt_setrxantennadelay(RX_ANT_DLY);      //设置接收天线延迟


    dwt_settxantennadelay(TX_ANT_DLY);      //设置发射天线延迟




    


//    dwt_setrxtimeout(1000);//设定接收超时时间，0位没有超时时间


//   dwt_rxenable(0);//打开接收


//    uwbid=dwt_readdevid();


    /* Set expected response's delay and timeout. See NOTE 4 and 5 below.


     * As this example only handles one incoming frame with always the same delay and timeout, those values can be set here once for all. */


            //设置接收超时时间


@@ -188,7 +194,7 @@


void Dw1000_App_Init(void)


{


//g_com_map[DEV_ID] = 0x0b;


   tag_state=DISCPOLL;


   //tag_state=DISCPOLL;


   tx_poll_msg[MESSAGE_TYPE_IDX]=POLL;


   tx_resp_msg[MESSAGE_TYPE_IDX]=RESPONSE;


   tx_final_msg[MESSAGE_TYPE_IDX]=FINAL;


@@ -212,7 +218,7 @@


}




u16 tag_time_recv[TAG_NUM_IN_SYS];


u8 usart_send[25];


u8 usart_send[100];


u8 battary,button;


extern uint8_t g_pairstart;


void tag_sleep_configuraion(void)


@@ -220,402 +226,498 @@


   dwt_configuresleep(0x940, 0x7);


   dwt_entersleep();


}


extern uint8_t g_start_send_flag;


//extern uint8_t g_start_send_flag;




uint16_t g_Resttimer;


uint8_t result;


u8 tag_succ_times=0;


int32_t hex_dist;


u16 checksum;


int8_t tag_delaytime;


extern uint16_t sync_timer;


u16 tmp_time;


int32_t temp_dist;


u16 tagslotpos;


//uint16_t g_Resttimer;


//uint8_t result;


//u8 tag_succ_times=0;


//int32_t hex_dist;


//u16 checksum;


//int8_t tag_delaytime;


//extern uint16_t sync_timer;


//u16 tmp_time;


//int32_t temp_dist;


//u16 tagslotpos;




u16 anclist_num=0,anclist_pos; //list 总数量和当前位置


u16 ancid_list[TAG_NUM_IN_SYS];


u8 nearbase_num;


u16 nearbaseid_list[10],mainbase_id;


int32_t mainbase_dist,nearbase_distlist[10];


uint8_t trygetnearmsg_times;


void Poll(void)


{


   uint32_t frame_len;


   uint32_t final_tx_time;


   u32 start_poll;


   int32_t mindist=999999,minid=-1,temp_dist;


   u8 i,getsync_flag=0;


    dwt_setrxaftertxdelay(POLL_TX_TO_RESP_RX_DLY_UUS);         //设置发送后开启接收，并设定延迟时间


    dwt_setrxtimeout(RESP_RX_TIMEOUT_UUS);		


   tag_succ_times = 0;


//   GPIO_WriteBit(GPIOA, GPIO_Pin_9, Bit_RESET);


   for(i=0;i<g_com_map[MAX_REPORT_ANC_NUM];i++)


   {


   /* Write frame data to DW1000 and prepare transmission. See NOTE 7 below. */


   tx_poll_msg[ANC_TYPE_IDX] = i;	


   dwt_writetxdata(sizeof(tx_poll_msg), tx_poll_msg, 0);//将Poll包数据传给DW1000，将在开启发送时传出去


   dwt_writetxfctrl(sizeof(tx_poll_msg), 0);//设置超宽带发送数据长度


   dwt_starttx(DWT_START_TX_IMMEDIATE | DWT_RESPONSE_EXPECTED);//开启发送，发送完成后等待一段时间开启接收，等待时间在dwt_setrxaftertxdelay中设置


//u16 anclist_num=0,anclist_pos; //list 总数量和当前位置


//u16 ancid_list[TAG_NUM_IN_SYS];


//u8 nearbase_num;


//u16 mainbase_id;


//int32_t mainbase_dist;


//uint8_t trygetnearmsg_times;


//u16 nearbaseid_list[MAX_NEARBASE_NUM],mainbase_id,true_nearbase_idlist[MAX_NEARBASE_NUM];


//u8 FindNearBasePos(u16 baseid)


//{


//   u8 i;


//   for(i=0;i<nearbase_num;i++)


//   {


//      if(baseid==nearbaseid_list[i])


//         return i;


//   }


//}


//u8 recbase_num=0;


//#define CHANGE_BASE_THRESHOLD  5


//uint8_t GetRandomValue(void)


//{


//   uint8_t random_value=0,temp_adc,i;


//   for(i=0;i<8;i++)


//   {


//      temp_adc=Get_ADC_Value();


//      random_value=random_value|((temp_adc&0x01)<<i);


//   }


//   return random_value;


//}


//u8 GetRandomSlotPos(uint32_t emptyslot)


//{


//   u8 i,temp_value;


//   temp_value = HAL_LPTIM_ReadCounter(&hlptim1);//GetRandomValue();


//   for(i=temp_value%32;i<max_slotpos;i++)


//   {


//      if(((emptyslot>>i)&0x1)==0)


//      {


//         return i;


//      }


//   }


//	


//      for(i=1;i<max_slotpos;i++)


//   {


//      if(((emptyslot>>i)&0x1)==0)


//      {


//         return i;


//      }


//   }


//return max_slotpos-1;


//}




   /* We assume that the transmission is achieved correctly, poll for reception of a frame or error/timeout. See NOTE 8 below. */


   while (!((status_reg = dwt_read32bitreg(SYS_STATUS_ID)) & (SYS_STATUS_RXFCG | SYS_STATUS_ALL_RX_ERR)))//不断查询芯片状态直到成功接收或者发生错误


   {


   };


   if(status_reg==0xffffffff)


   {


      NVIC_SystemReset();


   }


   if (status_reg & SYS_STATUS_RXFCG)//如果成功接收


   {


      dwt_write32bitreg(SYS_STATUS_ID, SYS_STATUS_RXFCG | SYS_STATUS_TXFRS);//清楚寄存器标志位


      frame_len = dwt_read32bitreg(RX_FINFO_ID) & RX_FINFO_RXFLEN_MASK;   //获得接收到的数据长度


      dwt_readrxdata(rx_buffer, frame_len, 0);   //读取接收数据


      if (rx_buffer[MESSAGE_TYPE_IDX] == RESPONSE&&!memcmp(&rx_buffer[TAG_ID_IDX],&dev_id,2)) //判断接收到的数据是否是response数据


      {


         poll_tx_ts = get_tx_timestamp_u64();                              //获得POLL发送时间T1


         resp_rx_ts = get_rx_timestamp_u64();                              //获得RESPONSE接收时间T4			


         if(getsync_flag==0)


         {


            getsync_flag=1;


         memcpy(&sync_timer,&rx_buffer[ANCTIMEMS],2);


         memcpy(&tmp_time,&rx_buffer[ANCTIMEUS],2);


         memcpy(&tagslotpos,&rx_buffer[TAGSLOTPOS],2);		


         tmp_time=tmp_time+450;


         if(tmp_time>999)


         {


            tmp_time-=999;


            sync_timer++;


            if(sync_timer>=1010)


               {sync_timer=0;}


         }


//         TIM3->CNT=tmp_time;


//         if(tagslotpos>max_slotpos)


//            tagslotpos=tagslotpos%(max_slotpos+1);


//            tyncpoll_time=(tagslotpos-1)*slottime;


      }


			


         memcpy(&temp_dist, &rx_buffer[DIST_IDX], 4);


         memcpy(&tx_final_msg[ANCHOR_ID_IDX], &rx_buffer[ANCHOR_ID_IDX], 4);


         /* Compute final message transmission time. See NOTE 9 below. */


         final_tx_time = (resp_rx_ts + (RESP_RX_TO_FINAL_TX_DLY_UUS * UUS_TO_DWT_TIME)) >> 8;//计算final包发送时间，T5=T4+Treply2


         dwt_setdelayedtrxtime(final_tx_time);//设置final包发送时间T5


         final_tx_ts = (((uint64_t)(final_tx_time & 0xFFFFFFFE)) << 8) + TX_ANT_DLY;//final包实际发送时间是计算时间加上发送天线delay


         final_msg_set_ts(&tx_final_msg[FINAL_MSG_POLL_TX_TS_IDX], poll_tx_ts);//将T1，T4，T5写入发送数据


         final_msg_set_ts(&tx_final_msg[FINAL_MSG_RESP_RX_TS_IDX], resp_rx_ts);


         final_msg_set_ts(&tx_final_msg[FINAL_MSG_FINAL_TX_TS_IDX], final_tx_ts);


         dwt_writetxdata(sizeof(tx_final_msg), tx_final_msg, 0);//将发送数据写入DW1000


         dwt_writetxfctrl(sizeof(tx_final_msg), 0);//设定发送数据长度


         result=dwt_starttx(DWT_START_TX_DELAYED);//设定为延迟发送			


         tag_succ_times++;		


            LED0_BLINK;


			


         if(temp_dist<mindist)


         {


            memcpy(&minid, &rx_buffer[ANCHOR_ID_IDX], 4);


            tag_state=GETNEARMSG;


            trygetnearmsg_times=5;


            mindist=temp_dist;


         }


         if(result==0)


         {while (!(dwt_read32bitreg(SYS_STATUS_ID) & SYS_STATUS_TXFRS))//不断查询芯片状态直到发送完成


         { };


      }


         /* Clear TXFRS event. */


         dwt_write32bitreg(SYS_STATUS_ID, SYS_STATUS_TXFRS);//清除标志位


         random_delay_tim = 0;


      }


      else


      {


         random_delay_tim = DFT_RAND_DLY_TIM_MS; //如果通讯失败，将间隔时间增加5ms，避开因为多标签同时发送引起的冲突。


      }


   }


   else


   {


   dwt_write32bitreg(SYS_STATUS_ID, SYS_STATUS_ALL_RX_ERR);


      random_delay_tim = DFT_RAND_DLY_TIM_MS;


   }


}


   if(getsync_flag==0)


   {


   tagslotpos--;


         if(tagslotpos==0||tagslotpos>max_slotpos)


      {		


         tagslotpos=max_slotpos;	


      }


      tyncpoll_time=(tagslotpos-1)*slottime;


   }


   mainbase_id=minid;


}


//int32_t mainbase_dist,nearbase_distlist[MAX_NEARBASE_NUM],true_nearbase_distlist[MAX_NEARBASE_NUM],true_exsistbase_list[MAX_NEARBASE_NUM],ancsync_time,nextpoll_delaytime,offsettimeus;


//u8 anclost_times=0 , mainbase_lost_count=0;


//u8 exsistbase_list[MAX_NEARBASE_NUM],report_num,get_newbase=0;


//u8 flag_finalsend,flag_getresponse,flag_rxon;


//uint16_t current_count,start_count,end_count,lastsync_timer;




u8 FindNearBasePos(u16 baseid)


{


   u8 i;


   for(i=0;i<nearbase_num;i++)


   {


      if(baseid==nearbaseid_list[i])


         return i;


   }


}


u8 recbase_num=0;


#define CHANGE_BASE_THRESHOLD  5


void NearAncSelect(void)


{static u16 last_mainbase_id,change_base_count;


   int32_t nearbase_mindist=99999, nearbase_minpos;


   u8 i;


   for(i=0;i<recbase_num-1;i++)


   {


      if(nearbase_mindist>nearbase_distlist[i])


      {


         nearbase_mindist=nearbase_distlist[i];


         nearbase_minpos=i;


      }


   }


   if(nearbase_mindist<mainbase_dist-THRESHOLD_CHANGE_MAINBASE_DIST)


   {


      if(last_mainbase_id==nearbaseid_list[nearbase_minpos])


      {


         change_base_count++;


         if(change_base_count>CHANGE_BASE_THRESHOLD)


         {


            mainbase_id=last_mainbase_id;


            tag_state=GETNEARMSG;


         }


      }else{


         change_base_count=0;


      }


      last_mainbase_id=nearbaseid_list[nearbase_minpos];		


   }else{


      change_base_count=0;


   }


}


u8 anclost_times=0;


uint16_t current_count,start_count,end_count;


void NearPoll(void)


{


   static u8 mainbase_lost_count=0,flag_finalsend;


   uint32_t temp1,temp2,dw_systime;


   uint32_t frame_len;


   uint32_t final_tx_time;


   u32 start_poll;


   u8 i,getsync_flag=0,timeout;


    dwt_setrxaftertxdelay(POLL_TX_TO_RESP_RX_DLY_UUS);         //设置发送后开启接收，并设定延迟时间


    dwt_setrxtimeout(RESP_RX_TIMEOUT_UUS);		


   tag_succ_times = 0;


   tx_near_msg[BATTARY_IDX] = Get_Battary();


   //tx_near_msg[BUTTON_IDX] = !READ_KEY0;


   tx_near_msg[SEQUENCE_IDX] = frame_seq_nb++;


   tx_near_msg[NEARBASENUM_INDEX] = nearbase_num;


   memcpy(&tx_near_msg[NEARBASEID_INDEX],&nearbaseid_list,nearbase_num*2);


   tx_near_msg[MESSAGE_TYPE_IDX] = NEAR_POLL;	


   memcpy(&tx_near_msg[ANCHOR_ID_IDX],&mainbase_id,2);	


   dwt_writetxdata(13+2*nearbase_num, tx_near_msg, 0);//将Poll包数据传给DW1000，将在开启发送时传出去


   dwt_writetxfctrl(13+2*nearbase_num, 0);//设置超宽带发送数据长度


   dwt_starttx(DWT_START_TX_IMMEDIATE | DWT_RESPONSE_EXPECTED);//开启发送，发送完成后等待一段时间开启接收，等待时间在dwt_setrxaftertxdelay中设置


//u8 nearbase_num=0,last_nearbase_num,next_nearbase_num,last_slotnum, para_update,para_len,stationary_flag=0;


//u32 rec_tagpos_binary;


//int16_t offset=2700;


//u8 current_freq,rec_freq;


//u8 motor_state,rec_remotepara_state,rec_remotepara[80];


//extern u16 last_lpcount;


//float freqlost_count = 0;


//void TagFreqProcess(u8 freq)


//{


//    if(freq>MAX_ANCFREQ||freq==0)


//    {


//        return;


//    }


//    if(freq==tag_frequency||freq>tag_frequency)


//    {


//        tag_frequency = freq;


//        freqlost_count = 0;


//    }


//}


//#define FREQ_OFFSET_MULTIPLIER          (998.4e6/2.0/1024.0/131072.0)


//#define FREQ_OFFSET_MULTIPLIER_110KB    (998.4e6/2.0/8192.0/131072.0)




   for(i=0;i<nearbase_num;i++)


   nearbase_distlist[i]=0xffff;


	


   flag_finalsend=0;


   start_count=HAL_LPTIM_ReadCounter(&hlptim1);


   recbase_num=0;


   timeout=ceil((float)nearbase_num/4)+2;


   end_count=start_count+(timeout<<5);


   if(end_count>=32768)


   {end_count-=32768;}


   mainbase_dist=100000;


   mainbase_lost_count++;


         while(current_count<end_count||current_count>end_count+15000)


         {


               while (!((status_reg = dwt_read32bitreg(SYS_STATUS_ID)) & (SYS_STATUS_RXFCG | SYS_STATUS_ALL_RX_ERR)))//不断查询芯片状态直到成功接收或者发生错误


               {


                  if(flag_finalsend)


                  {


                     dw_systime=dwt_readsystimestamphi32();


                     if(dw_systime>temp1&&dw_systime<temp2)


                     {


                        flag_finalsend=0;


                        dwt_forcetrxoff();


                        dwt_setdelayedtrxtime(final_tx_time);


                        result=dwt_starttx(DWT_START_TX_DELAYED);//设定为延迟发送	


                        break;


                     }


                  }


                   if(current_count>end_count&&current_count<end_count+15000)


                        break;


               };


               if(status_reg==0xffffffff)


               {


                  NVIC_SystemReset();


               }


               if (status_reg & SYS_STATUS_RXFCG)//如果成功接收


                  {


                     dwt_write32bitreg(SYS_STATUS_ID, SYS_STATUS_RXFCG | SYS_STATUS_TXFRS);//清楚寄存器标志位


                     frame_len = dwt_read32bitreg(RX_FINFO_ID) & RX_FINFO_RXFLEN_MASK;   //获得接收到的数据长度


                     dwt_readrxdata(rx_buffer, frame_len, 0);   //读取接收数据


                     dwt_setrxtimeout(0);//DELAY_BETWEEN_TWO_FRAME_UUS*(nearbase_num+1-recbase_num)+10);//设定接收超时时间，0位没有超时时间


                     dwt_rxenable(0);//打开接收


                     if (rx_buffer[MESSAGE_TYPE_IDX] == NEAR_RESPONSE&&!memcmp(&rx_buffer[TAG_ID_IDX],&dev_id,2)) //判断接收到的数据是否是response数据


                     {   u16 rec_nearbaseid,rec_nearbasepos;


                        poll_tx_ts = get_tx_timestamp_u64();                              //获得POLL发送时间T1


                        resp_rx_ts = get_rx_timestamp_u64();                              //获得RESPONSE接收时间T4	


                        recbase_num++;


                        memcpy(&rec_nearbaseid,&rx_buffer[ANCHOR_ID_IDX],2);


                        if(rec_nearbaseid==mainbase_id)


                        {


                           //////////////////////////////////时间同步


                           memcpy(&sync_timer,&rx_buffer[ANCTIMEMS],2);


                           memcpy(&tmp_time,&rx_buffer[ANCTIMEUS],2);


//                           memcpy(&tagslotpos,&rx_buffer[TAGSLOTPOS],2);		


                           tmp_time=tmp_time+450;


                           if(tmp_time>999)


                           {


                              tmp_time-=999;


                              sync_timer++;


                              if(sync_timer>=1010)


                                 {sync_timer=0;}


                           }


                        //   TIM3->CNT=tmp_time;


//                           if(tagslotpos>max_slotpos)


//                              tagslotpos=tagslotpos%(max_slotpos+1);


//                              tyncpoll_time=(tagslotpos-1)*slottime;


                           ////////////////////////////


                           mainbase_lost_count=0;


                           flag_finalsend=1;


                           memcpy(&mainbase_dist,&rx_buffer[DIST_IDX],4);


                           final_tx_time = (resp_rx_ts + ((RESP_RX_TO_FINAL_TX_DLY_UUS+DELAY_BETWEEN_TWO_FRAME_UUS*nearbase_num+500) * UUS_TO_DWT_TIME)) >> 8;


                           temp1=final_tx_time-((350*UUS_TO_DWT_TIME)>>8);


                           temp2=final_tx_time+((100*UUS_TO_DWT_TIME)>>8);


                        //   dwt_setdelayedtrxtime(final_tx_time);//设置final包发送时间T5


                           final_tx_ts = (((uint64_t)(final_tx_time & 0xFFFFFFFE)) << 8) + TX_ANT_DLY;//final包实际发送时间是计算时间加上发送天线delay


                           final_msg_set_ts(&tx_near_msg[FINAL_MSG_POLL_TX_TS_IDX], poll_tx_ts);//将T1，T4，T5写入发送数据


                           final_msg_set_ts(&tx_near_msg[FINAL_MSG_RESP_RX_NEARBASE_IDX], resp_rx_ts);


                           final_msg_set_ts(&tx_near_msg[FINAL_MSG_FINAL_TX_TS_IDX], final_tx_ts);


                           tx_near_msg[MESSAGE_TYPE_IDX]=NEAR_FINAL;


                           dwt_writetxdata(28+nearbase_num*4, tx_near_msg, 0);//将发送数据写入DW1000


                           dwt_writetxfctrl(28+nearbase_num*4, 0);//设定发送数据长度


                              usart_send[2] = 1;//正常模式


                              usart_send[3] = 17;//数据段长度


                              usart_send[4] = frame_seq_nb;//数据段长度


                              memcpy(&usart_send[5],&dev_id,2);


                              memcpy(&usart_send[7],&rec_nearbaseid,2);				


                              memcpy(&usart_send[9],&rx_buffer[DIST_IDX],4);


                              usart_send[13] = battary;


                              usart_send[14] = button;


                              checksum = Checksum_u16(&usart_send[2],17);


                              memcpy(&usart_send[19],&checksum,2);


                              UART_PushFrame(usart_send,21);


                           //result=dwt_starttx(DWT_START_TX_DELAYED);//设定为延迟发送			


                        }else{


                           rec_nearbasepos=FindNearBasePos(rec_nearbaseid);


                           final_msg_set_ts(&tx_near_msg[FINAL_MSG_RESP_RX_NEARBASE_IDX+(rec_nearbasepos+1)*4], resp_rx_ts);								


                           memcpy(&nearbase_distlist[rec_nearbasepos],&rx_buffer[DIST_IDX],4);


                           dwt_writetxdata(28+nearbase_num*4, tx_near_msg, 0);//将发送数据写入DW1000


                           dwt_writetxfctrl(28+nearbase_num*4, 0);//设定发送数据长度


                           LED0_BLINK;


                              usart_send[2] = 1;//正常模式


                              usart_send[3] = 17;//数据段长度


                              usart_send[4] = frame_seq_nb;//数据段长度


                              memcpy(&usart_send[5],&dev_id,2);


                              memcpy(&usart_send[7],&rec_nearbaseid,2);				


                              memcpy(&usart_send[9],&rx_buffer[DIST_IDX],4);


                              usart_send[13] = battary;


                              usart_send[14] = button;


                              checksum = Checksum_u16(&usart_send[2],17);


                              memcpy(&usart_send[19],&checksum,2);


                              UART_PushFrame(usart_send,21);


//#define HERTZ_TO_PPM_MULTIPLIER_CHAN_1     (-1.0e6/3494.4e6)


//#define HERTZ_TO_PPM_MULTIPLIER_CHAN_2     (-1.0e6/3993.6e6)


//#define HERTZ_TO_PPM_MULTIPLIER_CHAN_3     (-1.0e6/4492.8e6)


//#define HERTZ_TO_PPM_MULTIPLIER_CHAN_5     (-1.0e6/6489.6e6)


//u16 rec_maxrangelen;//rec_anc_signalpower[MAX_NEARBASE_ANCNUM];


//float clockOffsetRatio;


//double rtd_init, rtd_resp;


//double tof,distance;


//extern int32_t dwt_readcarrierintegrator(void) ;


//uint32_t testtimer2,anc_pollrx[MAX_NEARBASE_NUM],anc_resptx[MAX_NEARBASE_NUM],tag_resprx[MAX_NEARBASE_NUM];


//int32_t anc_clockoffset[MAX_NEARBASE_NUM];


//int16_t anc_distoffset[MAX_NEARBASE_NUM];


//int32_t test2;


//uint16_t u16_nearbase_distlist[MAX_NEARBASE_NUM];


//uint8_t get_newdist,notenoughdist_count;


//void SetANCTimestap(uint8_t i,uint8_t* pollrx,uint8_t* resptx,uint32_t resprx,uint8_t* distoffset)  //写入时间戳信息


//{


//    memcpy(&anc_pollrx[i],pollrx,4);


//    memcpy(&anc_resptx[i],resptx,4);


//    memcpy(&tag_resprx[i],&resprx,4);


//    memcpy(&anc_distoffset[i],distoffset,2);


//    anc_clockoffset[i] = test2;


//}


//void CalculateDists(void)   //计算距离


//{


//    for(int i=0;i<MAX_NEARBASE_NUM;i++)


//    {


//        //rec_anc_signalpower[i] = exsistbase_list[i];


//      if(exsistbase_list[i]==KEEP_TIMES)


//      {




                           //dwt_setdelayedtrxtime(final_tx_time);//设置final包发送时间T5


                        //   result=dwt_starttx(DWT_START_TX_DELAYED);//设定为延迟发送			


                           //dwt_writetxdata(4,&tx_near_msg[FINAL_MSG_RESP_RX_NEARBASE_IDX+(rec_nearbasepos+1)*4], FINAL_MSG_RESP_RX_NEARBASE_IDX+(rec_nearbasepos+1)*4);//将发送数据写入DW1000


                        }								


                     }


                  }			


                  dwt_write32bitreg(SYS_STATUS_ID,SYS_STATUS_RXFCG| SYS_STATUS_ALL_RX_ERR);


                  current_count=HAL_LPTIM_ReadCounter(&hlptim1);


         }


         if(mainbase_lost_count>5)


         {


            tag_state=DISCPOLL;


         }


         NearAncSelect();


         if(recbase_num<MIN_ANCHOR_NUM )


         {


            anclost_times++;


            if(anclost_times>3)


            {


               tagslotpos=poll_tx_ts%(max_slotpos+1);


            }


         }else{


            anclost_times=0;


         }


//         // exsistbase_list[i]--;


//#ifdef _UWB_4G


//            clockOffsetRatio = anc_clockoffset[i] * (FREQ_OFFSET_MULTIPLIER * HERTZ_TO_PPM_MULTIPLIER_CHAN_2 / 1.0e6) ;


//#else


//            clockOffsetRatio = anc_clockoffset[i] * (FREQ_OFFSET_MULTIPLIER * HERTZ_TO_PPM_MULTIPLIER_CHAN_5 / 1.0e6) ;


//#endif


//          rtd_init = tag_resprx[i] - poll_tx_ts;


//          rtd_resp = anc_resptx[i] - anc_pollrx[i];


//          tof = ((rtd_init - rtd_resp * (1 - clockOffsetRatio)) / 2.0) * DWT_TIME_UNITS;


//          distance = tof * SPEED_OF_LIGHT;


//          if(distance>-10&&distance<1000)


//            nearbase_distlist[i] = distance*100+anc_distoffset[i];


//      }else{


//         // nearbase_distlist[i] = 0x1ffff;


//      }


//    


//    }


//}


//extern uint8_t module_power,imu_enable,motor_enable;


//void Registor_Poll(void)


//{


//   static u8 regpoll_count=0;


//    u8 timeout;


//		


//      tx_near_msg[MESSAGE_TYPE_IDX] = MBX_REG;


//        tx_near_msg[REGP_TAGSTATE_INDEX] = !GET_USERKEY<<2|imu_enable<<1|motor_enable;


//      tx_near_msg[REGP_FREQUENCY_INDEX] = bat_percent;


//      tx_near_msg[REGP_POWER_INDEX] = module_power;


//      memcpy(&tx_near_msg[REGP_VERSION_INDEX],&g_com_map[VERSION],2);	


//      memcpy(&tx_near_msg[REGP_IMUTHRES_INDEX],&g_com_map[GROUP_ID],2);


//      memcpy(&tx_near_msg[REGP_NOMOVESLEEPTIME_INDEX],&g_com_map[DIST_OFFSET],2);


//        memcpy(&tx_near_msg[REGP_HEIGHTOFFSET_INDEX],&g_com_map[MAX_REPORT_ANC_NUM],2);


//      dwt_writetxdata(23, tx_near_msg, 0);//将Poll包数据传给DW1000，将在开启发送时传出去


//      dwt_writetxfctrl(23, 0);//设置超宽带发送数据长度


//      dwt_starttx(DWT_START_TX_IMMEDIATE);//开启发送，发送完成后等待一段时间开启接收，等待时间在dwt_setrxaftertxdelay中设置


//        start_count=HAL_LPTIM_ReadCounter(&hlptim1);


//        timeout=50;


//        end_count=start_count+(timeout<<2);


//        while (!((status_reg = dwt_read32bitreg(SYS_STATUS_ID)) & (SYS_STATUS_TXFRS)))//不断查询芯片状态直到成功接收或者发生错误


//        { 


//            current_count=HAL_LPTIM_ReadCounter(&hlptim1);


//           if(current_count>=end_count&&current_count<end_count+15000)


//                        break;


//            


//        };	


//               


//}


//float range_lost_time = 0;


//u16 rec_nearbaseid,rec_nearbasepos;


//void NearPoll(void)


//{


//	


//   uint32_t temp1,temp2,dw_systime;


//   uint32_t frame_len;


//   uint32_t final_tx_time;


//   u32 start_poll;


//   u8 i,j,getsync_flag=0,timeout,flag_ancreadpara=0;


//    dwt_setrxaftertxdelay(POLL_TX_TO_RESP_RX_DLY_UUS);         //设置发送后开启接收，并设定延迟时间


//    dwt_setrxtimeout(0);		


//   tag_succ_times = 0;


//      //GPIO_WriteBit(GPIOA, GPIO_Pin_10, Bit_SET);


//   if(nearbase_num>=MAX_NEARBASE_NUM)


//   {


//      nearbase_num = MAX_NEARBASE_NUM-1;


//   }


//   recbase_num=0;


//    for(uint8_t i=0;i<nearbase_num;i++)   //标签距离32位转成16位


//    {


//        u16_nearbase_distlist[i] = nearbase_distlist[i];


//    }


//   tx_near_msg[GROUP_ID_IDX] = group_id;


//   tx_near_msg[BATTARY_IDX] = bat_percent;


//   tx_near_msg[BUTTON_IDX] = !GET_USERKEY|stationary_flag<<1;


//   tx_near_msg[SEQUENCE_IDX] = frame_seq_nb++;


//   tx_near_msg[NEARBASENUM_INDEX] = nearbase_num;


//   memcpy(&tx_near_msg[NEARBASEID_INDEX],&nearbaseid_list,nearbase_num*2);


//    memcpy(&tx_near_msg[NEARBASEID_INDEX+nearbase_num*2],&u16_nearbase_distlist,nearbase_num*2);


//   tx_near_msg[MESSAGE_TYPE_IDX] = MBX_POLL;	


//   memcpy(&tx_near_msg[ANCHOR_ID_IDX],&mainbase_id,2);	


//   dwt_writetxdata(13+4*nearbase_num, tx_near_msg, 0);//将Poll包数据传给DW1000，将在开启发送时传出去


//   dwt_writetxfctrl(13+4*nearbase_num, 0);//设置超宽带发送数据长度


//   dwt_starttx(DWT_START_TX_IMMEDIATE | DWT_RESPONSE_EXPECTED);//开启发送，发送完成后等待一段时间开启接收，等待时间在dwt_setrxaftertxdelay中设置


//	


//   tx_near_msg[TAGCONFIGSUCCESS_INDEX] =0;


//   para_update = 0;


//    get_newbase = 0;


//   flag_finalsend=0;


//   flag_rxon=1;


//   flag_getresponse=0;


//   start_count=HAL_LPTIM_ReadCounter(&hlptim1);


//   recbase_num=0;


//   timeout=nearbase_num*SLOT_SCALE+10;


//   end_count=start_count+(timeout<<2);


//   if(end_count>=32768)


//   {end_count-=32768;}


//   mainbase_dist=100000;


//   mainbase_lost_count++;


//   current_count=HAL_LPTIM_ReadCounter(&hlptim1);


//         while(current_count<end_count||current_count>end_count+15000)


//         {


//            current_count=HAL_LPTIM_ReadCounter(&hlptim1);


//               while (!((status_reg = dwt_read32bitreg(SYS_STATUS_ID)) & (SYS_STATUS_RXFCG | SYS_STATUS_ALL_RX_ERR)))//不断查询芯片状态直到成功接收或者发生错误


//               {


//                  if(flag_finalsend&&flag_ancreadpara)


//                  {


//                     dw_systime=dwt_readsystimestamphi32();


//                     if(dw_systime>temp1&&dw_systime<temp2)


//                     {


//								


//                        dwt_forcetrxoff();


//                        flag_rxon=0;


//                                if(flag_ancreadpara)   //只有在读取参数的时候需要回复


//                                {


//                                    u16 calCRC;


//                                  tx_near_msg[MESSAGE_TYPE_IDX] = MBX_PRAAREPLY;  


//                                  memcpy(&tx_near_msg[MESSAGE_PARAREPLY_IDX],g_com_map,SENDANCPARA_LEN);


//                                  calCRC = CRC_Compute((uint8_t*)g_com_map,SENDANCPARA_LEN);


//                                  memcpy(&tx_near_msg[MESSAGE_PARAREPLY_IDX+SENDANCPARA_LEN],&calCRC,2);


//                                  dwt_writetxdata(14+SENDANCPARA_LEN, tx_near_msg, 0);//将发送数据写入DW1000


//                                  dwt_writetxfctrl(14+SENDANCPARA_LEN, 0);//设定发送数据长度


//                                


//                        dwt_setdelayedtrxtime(final_tx_time);


//                        result=dwt_starttx(DWT_START_TX_DELAYED);//设定为延迟发送	


//                                }


//                        flag_finalsend=0;


//                        break;


//                     }


//                  }


//                     current_count=HAL_LPTIM_ReadCounter(&hlptim1);


//                   if(current_count>=end_count&&current_count<end_count+15000)


//                        break;


//               };


//               if(status_reg==0xffffffff)


//               {


//                  NVIC_SystemReset();


//               }


//               if (status_reg & SYS_STATUS_RXFCG)//如果成功接收


//                  {


//                     dwt_write32bitreg(SYS_STATUS_ID, SYS_STATUS_RXFCG | SYS_STATUS_TXFRS);//清楚寄存器标志位


//                     frame_len = dwt_read32bitreg(RX_FINFO_ID) & RX_FINFO_RXFLEN_MASK;   //获得接收到的数据长度


//                     dwt_readrxdata(rx_buffer, frame_len, 0);   //读取接收数据


//                            test2 = dwt_readcarrierintegrator();


//                     dwt_setrxtimeout(0);//DELAY_BETWEEN_TWO_FRAME_UUS*(nearbase_num+1-recbase_num)+10);//设定接收超时时间，0位没有超时时间


//                     dwt_rxenable(0);//打开接收


//                     if (rx_buffer[MESSAGE_TYPE_IDX] == MBX_RESPONSE&&!memcmp(&rx_buffer[TAG_ID_IDX],&dev_id,2)&&rx_buffer[GROUP_ID_IDX]==group_id) //判断接收到的数据是否是response数据


//                     {	


//                        poll_tx_ts = get_tx_timestamp_u64();                              //获得POLL发送时间T1


//                        resp_rx_ts = get_rx_timestamp_u64();                              //获得RESPONSE接收时间T4	


//                        recbase_num++;


//                        memcpy(&rec_nearbaseid,&rx_buffer[ANCHOR_ID_IDX],2);


//                                rec_remotepara_state = rx_buffer[MOTORSTATE_INDEX]>>4;


//                                TagFreqProcess(rx_buffer[TAGFREQ_IDX]);


//                                if(rec_remotepara_state != 0)


//                                {   


//                                    para_update = rec_remotepara_state;


//                                    memcpy(rec_remotepara,&rx_buffer[REMOTEPARA_INDEX],7);


//                                    if(para_update==2)


//                                    {


//                                        flag_ancreadpara = 1;                                     


//                                    }


//                                }


//                        if(last_nearbase_num==0)


//                        {


//                           get_newbase=1;


//                           nearbaseid_list[0]=rec_nearbaseid;


//                           nearbase_num=1;


//                           memcpy(&tx_near_msg[ANCHOR_ID_IDX],&rec_nearbaseid,2);


//                        }


//                        if(rec_nearbaseid==nearbaseid_list[0])


//                        {


//                                     exsistbase_list[0]=KEEP_TIMES;


//                                   SetANCTimestap(0,&rx_buffer[RESP_MSG_POLL_RX_TS_IDX],&rx_buffer[RESP_MSG_RESP_TX_TS_IDX],resp_rx_ts,&rx_buffer[RESP_MSG_ANC_DISTOFFSET]);




   dwt_write32bitreg(SYS_STATUS_ID, SYS_STATUS_ALL_RX_ERR);


//                           //////////////////////////////////时间同步


//                           memcpy(&sync_timer,&rx_buffer[ANCTIMEMS],2);


//                           memcpy(&tmp_time,&rx_buffer[ANCTIMEUS],2);


//                           current_count=HAL_LPTIM_ReadCounter(&hlptim1);


////                           memcpy(&tagslotpos,&rx_buffer[TAGSLOTPOS],2);		


//                           tmp_time=tmp_time+450;


//                           if(tmp_time>999)


//                           {


//                              tmp_time-=999;


//                              sync_timer++;


//                              if(sync_timer>=1010)


//                                 {sync_timer=0;}


//                           }


//                           rec_nearbasepos=0;


//                           exsistbase_list[rec_nearbasepos]=KEEP_TIMES;




//                           if((rx_buffer[MOTORSTATE_INDEX]&0xf)!=3)


//                              motor_state=rx_buffer[MOTORSTATE_INDEX]&0xf;


//									


//									


//                           mainbase_lost_count=0;


//                           flag_finalsend=1;


//                           memcpy(&mainbase_dist,&rx_buffer[DIST_IDX],4);


//                           final_tx_time = (resp_rx_ts + ((RESP_RX_TO_FINAL_TX_DLY_UUS+DELAY_BETWEEN_TWO_FRAME_UUS*nearbase_num+500) * UUS_TO_DWT_TIME)) >> 8;


//                           temp1=final_tx_time-((850*UUS_TO_DWT_TIME)>>8);


//                           temp2=final_tx_time+((100*UUS_TO_DWT_TIME)>>8);


//                        //   dwt_setdelayedtrxtime(final_tx_time);//设置final包发送时间T5


//                           final_tx_ts = (((uint64_t)(final_tx_time & 0xFFFFFFFE)) << 8) + TX_ANT_DLY;//final包实际发送时间是计算时间加上发送天线delay


//                           final_msg_set_ts(&tx_near_msg[FINAL_MSG_POLL_TX_TS_IDX], poll_tx_ts);//将T1，T4，T5写入发送数据


//                           final_msg_set_ts(&tx_near_msg[FINAL_MSG_RESP_RX_NEARBASE_IDX], resp_rx_ts);


//                           final_msg_set_ts(&tx_near_msg[FINAL_MSG_FINAL_TX_TS_IDX], final_tx_ts);


//                           tx_near_msg[MESSAGE_TYPE_IDX]=MBX_FINAL;


//                                    tx_near_msg[GROUP_ID_IDX] = group_id;


//									


//                           dwt_writetxdata(28+nearbase_num*4, tx_near_msg, 0);//将发送数据写入DW1000


//                           dwt_writetxfctrl(28+nearbase_num*4, 0);//设定发送数据长度


//                           flag_getresponse=1;


//                           memcpy(&rec_tagpos_binary,&rx_buffer[NEARMSG_EMPTYSLOTPOS_INDEX],4);


//                        }else{


//                           rec_nearbasepos=FindNearBasePos(rec_nearbaseid);


//                           SetANCTimestap(rec_nearbasepos,&rx_buffer[RESP_MSG_POLL_RX_TS_IDX],&rx_buffer[RESP_MSG_RESP_TX_TS_IDX],resp_rx_ts,&rx_buffer[RESP_MSG_ANC_DISTOFFSET]);




}


//                           if(rec_nearbasepos>=last_nearbase_num)          //发现新的基站


//                           {


//                              get_newbase=1;


//                              nearbase_num++;


//                              nearbaseid_list[rec_nearbasepos] = rec_nearbaseid;


//                              memcpy(&tx_near_msg[ANCHOR_ID_IDX],&rec_nearbaseid,2);


//                           }


//									


//                           exsistbase_list[rec_nearbasepos]=KEEP_TIMES;




void GetNearMsg(void)


{


   u32 start_poll,frame_len;


   memcpy(&tx_near_msg[ANCHOR_ID_IDX],&mainbase_id,2);


   memcpy(&tx_near_msg[TAG_ID_IDX],&dev_id,2);


   tx_near_msg[MESSAGE_TYPE_IDX] = NEAR_MSG;


	


   dwt_setrxaftertxdelay(POLL_TX_TO_RESP_RX_DLY_UUS);         //设置发送后开启接收，并设定延迟时间


  dwt_setrxtimeout(RESP_RX_TIMEOUT_UUS);	


   dwt_writetxdata(12, tx_near_msg, 0);//将Poll包数据传给DW1000，将在开启发送时传出去


   dwt_writetxfctrl(12, 0);//设置超宽带发送数据长度


   dwt_starttx(DWT_START_TX_IMMEDIATE| DWT_RESPONSE_EXPECTED);




   /* We assume that the transmission is achieved correctly, poll for reception of a frame or error/timeout. See NOTE 8 below. */


   while (!((status_reg = dwt_read32bitreg(SYS_STATUS_ID)) & (SYS_STATUS_RXFCG | SYS_STATUS_ALL_RX_ERR)))//不断查询芯片状态直到成功接收或者发生错误


   {


   };


   if(status_reg==0xffffffff)


   {


      NVIC_SystemReset();


   }


   if (status_reg & SYS_STATUS_RXFCG)//如果成功接收


   {


      dwt_write32bitreg(SYS_STATUS_ID, SYS_STATUS_RXFCG | SYS_STATUS_TXFRS);//清楚寄存器标志位


      frame_len = dwt_read32bitreg(RX_FINFO_ID) & RX_FINFO_RXFLEN_MASK;   //获得接收到的数据长度


      dwt_readrxdata(rx_buffer, frame_len, 0);   //读取接收数据


      if (rx_buffer[MESSAGE_TYPE_IDX] == NEAR_MSG&&!memcmp(&rx_buffer[TAG_ID_IDX],&dev_id,2)) //判断接收到的数据是否是response数据


      {


         nearbase_num=rx_buffer[NEARBASENUM_INDEX];


         tagslotpos=rx_buffer[TAGSLOTPOS];


         memcpy(nearbaseid_list,&rx_buffer[NEARBASEID_INDEX],nearbase_num*2);


         slottime=ceil((nearbase_num+2)*0.3)+1;


         tyncpoll_time=tagslotpos*slottime;


         tag_state=NEARPOLL;


      }


   }


}




void Tag_App(void)//发送模式(TAG标签)


{


   //LED0_ON;


   dwt_forcetrxoff();


   g_Resttimer=0;


   switch(tag_state)


   {


      case DISCPOLL:


         Poll();


         break;


      case GETNEARMSG:


      //   if(trygetnearmsg_times--!=0)


         {GetNearMsg();


         }


//         else{


//            tag_state=DISCPOLL;


//									


//                           if(motor_state<(rx_buffer[MOTORSTATE_INDEX]&0xf)&&(rx_buffer[MOTORSTATE_INDEX]&0xf)!=3)


//                           {


//                                 motor_state=rx_buffer[MOTORSTATE_INDEX];


//                           }


//                           final_msg_set_ts(&tx_near_msg[FINAL_MSG_RESP_RX_NEARBASE_IDX+(rec_nearbasepos)*4], resp_rx_ts);		


//               


//                           dwt_writetxdata(28+nearbase_num*4, tx_near_msg, 0);//将发送数据写入DW1000


//                           dwt_writetxfctrl(28+nearbase_num*4, 0);//设定发送数据长度


//                        }								


//                     }


//                  }else{


//                  dwt_write32bitreg(SYS_STATUS_ID,SYS_STATUS_RXFCG| SYS_STATUS_ALL_RX_ERR);


//                  if(flag_rxon)


//                     {dwt_rxenable(0);	


//                     }								


//                  }			


//               //   dwt_write32bitreg(SYS_STATUS_ID,SYS_STATUS_RXFCG| SYS_STATUS_ALL_RX_ERR);


//         }


	 


         break;


      case NEARPOLL:


         //GPIO_WriteBit(EU_TX_GPIO, EU_RX_PIN, Bit_SET);


         NearPoll();


         //GPIO_WriteBit(EU_TX_GPIO, EU_RX_PIN, Bit_RESET);


         break;


   }


}


//            dwt_forcetrxoff();


//            dwt_write32bitreg(SYS_STATUS_ID,SYS_STATUS_RXFCG| SYS_STATUS_ALL_RX_ERR);


//            CalculateDists();


//            j = 0;


//            next_nearbase_num = 0;


//         for(i=0;i<nearbase_num;i++)


//         {


//            if(exsistbase_list[i]>0)


//            {	


//                    exsistbase_list[i]--;	


//               next_nearbase_num++;


//               true_exsistbase_list[j]=exsistbase_list[i];


//               true_nearbase_idlist[j]=nearbaseid_list[i];			


//               true_nearbase_distlist[j++]=nearbase_distlist[i];


//					


//            }


//         }


//            nearbase_num = next_nearbase_num;


//            if(mainbase_lost_count>1&&exsistbase_list[0] != 0)


//         {


//                last_lpcount+= HAL_LPTIM_ReadCounter(&hlptim1)%(g_com_map[COM_INTERVAL]*16);


//         }


//            last_nearbase_num = next_nearbase_num;


//         for(i=0;i<last_nearbase_num-1;i++)


//         {


//            for(j=0;j<last_nearbase_num-1;j++)


//            {


//               if(true_nearbase_distlist[j]>true_nearbase_distlist[j+1])


//               {


//                  u32 temp_dist,temp_id,temp_exsis;


//                  temp_dist=true_nearbase_distlist[j];


//                  temp_id = true_nearbase_idlist[j];


//                  temp_exsis=true_exsistbase_list[i];


//                  true_nearbase_distlist[j]=true_nearbase_distlist[j+1];


//                  true_nearbase_idlist[j]=true_nearbase_idlist[j+1];


//                  true_exsistbase_list[j]=true_exsistbase_list[j+1];


//						


//                  true_nearbase_distlist[j+1]=temp_dist;


//                  true_nearbase_idlist[j+1]=temp_id;


//                  true_exsistbase_list[j+1]=temp_exsis;


//               }			


//            }


//         }


//			


//         report_num=0;


//   for (i=0;i<last_nearbase_num;i++)


//         {


//            nearbaseid_list[i]=true_nearbase_idlist[i];


//            nearbase_distlist[i]=true_nearbase_distlist[i];


//                exsistbase_list[i] = true_exsistbase_list[i];


//         }


//            


//   dwt_write32bitreg(SYS_STATUS_ID, SYS_STATUS_ALL_RX_ERR| SYS_STATUS_TXFRS |SYS_STATUS_RXFCG);


////HAL_GPIO_WritePin(LED0_GPIO, GPIO_PIN_9, GPIO_PIN_RESET);


//            


//if(para_update==1)


//    {   


//        uint16_t calCRC;


//        calCRC = CRC_Compute(rec_remotepara,5);


//        if(memcmp(&calCRC,&rec_remotepara[5],2)==0)


//        {   uint8_t pack_msgtype,pack_index,pack_length;


//            pack_msgtype = rec_remotepara[0];


//            pack_index = rec_remotepara[1];


//            pack_length = rec_remotepara[2];


//            if(pack_msgtype==2)


//            {


//                if( pack_index == 1)//MOTOR_ONTIME_INDEX)


//                {


//               


//               //     motor_keeptime = rec_remotepara[3];


//                }else if(pack_index == CNT_UPDATE)


//                        {


//                              if(rec_remotepara[3]==2)


//                              {


//                                     EnterUWBUpdateMode();


//                              }


//                        }								


//                           else{


//                    if(pack_index<200)


//                    {


//                        memcpy((uint8_t*)&g_com_map + pack_index, &rec_remotepara[3], pack_length);


//                        //返回一个error状态


//                        //SendComMap(pack_datalen,pack_index);


//                        save_com_map_to_flash();


//                        delay_ms(100);


//                        NVIC_SystemReset();


//                    }


//                }


//            }


//        }


//    }


//}


//u8 regpoll_count;


//u32 id;


//void Tag_App(void)//发送模式(TAG标签)


//{


//	


//   //LED0_ON;


//   id =  dwt_readdevid() ;


//   while (DWT_DEVICE_ID != id) 


//    {


//        u8 iderror_count = 0;


//        id =  dwt_readdevid() ;


//        if(iderror_count++>100)


//        {


//            printf("UWB芯片ID错误");


//            break;


//        }


//    }


//    delay_us(100);


//   g_Resttimer=0;


//    if(freqlost_count>FREQ_LOST_TIME)


//    {


//        if(regpoll_count++>11) //待机状态1分钟上传一次基站状态


//        {


//            regpoll_count = 0;


//            Registor_Poll();


//        }


//    }else{


//        if(regpoll_count++>59)//测距状态1分钟上传一次基站状态


//        {


//            regpoll_count = 0;


//            Registor_Poll();


//        }


//    }


//   NearPoll();


//   dwt_entersleep();


//    bat_percent=Get_VDDVlotage();


//}