F103基站代码
blame | 历史 | 补丁 | 提交 | 提交对比 | 忽略空白
zhyinch
2019-11-04 45511597788e2eea3abb66f9363682cf1ed96caa 
 Ô´Âë/ºËÐÄ°å/Src/application/dw_app.c


@@ -3,12 +3,7 @@


 *  @file    main.c


 *  @brief   Double-sided two-way ranging (DS TWR) initiator example code


 *


 *           This is a simple code example which acts as the initiator in a DS TWR distance measurement exchange. This application sends a "poll"


 *           frame (recording the TX time-stamp of the poll), and then waits for a "response" message expected from the "DS TWR responder" example


 *           code (companion to this application). When the response is received its RX time-stamp is recorded and we send a "final" message to


 *           complete the exchange. The final message contains all the time-stamps recorded by this application, including the calculated/predicted TX


 *           time-stamp for the final message itself. The companion "DS TWR responder" example application works out the time-of-flight over-the-air


 *           and, thus, the estimated distance between the two devices.


 *         


 *


 * @attention


 *


@@ -51,9 +46,9 @@


#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 1500


#define RESP_RX_TO_FINAL_TX_DLY_UUS 400


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


#define RESP_RX_TIMEOUT_UUS 2700


#define RESP_RX_TIMEOUT_UUS 600




#define POLL_RX_TO_RESP_TX_DLY_UUS 420


/* 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. */


@@ -64,22 +59,31 @@


#define SPEED_OF_LIGHT 299702547




/* Indexes to access some of the fields in the frames defined above. */


#define ALL_MSG_SN_IDX 2


#define FINAL_MSG_POLL_TX_TS_IDX 10


#define FINAL_MSG_RESP_RX_TS_IDX 14


#define FINAL_MSG_FINAL_TX_TS_IDX 18


#define FINAL_MSG_TS_LEN 4




#define SYNC_SEQ_IDX             5




#define GROUP_ID_IDX               0


#define ANCHOR_ID_IDX             1


#define TAG_ID_IDX                3


#define MESSAGE_TYPE_IDX          5


#define DIST_IDX                      6


#define ANC_TYPE_IDX                7


#define TAG_ID_IDX                5


#define MESSAGE_TYPE_IDX          9	


#define DIST_IDX                      10


//Poll


#define ANC_TYPE_IDX                14


#define BATTARY_IDX                  15


#define BUTTON_IDX                  16


#define SEQUENCE_IDX               17


//respose


#define ANCTIMEMS             14


#define ANCTIMEUS             16




#define POLL                    0x01


#define RESPONSE                0x02


#define FINAL                  0x03


#define SYNC                     0x04




/*------------------------------------ Variables ------------------------------------------*/


/* Default communication configuration. We use here EVK1000's default mode (mode 3). */


@@ -97,12 +101,13 @@


};




/* Frames used in the ranging process. See NOTE 2 below. */


static uint8_t tx_poll_msg[] = {0x00, 0x88, 0, 0xCA, 0xDE, 'W', 'A', 'V', 'E', 0x21, 0, 0};


static uint8_t tx_poll_msg[20] = {0};


static uint8_t tx_sync_msg[14] = {0};


//static uint8_t rx_resp_msg[] = {0x41, 0x88, 0, 0xCA, 0xDE, 'V', 'E', 'W', 'A', 0x10, 0x02, 0, 0, 0, 0};


static uint8_t tx_final_msg[] = {0x41, 0x88, 0, 0xCA, 0xDE, 'W', 'A', 'V', 'E', 0x23, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};


   


//static uint8_t rx_poll_msg[] = {0x00, 0x88, 0, 0xCA, 0xDE, 'W', 'A', 'V', 'E', 0x21, 0, 0};


static uint8_t tx_resp_msg[] = {0x41, 0x88, 0, 0xCA, 0xDE, 'V', 'E', 'W', 'A', 0x10, 0x02, 0, 0, 0, 0};


static uint8_t tx_resp_msg[20] = {0};


//static uint8_t rx_final_msg[] = {0x41, 0x88, 0, 0xCA, 0xDE, 'W', 'A', 'V', 'E', 0x23, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};


   


/* Frame sequence number, incremented after each transmission. */


@@ -129,9 +134,9 @@




static double tof;


   


uint16_t anchor_dist_last_frm[TAG_NUM_IN_SYS];	


uint8_t tag_id = 0;


uint8_t tag_id_recv = 0;


uint32_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;


uint8_t random_delay_tim = 0;




double distance, dist_no_bias, dist_cm;


@@ -140,7 +145,7 @@


float dis_after_filter;            //当前距离值


LPFilter_Frac* p_Dis_Filter;      //测距用的低通滤波器




uint16_t g_Tagdist[256];


uint16_t g_Tagdist[TAG_NUM_IN_SYS];


uint8_t g_flag_Taggetdist[256];


/*------------------------------------ Functions ------------------------------------------*/




@@ -246,8 +251,9 @@


     * 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(SPI_BaudRatePrescaler_64);   //设置为快速模式


    dwt_initialise(DWT_LOADUCODE);//初始化DW1000


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


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




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


    dwt_configure(&config);//配置DW1000


@@ -260,8 +266,7 @@




    /* 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. */


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


    dwt_setrxtimeout(RESP_RX_TIMEOUT_UUS);                  //设置接收超时时间


            //设置接收超时时间


}


void Dw1000_App_Init(void)


{


@@ -269,36 +274,70 @@


   tx_poll_msg[MESSAGE_TYPE_IDX]=POLL;


   tx_resp_msg[MESSAGE_TYPE_IDX]=RESPONSE;


   tx_final_msg[MESSAGE_TYPE_IDX]=FINAL;


   memcpy(&tx_poll_msg[TAG_ID_IDX], &g_com_map[DEV_ID], 2);


   memcpy(&tx_final_msg[TAG_ID_IDX], &g_com_map[DEV_ID], 2);


   memcpy(&tx_resp_msg[ANCHOR_ID_IDX], &g_com_map[DEV_ID], 2);


   tx_sync_msg[MESSAGE_TYPE_IDX]=SYNC;


   


   memcpy(&tx_poll_msg[TAG_ID_IDX], &dev_id, 4);


   memcpy(&tx_final_msg[TAG_ID_IDX], &dev_id, 4);


   memcpy(&tx_resp_msg[ANCHOR_ID_IDX], &dev_id, 4);


   memcpy(&tx_sync_msg[ANCHOR_ID_IDX], &dev_id, 4);


}   


uint16_t Checksum_u16(uint8_t* pdata, uint32_t len) 


{


    uint16_t sum = 0;


    uint32_t i;


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


        sum += pdata[i];


    sum = ~sum;


    return sum;


}




u16 tag_time_recv[TAG_NUM_IN_SYS];


u8 usart_send[25];


u8 battary,button;


extern uint8_t g_pairstart;


void tag_sleep_configuraion(void)


{


   dwt_configuresleep(0x940, 0x7);


   dwt_entersleep();


}


extern uint8_t g_start_send_flag;


u8 g_start_sync_flag;


void SyncPoll(u8 sync_seq)


{


   g_start_sync_flag=1;


   dwt_forcetrxoff();


   tx_sync_msg[SYNC_SEQ_IDX]=sync_seq;


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


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


   dwt_starttx(DWT_START_TX_IMMEDIATE);


}


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;


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


{


   uint32_t frame_len;


   uint32_t final_tx_time;


   u32 start_poll;


   u8 i;


	


   u8 i,getsync_flag=0;


   //LED0_ON;


   dwt_forcetrxoff();


   g_Resttimer=0;


   UART_CheckReceive();


   GPIO_ResetBits(SPIx_GPIO, SPIx_CS);


   delay_us(2500);


   GPIO_SetBits(SPIx_GPIO, SPIx_CS);


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


    dwt_setrxtimeout(RESP_RX_TIMEOUT_UUS);		


   tag_succ_times = 0;


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


   tx_poll_msg[BATTARY_IDX] = Get_Battary();


   tx_poll_msg[BUTTON_IDX] = !READ_KEY0;


   tx_poll_msg[SEQUENCE_IDX] = frame_seq_nb++;


   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[ALL_MSG_SN_IDX] = frame_seq_nb;


   tx_poll_msg[ANC_TYPE_IDX] = i;


      


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


@@ -312,11 +351,11 @@


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


   { if(time32_incr - start_poll>20)


      NVIC_SystemReset();


	


      UART_CheckReceive();


		


   };




   /* Increment frame sequence number after transmission of the poll message (modulo 256). */


   frame_seq_nb++;


   if(status_reg==0xffffffff)


   {


      NVIC_SystemReset();


@@ -335,15 +374,30 @@




      /* Check that the frame is the expected response from the companion "DS TWR responder" example.


       * As the sequence number field of the frame is not relevant, it is cleared to simplify the validation of the frame. */


      rx_buffer[ALL_MSG_SN_IDX] = 0;


      if (rx_buffer[MESSAGE_TYPE_IDX] == RESPONSE&&rx_buffer[TAG_ID_IDX]==g_com_map[DEV_ID]) //判断接收到的数据是否是response数据


		


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


      {


         /* Retrieve poll transmission and response reception timestamp. */


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


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


         


         memcpy(&anchor_dist_last_frm[tag_id], &rx_buffer[DIST_IDX], 2);


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


         if(getsync_flag==0)


         {


            getsync_flag=1;


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


         memcpy(&tmp_time,&rx_buffer[ANCTIMEUS],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;


      }


         memcpy(&anchor_dist_last_frm[0], &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


@@ -357,13 +411,29 @@


         final_msg_set_ts(&tx_final_msg[FINAL_MSG_FINAL_TX_TS_IDX], final_tx_ts);




         /* Write and send final message. See NOTE 7 below. */


         tx_final_msg[ALL_MSG_SN_IDX] = frame_seq_nb;


		


         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;


			


					


               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],&rx_buffer[ANCHOR_ID_IDX],2);


               hex_dist = anchor_dist_last_frm[0]+(int16_t)g_com_map[DIST_OFFSET];


               memcpy(&usart_send[9],&hex_dist,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);




         /* Poll DW1000 until TX frame sent event set. See NOTE 8 below. */


         if(result==0)


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


@@ -373,7 +443,7 @@


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




         /* Increment frame sequence number after transmission of the final message (modulo 256). */


         frame_seq_nb++;		




         random_delay_tim = 0;


      }


      else


@@ -389,31 +459,18 @@


   }


//   deca_sleep(10);


}


   if(tag_succ_times!=REPOET_ANC_NUM)


//   dwt_entersleep();


   if(tag_succ_times<g_com_map[MIN_REPORT_ANC_NUM])


   {


   random_delay_tim =g_com_map[DEV_ID]*13+7;


   }else{


      random_delay_tim=0;


   //poll_timer +=time32_incr&0x7+3;


   }


   LED0_BLINK;


   deca_sleep(random_delay_tim);


   RTC_SET_ALARM(1);


   /* Execute a delay between ranging exchanges. */


   dwt_entersleep();


}


uint16_t Checksum_u16(uint8_t* pdata, uint32_t len) 


{


    uint16_t sum = 0;


    uint32_t i;


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


        sum += pdata[i];


    sum = ~sum;


    return sum;


}




u16 tag_time_recv[TOTAL_TAG_NUM];


u8 usart_send[16];


extern uint8_t g_pairstart;


   /* Execute a delay between ranging exchanges. */


	


}


int8_t correction_time;


extern uint8_t sync_seq;




void Anchor_App(void)


{


   uint32_t frame_len;


@@ -426,10 +483,9 @@


   dwt_rxenable(0);//打开接收




   /* Poll for reception of a frame or error/timeout. See NOTE 7 below. */


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


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


   { 


      UART_CheckReceive();


      UART_CheckSend();


      IdleTask();


      g_Resttimer=0;


   };




@@ -446,19 +502,28 @@




      /* Check that the frame is a poll sent by "DS TWR initiator" example.


       * As the sequence number field of the frame is not relevant, it is cleared to simplify the validation of the frame. */


      rx_buffer[ALL_MSG_SN_IDX] = 0;


	


      


      //将收到的tag_id分别写入各次通讯的包中，为多标签通讯服务，防止一次通讯中接收到不同ID标签的数据


      tag_id_recv = rx_buffer[TAG_ID_IDX];


      tx_resp_msg[TAG_ID_IDX] = tag_id_recv;


      if(tag_recv_timer>tag_time_recv[tag_id_recv])


      {   tag_recv_interval =  tag_recv_timer - tag_time_recv[tag_id_recv];


      }else{


         tag_recv_interval = tag_recv_timer + 65535 - tag_time_recv[tag_id_recv];


      }


      //tag_id_recv = rx_buffer[TAG_ID_IDX];


      memcpy(&tag_id_recv,&rx_buffer[TAG_ID_IDX],4);


      memcpy(&tx_resp_msg[TAG_ID_IDX],&tag_id_recv,4);


      //tx_resp_msg[TAG_ID_IDX] = tag_id_recv;


//      if(tag_recv_timer>tag_time_recv[tag_id_recv-TAG_ID_START])


//      {   tag_recv_interval =  tag_recv_timer - tag_time_recv[tag_id_recv];


//      }else{


//         tag_recv_interval = tag_recv_timer + 65535 - tag_time_recv[tag_id_recv];


//      }


      


      if (rx_buffer[MESSAGE_TYPE_IDX] == POLL&&tag_id_recv!= g_com_map[PAIR_ID]&&(tag_recv_interval>g_com_map[COM_INTERVAL]/2)&&(g_com_map[DEV_ID]%REPOET_ANC_NUM == rx_buffer[ANC_TYPE_IDX])) //判断是否是poll包数据


      if (rx_buffer[MESSAGE_TYPE_IDX] == POLL&&(anchor_type == rx_buffer[ANC_TYPE_IDX])) //判断是否是poll包数据


      {


         tmp_time=TIM3->CNT;


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


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




//                     if(correction_time>10)


//                     {correction_time++;}


							


         /* Retrieve poll reception timestamp. */


         poll_rx_ts = get_rx_timestamp_u64();//获得Poll包接收时间T2




@@ -471,12 +536,16 @@


         dwt_setrxtimeout(FINAL_RX_TIMEOUT_UUS);//接收超时时间




         /* Write and send the response message. See NOTE 9 below.*/


         memcpy(&tx_resp_msg[DIST_IDX], &anchor_dist_last_frm[tag_id_recv], 2);


         tx_resp_msg[ALL_MSG_SN_IDX] = frame_seq_nb;


         if(tag_id_recv-TAG_ID_START<=TAG_NUM_IN_SYS)


         memcpy(&tx_resp_msg[DIST_IDX], &anchor_dist_last_frm[tag_id_recv-TAG_ID_START], 4);


		


         dwt_writetxdata(sizeof(tx_resp_msg), tx_resp_msg, 0);//写入发送数据


         dwt_writetxfctrl(sizeof(tx_resp_msg), 0);//设定发送长度


         result = dwt_starttx(DWT_START_TX_DELAYED | DWT_RESPONSE_EXPECTED);//延迟发送，等待接收




         battary = rx_buffer[BATTARY_IDX];


         button = rx_buffer[BUTTON_IDX];


         frame_seq_nb = rx_buffer[SEQUENCE_IDX];


         /* We assume that the transmission is achieved correctly, now poll for reception of expected "final" frame or error/timeout.


          * See NOTE 7 below. */


         if(result==0)


@@ -485,7 +554,6 @@


         { };


      }


         /* Increment frame sequence number after transmission of the response message (modulo 256). */


         frame_seq_nb++;




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


         {


@@ -500,15 +568,14 @@




            /* Check that the frame is a final message sent by "DS TWR initiator" example.


             * As the sequence number field of the frame is not used in this example, it can be zeroed to ease the validation of the frame. */


            rx_buffer[ALL_MSG_SN_IDX] = 0;


            if (rx_buffer[MESSAGE_TYPE_IDX] == FINAL&&rx_buffer[TAG_ID_IDX]==tag_id_recv&&rx_buffer[ANCHOR_ID_IDX]==g_com_map[DEV_ID]) //判断是否为Final包


			


            if (rx_buffer[MESSAGE_TYPE_IDX] == FINAL&&!memcmp(&rx_buffer[TAG_ID_IDX],&tag_id_recv,4)&&!memcmp(&rx_buffer[ANCHOR_ID_IDX],&dev_id,4)) //判断是否为Final包


            {


               uint32_t poll_tx_ts, resp_rx_ts, final_tx_ts;


               uint32_t poll_rx_ts_32, resp_tx_ts_32, final_rx_ts_32;


               double Ra, Rb, Da, Db;


               int64_t tof_dtu;


               u32 hex_dist;


               u16 checksum;


					


               /* Retrieve response transmission and final reception timestamps. */


               resp_tx_ts = get_tx_timestamp_u64();//获得response发送时间T3


               final_rx_ts = get_rx_timestamp_u64();//获得final接收时间T6


@@ -539,36 +606,45 @@


               LED0_BLINK; //每成功一次通讯则闪烁一次


               g_UWB_com_interval = 0;


               dis_after_filter=dist_cm;


               g_Tagdist[tag_id_recv]=dist_cm;


//               if(g_pairstart==1&&dist_cm<20)


//               {


//                  g_pairstart=0;


//                  g_com_map[PAIR_ID]=tag_id_recv;


//                  save_com_map_to_flash();


//                  BEEP2_ON;


//                  delay_ms(1000);


//                  printf("Pair Finish PairID: %d. \r\n",g_com_map[PAIR_ID]);


//               }


                tag_time_recv[tag_id_recv] = tag_recv_timer;


               g_flag_Taggetdist[tag_id_recv]=0;


               #ifdef HEX_OUTPUT


               usart_send[2] = frame_seq_nb;


               usart_send[6] = g_com_map[DEV_ID];


               usart_send[8] = tag_id_recv;


               hex_dist = dist_cm;


               memcpy(&usart_send[10],&hex_dist,4);


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


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


               UART_PushFrame(usart_send,16);


               #else


               printf("Anchor ID: %d, Tag ID: %d, Dist = %d cm\n", g_com_map[DEV_ID], tag_id_recv, (uint16_t)dis_after_filter);


               #endif


               hex_dist = (int16_t)(dist_cm+g_com_map[DIST_OFFSET]);


                  if(tag_id_recv-TAG_ID_START<=TAG_NUM_IN_SYS)


               if(abs(hex_dist-his_dist[tag_id_recv-TAG_ID_START])<1000)


               {


                  g_Tagdist[tag_id_recv-TAG_ID_START] = hex_dist;


                  anchor_dist_last_frm[tag_id_recv-TAG_ID_START] = hex_dist;


               }


               his_dist[tag_id_recv-TAG_ID_START]=hex_dist;


						


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


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


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


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


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


					


               memcpy(&usart_send[9],&anchor_dist_last_frm[tag_id_recv-TAG_ID_START],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);




					


               //dis_after_filter = LP_Frac_Update(p_Dis_Filter, dist_cm);




            }


         }else{


            /* Clear RX error events in the DW1000 status register. */


            dwt_write32bitreg(SYS_STATUS_ID, SYS_STATUS_ALL_RX_ERR);


         }


      }else if(rx_buffer[MESSAGE_TYPE_IDX] == SYNC)


      {


         if(rx_buffer[SYNC_SEQ_IDX]<sync_seq)


      //   if(rx_buffer[SYNC_SEQ_IDX]==2)


         {


            sync_seq=rx_buffer[SYNC_SEQ_IDX]+1;


            TIM3->CNT = sync_seq*325%1000+15;


            sync_timer = sync_seq*325/1000;


            SyncPoll(sync_seq);


         }


      }


   }


@@ -579,66 +655,3 @@


   }


}




/*****************************************************************************************************************************************************


 * NOTES:


 *


 * 1. The sum of the values is the TX to RX antenna delay, experimentally determined by a calibration process. Here we use a hard coded typical value


 *    but, in a real application, each device should have its own antenna delay properly calibrated to get the best possible precision when performing


 *    range measurements.


 * 2. The messages here are similar to those used in the DecaRanging ARM application (shipped with EVK1000 kit). They comply with the IEEE


 *    802.15.4 standard MAC data frame encoding and they are following the ISO/IEC:24730-62:2013 standard. The messages used are:


 *     - a poll message sent by the initiator to trigger the ranging exchange.


 *     - a response message sent by the responder allowing the initiator to go on with the process


 *     - a final message sent by the initiator to complete the exchange and provide all information needed by the responder to compute the


 *       time-of-flight (distance) estimate.


 *    The first 10 bytes of those frame are common and are composed of the following fields:


 *     - byte 0/1: frame control (0x8841 to indicate a data frame using 16-bit addressing).


 *     - byte 2: sequence number, incremented for each new frame.


 *     - byte 3/4: PAN TAG_ID (0xDECA).


 *     - byte 5/6: destination address, see NOTE 3 below.


 *     - byte 7/8: source address, see NOTE 3 below.


 *     - byte 9: function code (specific values to indicate which message it is in the ranging process).


 *    The remaining bytes are specific to each message as follows:


 *    Poll message:


 *     - no more data


 *    Response message:


 *     - byte 10: activity code (0x02 to tell the initiator to go on with the ranging exchange).


 *     - byte 11/12: activity parameter, not used here for activity code 0x02.


 *    Final message:


 *     - byte 10 -> 13: poll message transmission timestamp.


 *     - byte 14 -> 17: response message reception timestamp.


 *     - byte 18 -> 21: final message transmission timestamp.


 *    All messages end with a 2-byte checksum automatically set by DW1000.


 * 3. Source and destination addresses are hard coded constants in this example to keep it simple but for a real product every device should have a


 *    unique TAG_ID. Here, 16-bit addressing is used to keep the messages as short as possible but, in an actual application, this should be done only


 *    after an exchange of specific messages used to define those short addresses for each device participating to the ranging exchange.


 * 4. Delays between frames have been chosen here to ensure proper synchronisation of transmission and reception of the frames between the initiator


 *    and the responder and to ensure a correct accuracy of the computed distance. The user is referred to DecaRanging ARM Source Code Guide for more


 *    details about the timings involved in the ranging process.


 * 5. This timeout is for complete reception of a frame, i.e. timeout duration must take into account the length of the expected frame. Here the value


 *    is arbitrary but chosen large enough to make sure that there is enough time to receive the complete response frame sent by the responder at the


 *    110k data rate used (around 3 ms).


 * 6. In a real application, for optimum performance within regulatory limits, it may be necessary to set TX pulse bandwidth and TX power, (using


 *    the dwt_configuretxrf API call) to per device calibrated values saved in the target system or the DW1000 OTP memory.


 * 7. dwt_writetxdata() takes the full size of the message as a parameter but only copies (size - 2) bytes as the check-sum at the end of the frame is


 *    automatically appended by the DW1000. This means that our variable could be two bytes shorter without losing any data (but the sizeof would not


 *    work anymore then as we would still have to indicate the full length of the frame to dwt_writetxdata()). It is also to be noted that, when using


 *    delayed send, the time set for transmission must be far enough in the future so that the DW1000 IC has the time to process and start the


 *    transmission of the frame at the wanted time. If the transmission command is issued too late compared to when the frame is supposed to be sent,


 *    this is indicated by an error code returned by dwt_starttx() API call. Here it is not tested, as the values of the delays between frames have


 *    been carefully defined to avoid this situation.


 * 8. We use polled mode of operation here to keep the example as simple as possible but all status events can be used to generate interrupts. Please


 *    refer to DW1000 User Manual for more details on "interrupts". It is also to be noted that STATUS register is 5 bytes long but, as the event we


 *    use are all in the first bytes of the register, we can use the simple dwt_read32bitreg() API call to access it instead of reading the whole 5


 *    bytes.


 * 9. As we want to send final TX timestamp in the final message, we have to compute it in advance instead of relying on the reading of DW1000


 *    register. Timestamps and delayed transmission time are both expressed in device time units so we just have to add the desired response delay to


 *    response RX timestamp to get final transmission time. The delayed transmission time resolution is 512 device time units which means that the


 *    lower 9 bits of the obtained value must be zeroed. This also allows to encode the 40-bit value in a 32-bit words by shifting the all-zero lower


 *    8 bits.


 * 10. In this operation, the high order byte of each 40-bit timestamps is discarded. This is acceptable as those time-stamps are not separated by


 *     more than 2**32 device time units (which is around 67 ms) which means that the calculation of the round-trip delays (needed in the


 *     time-of-flight computation) can be handled by a 32-bit subtraction.


 * 11. The user is referred to DecaRanging ARM application (distributed with EVK1000 product) for additional practical example of usage, and to the


 *     DW1000 API Guide for more details on the DW1000 driver functions.


 ****************************************************************************************************************************************************/