format all the code

guanjiao

2018-05-12 7bd852c98c52c306e3628acedc33149ebee3cff6

 Ô´Âë/ºËÐÄ°å/Src/main.c

@@ -32,7 +32,8 @@
#define RNG_DELAY_MS 100

/* Default communication configuration. We use here EVK1000's default mode (mode 3). */
static dwt_config_t config = {
static dwt_config_t config =
{
    2,               /* Channel number. */
    DWT_PRF_64M,     /* Pulse repetition frequency. */
    DWT_PLEN_1024,   /* Preamble length. */
@@ -51,7 +52,7 @@
static uint8 tx_resp_msg[] = {0x41, 0x88, 0, 0xCA, 0xDE, 'V', 'E', 'W', 'A', 0x10, 0x02, 0, 0, 0, 0};
static uint8 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};

	

/* Frames used in the ranging process. See NOTE 2 below. */
static uint8 tx_poll_msg[] = {0x00, 0x88, 0, 0xCA, 0xDE, 'W', 'A', 'V', 'E', 0x21, 0, 0};
static uint8 rx_resp_msg[] = {0x41, 0x88, 0, 0xCA, 0xDE, 'V', 'E', 'W', 'A', 0x10, 0x02, 0, 0, 0, 0};
@@ -64,7 +65,7 @@
static uint64 final_rx_ts;

static double tof;
static double distance,dist2;
static double distance, dist2;
int16_t dist[8];
#define ALL_MSG_COMMON_LEN 10
/* Indexes to access some of the fields in the frames defined above. */
@@ -80,7 +81,7 @@
 * Its size is adjusted to longest frame that this example code is supposed to handle. */
#define RX_BUF_LEN 20
#define RX_BUF_LEN2 24
static uint8 rx_buffer[RX_BUF_LEN+4];
static uint8 rx_buffer[RX_BUF_LEN + 4];

/* Hold copy of status register state here for reference, so reader can examine it at a breakpoint. */
static uint32 status_reg = 0;
@@ -125,7 +126,7 @@
 *
 * @return none
 */
 static void final_msg_get_ts(const uint8 *ts_field, uint32 *ts)
static void final_msg_get_ts(const uint8 *ts_field, uint32 *ts)
{
    int i;
    *ts = 0;
@@ -134,67 +135,67 @@
        *ts += ts_field[i] << (i * 8);
    }
}
 void GPIO_Toggle(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin)
void GPIO_Toggle(GPIO_TypeDef *GPIOx, uint16_t GPIO_Pin)
{
   GPIO_WriteBit(GPIOx, GPIO_Pin, (BitAction)!GPIO_ReadOutputDataBit(GPIOx, GPIO_Pin));
    GPIO_WriteBit(GPIOx, GPIO_Pin, (BitAction)!GPIO_ReadOutputDataBit(GPIOx, GPIO_Pin));
}
int fputc(int ch, FILE *f)

{

USART_SendData(USART1, (unsigned char) ch);// USART1 ???? USART2 ?
    USART_SendData(USART1, (unsigned char) ch);// USART1 ???? USART2 ?

while (!(USART1->SR & USART_FLAG_TXE));
    while (!(USART1->SR & USART_FLAG_TXE));

return (ch);
    return (ch);


}

void USART_putc(char c)
{
   //while(!(USART2->SR & 0x00000040));
   //USART_SendData(USART2,c);
   /* e.g. write a character to the USART */
   USART_SendData(USART1, c);
    //while(!(USART2->SR & 0x00000040));
    //USART_SendData(USART2,c);
    /* e.g. write a character to the USART */
    USART_SendData(USART1, c);

   /* Loop until the end of transmission */
   while (USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET)   ;
    /* Loop until the end of transmission */
    while (USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET)   ;
}

void USART_puts(uint8_t *s,uint8_t len)
void USART_puts(uint8_t *s, uint8_t len)
{
   int i;
   for(i=0; i<len; i++)
   {
      USART_putc(s[i]);
   }
    int i;
    for(i = 0; i < len; i++)
    {
        USART_putc(s[i]);
    }
}
int ld[100];
int LP(int tmp,uint8_t channel)
int LP(int tmp, uint8_t channel)
{
int data;
   data = 0.7*ld[channel]+0.3*tmp;
   ld[channel]=data;
   return data;
    int data;
    data = 0.7 * ld[channel] + 0.3 * tmp;
    ld[channel] = data;
    return data;
}
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;
    for(i=0; i<len; i++)
    for(i = 0; i < len; i++)
        sum += pdata[i];
    sum = ~sum;
    return sum;
}
void LED_blink(void)
{
   uint8_t ii;
   for (ii=0;ii<10;ii++)
{
   GPIO_Toggle(GPIOA,LED_PIN);
   deca_sleep(100);
}
    uint8_t ii;
    for (ii = 0; ii < 10; ii++)
    {
        GPIO_Toggle(GPIOA, LED_PIN);
        deca_sleep(100);
    }
}
extern volatile unsigned long time32_reset;
extern uint8_t Work_Mode;
@@ -203,16 +204,16 @@
char dist_str[16] = {0};
int32_t dis;
double dID;
uint8_t TAG_ID,ANCHOR_ID, jumptime=0;
uint32_t rec_dist,hex_dist;
uint8_t TAG_ID, ANCHOR_ID, jumptime = 0;
uint32_t rec_dist, hex_dist;
uint16_t check;
int main(void)
{
   RCC_ClocksTypeDef  RCC_Clocks;  /* Start with board specific hardware init. */
    RCC_ClocksTypeDef  RCC_Clocks;  /* Start with board specific hardware init. */
    peripherals_init();//初始化外设
RCC_GetClocksFreq(&RCC_Clocks); 
    RCC_GetClocksFreq(&RCC_Clocks);
    /* Display application name on LCD. */
  //  lcd_display_str(APP_NAME);
    //  lcd_display_str(APP_NAME);

    /* Reset and initialise DW1000.
     * For initialisation, DW1000 clocks must be temporarily set to crystal speed. After initialisation SPI rate can be increased for optimum
@@ -234,275 +235,283 @@
    dwt_setrxaftertxdelay(POLL_TX_TO_RESP_RX_DLY_UUS);//设置发送后开启接收，并设定延迟时间
    dwt_setrxtimeout(RESP_RX_TIMEOUT_UUS);                  //设置接收超时时间

      send[0]=0x6D;                                 //串口数据
      send[1]=0xD6;                                 //串口数据
    send[0] = 0x6D;                                 //串口数据
    send[1] = 0xD6;                                 //串口数据

      tx_poll_msg[6] = ANCHOR_ID;   //UWB POLL åŒ…数据
      rx_resp_msg[6] = ANCHOR_ID;   //UWB RESPONSE åŒ…数据
      tx_final_msg[6] = ANCHOR_ID;//UWB Fianl åŒ…数据
		
      rx_poll_msg[6] = ANCHOR_ID;
      tx_resp_msg[6] = ANCHOR_ID;
      rx_final_msg[6] = ANCHOR_ID;
		
      tx_poll_msg[5] = TAG_ID;//UWB POLL åŒ…数据
      rx_resp_msg[5] = TAG_ID;//UWB RESPONSE åŒ…数据
      tx_final_msg[5] = TAG_ID;//UWB Fianl åŒ…数据
    tx_poll_msg[6] = ANCHOR_ID;   //UWB POLL åŒ…数据
    rx_resp_msg[6] = ANCHOR_ID;   //UWB RESPONSE åŒ…数据
    tx_final_msg[6] = ANCHOR_ID;//UWB Fianl åŒ…数据

    rx_poll_msg[6] = ANCHOR_ID;
    tx_resp_msg[6] = ANCHOR_ID;
    rx_final_msg[6] = ANCHOR_ID;

    tx_poll_msg[5] = TAG_ID;//UWB POLL åŒ…数据
    rx_resp_msg[5] = TAG_ID;//UWB RESPONSE åŒ…数据
    tx_final_msg[5] = TAG_ID;//UWB Fianl åŒ…数据
    /* Loop forever initiating ranging exchanges. */
   LED_blink();
      if(!Work_Mode)   //选择发送模式（TAG标签）还是接收模式(ANCHOR基站)
      {
    while (1)         //发送模式(TAG标签)
    LED_blink();
    if(!Work_Mode)   //选择发送模式（TAG标签）还是接收模式(ANCHOR基站)
    {
        /* Write frame data to DW1000 and prepare transmission. See NOTE 7 below. */
        tx_poll_msg[ALL_MSG_SN_IDX] = frame_seq_nb;
        dwt_writetxdata(sizeof(tx_poll_msg), tx_poll_msg, 0);//将Poll包数据传给DW1000，将在开启发送时传出去
        dwt_writetxfctrl(sizeof(tx_poll_msg), 0);//设置超宽带发送数据长度

        /* Start transmission, indicating that a response is expected so that reception is enabled automatically after the frame is sent and the delay
         * set by dwt_setrxaftertxdelay() has elapsed. */
        dwt_starttx(DWT_START_TX_IMMEDIATE | DWT_RESPONSE_EXPECTED);//开启发送，发送完成后等待一段时间开启接收，等待时间在dwt_setrxaftertxdelay中设置

        /* 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)))//不断查询芯片状态直到成功接收或者发生错误
        { };

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

        if (status_reg & SYS_STATUS_RXFCG)//如果成功接收
        while (1)         //发送模式(TAG标签)
        {
            uint32 frame_len;
            /* Write frame data to DW1000 and prepare transmission. See NOTE 7 below. */
            tx_poll_msg[ALL_MSG_SN_IDX] = frame_seq_nb;
            dwt_writetxdata(sizeof(tx_poll_msg), tx_poll_msg, 0);//将Poll包数据传给DW1000，将在开启发送时传出去
            dwt_writetxfctrl(sizeof(tx_poll_msg), 0);//设置超宽带发送数据长度

            /* Clear good RX frame event and TX frame sent in the DW1000 status register. */
            dwt_write32bitreg(SYS_STATUS_ID, SYS_STATUS_RXFCG | SYS_STATUS_TXFRS);//清楚寄存器标志位
            /* Start transmission, indicating that a response is expected so that reception is enabled automatically after the frame is sent and the delay
             * set by dwt_setrxaftertxdelay() has elapsed. */
            dwt_starttx(DWT_START_TX_IMMEDIATE | DWT_RESPONSE_EXPECTED);//开启发送，发送完成后等待一段时间开启接收，等待时间在dwt_setrxaftertxdelay中设置

            /* A frame has been received, read it into the local buffer. */
            frame_len = dwt_read32bitreg(RX_FINFO_ID) & RX_FINFO_RXFLEN_MASK;   //获得接收到的数据长度
            /* 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)))//不断查询芯片状态直到成功接收或者发生错误
            { };

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

            if (status_reg & SYS_STATUS_RXFCG)//如果成功接收
            {
                uint32 frame_len;

                /* Clear good RX frame event and TX frame sent in the DW1000 status register. */
                dwt_write32bitreg(SYS_STATUS_ID, SYS_STATUS_RXFCG | SYS_STATUS_TXFRS);//清楚寄存器标志位

                /* A frame has been received, read it into the local buffer. */
                frame_len = dwt_read32bitreg(RX_FINFO_ID) & RX_FINFO_RXFLEN_MASK;   //获得接收到的数据长度

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


            /* 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[9]==0x10)//判断接收到的数据是否是response数据
            {
                uint32 final_tx_time;

							
                /* 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(&dist[TAG_ID],&rx_buffer[11],2);
							
                /* 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 timestamp is the transmission time we programmed plus the TX antenna delay. */
                final_tx_ts = (((uint64)(final_tx_time & 0xFFFFFFFE)) << 8) + TX_ANT_DLY;//final包实际发送时间是计算时间加上发送天线delay

                /* Write all timestamps in the final message. See NOTE 10 below. */
                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);

                /* 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);//设定发送数据长度
                dwt_starttx(DWT_START_TX_DELAYED);//设定为延迟发送

                        if (GPIO_ReadInputDataBit(GPIOA,SW2) != RESET)  //通过拨码开关判断数据输出格式
                                 {
                                    dID=TAG_ID;
                                    printf("TAG_ID: %2.0f      ", dID);
                                    dID=ANCHOR_ID;
                                    printf("ANCHOR_ID: %2.0f      ", dID);
                        printf("Distance: %5.0f cm\n", (double)dist[TAG_ID]);
                                 }else{
                                    send[2] = ANCHOR_ID;
                                    send[3] = TAG_ID;
												
                                    memcpy(&send[4],&dist[TAG_ID],2);
                                 check=Checksum_u16(&send[2],6);
                                    memcpy(&send[8],&check,2);
                                    USART_puts(send,10);
                                 }
                /* Poll DW1000 until TX frame sent event set. See NOTE 8 below. */
                while (!(dwt_read32bitreg(SYS_STATUS_ID) & SYS_STATUS_TXFRS))//不断查询芯片状态直到发送完成
                { };

                /* Clear TXFRS event. */
                dwt_write32bitreg(SYS_STATUS_ID, SYS_STATUS_TXFRS);//清楚标志位

                /* Increment frame sequence number after transmission of the final message (modulo 256). */
                frame_seq_nb++;
                        time32_reset = 0;
                        GPIO_Toggle(GPIOA,LED_PIN);//LED闪烁
                        jumptime = 0;
            }else{
                     jumptime =5;//如果通讯失败，将间隔时间增加5ms，避开因为多标签同时发送引起的冲突。
                  }
        }
        else
        {
            /* Clear RX error events in the DW1000 status register. */
            dwt_write32bitreg(SYS_STATUS_ID, SYS_STATUS_ALL_RX_ERR);
                  jumptime =5;
        }

        /* Execute a delay between ranging exchanges. */
        deca_sleep(RNG_DELAY_MS+jumptime);//休眠固定时间
    }
   }else{
      while (1)//接收模式(ANCHOR基站)
    {
        /* Clear reception timeout to start next ranging process. */
        dwt_setrxtimeout(0);//设定接收超时时间，0位没有超时时间

        /* Activate reception immediately. */
        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)))//不断查询芯片状态直到接收成功或者出现错误
        { };

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

            /* Clear good RX frame event in the DW1000 status register. */
            dwt_write32bitreg(SYS_STATUS_ID, SYS_STATUS_RXFCG);//清楚标志位

            /* A frame has been received, read it into the local buffer. */
            frame_len = dwt_read32bitreg(RX_FINFO_ID) & RX_FINFO_RXFL_MASK_1023;//获得接收数据长度

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

            /* 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 = rx_buffer[5];
                     rx_poll_msg[5] = TAG_ID;//为多标签通讯服务，防止一次通讯中接收到不同ID标签的数据
                     tx_resp_msg[5] = TAG_ID;
                     rx_final_msg[5] = TAG_ID;
            if (rx_buffer[9]==0x21)//判断是否是poll包数据
            {
                uint32 resp_tx_time;

                /* Retrieve poll reception timestamp. */
                poll_rx_ts = get_rx_timestamp_u64();//获得Poll包接收时间T2

                /* Set send time for response. See NOTE 8 below. */
                resp_tx_time = (poll_rx_ts + (POLL_RX_TO_RESP_TX_DLY_UUS * UUS_TO_DWT_TIME)) >> 8;//计算Response发送时间T3。
                dwt_setdelayedtrxtime(resp_tx_time);//设置Response发送时间T3

                /* Set expected delay and timeout for final message reception. */
                dwt_setrxaftertxdelay(RESP_TX_TO_FINAL_RX_DLY_UUS);//设置发送完成后开启接收延迟时间
                dwt_setrxtimeout(FINAL_RX_TIMEOUT_UUS);//接收超时时间

                /* Write and send the response message. See NOTE 9 below.*/
                        memcpy(&tx_resp_msg[11],&dist[TAG_ID],2);
                tx_resp_msg[ALL_MSG_SN_IDX] = frame_seq_nb;
                dwt_writetxdata(sizeof(tx_resp_msg), tx_resp_msg, 0);//写入发送数据
                dwt_writetxfctrl(sizeof(tx_resp_msg), 0);//设定发送长度
                dwt_starttx(DWT_START_TX_DELAYED | DWT_RESPONSE_EXPECTED);//延迟发送，等待接收

                /* We assume that the transmission is achieved correctly, now poll for reception of expected "final" frame or error/timeout.
                 * See NOTE 7 below. */
                while (!((status_reg = dwt_read32bitreg(SYS_STATUS_ID)) & (SYS_STATUS_RXFCG | SYS_STATUS_ALL_RX_ERR)))///不断查询芯片状态直到接收成功或者出现错误
                { };

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

                if (status_reg & SYS_STATUS_RXFCG)//接收成功
                /* 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[9] == 0x10) //判断接收到的数据是否是response数据
                {
                    /* Clear good RX frame event and TX frame sent in the DW1000 status register. */
                    dwt_write32bitreg(SYS_STATUS_ID, SYS_STATUS_RXFCG | SYS_STATUS_TXFRS);//清楚标志位
                    uint32 final_tx_time;

                    /* A frame has been received, read it into the local buffer. */
                    frame_len = dwt_read32bitreg(RX_FINFO_ID) & RX_FINFO_RXFLEN_MASK;//数据长度

                        dwt_readrxdata(rx_buffer, frame_len, 0);//读取接收数据
                    
                    /* 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

                    /* 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[9]==0x23)//判断是否为Fianl包
                    memcpy(&dist[TAG_ID], &rx_buffer[11], 2);

                    /* 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 timestamp is the transmission time we programmed plus the TX antenna delay. */
                    final_tx_ts = (((uint64)(final_tx_time & 0xFFFFFFFE)) << 8) + TX_ANT_DLY;//final包实际发送时间是计算时间加上发送天线delay

                    /* Write all timestamps in the final message. See NOTE 10 below. */
                    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);

                    /* 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);//设定发送数据长度
                    dwt_starttx(DWT_START_TX_DELAYED);//设定为延迟发送

                    if (GPIO_ReadInputDataBit(GPIOA, SW2) != RESET) //通过拨码开关判断数据输出格式
                    {
                        uint32 poll_tx_ts, resp_rx_ts, final_tx_ts;
                        uint32 poll_rx_ts_32, resp_tx_ts_32, final_rx_ts_32;
                        double Ra, Rb, Da, Db;
                        int64 tof_dtu;

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

                        /* Get timestamps embedded in the final message. */
                        final_msg_get_ts(&rx_buffer[FINAL_MSG_POLL_TX_TS_IDX], &poll_tx_ts);//从接收数据中读取T1，T4，T5
                        final_msg_get_ts(&rx_buffer[FINAL_MSG_RESP_RX_TS_IDX], &resp_rx_ts);
                        final_msg_get_ts(&rx_buffer[FINAL_MSG_FINAL_TX_TS_IDX], &final_tx_ts);

                        /* Compute time of flight. 32-bit subtractions give correct answers even if clock has wrapped. See NOTE 10 below. */
                        poll_rx_ts_32 = (uint32)poll_rx_ts;//使用32位数据计算
                        resp_tx_ts_32 = (uint32)resp_tx_ts;
                        final_rx_ts_32 = (uint32)final_rx_ts;
                        Ra = (double)(resp_rx_ts - poll_tx_ts);//Tround1 = T4 - T1  
                        Rb = (double)(final_rx_ts_32 - resp_tx_ts_32);//Tround2 = T6 - T3 
                        Da = (double)(final_tx_ts - resp_rx_ts);//Treply2 = T5 - T4  
                        Db = (double)(resp_tx_ts_32 - poll_rx_ts_32);//Treply1 = T3 - T2  
                        tof_dtu = (int64)((Ra * Rb - Da * Db) / (Ra + Rb + Da + Db));//计算公式

                        tof = tof_dtu * DWT_TIME_UNITS;
                        distance = tof * SPEED_OF_LIGHT;//距离=光速*飞行时间
                                    dist2 = distance - dwt_getrangebias(config.chan,(float)distance, config.prf);//距离减去矫正系数
												
                                    dis = dist2*100;//dis ä¸ºå•ä½ä¸ºcm的距离
                                    dist[TAG_ID] = LP(dis,TAG_ID);//LP ä¸ºä½Žé€šæ»¤æ³¢å™¨ï¼Œè®©æ•°æ®æ›´ç¨³å®š
                                    time32_reset = 0;
                                    GPIO_Toggle(GPIOA,LED_PIN);
                                 if (GPIO_ReadInputDataBit(GPIOA,SW2) != RESET)  //通过拨码开关判断数据输出格式
                                 {
                                    dID=TAG_ID;
                                    printf("TAG_ID: %2.0f      ", dID);
                                    dID=ANCHOR_ID;
                                    printf("ANCHOR_ID: %2.0f      ", dID);
                        dID = TAG_ID;
                        printf("TAG_ID: %2.0f      ", dID);
                        dID = ANCHOR_ID;
                        printf("ANCHOR_ID: %2.0f      ", dID);
                        printf("Distance: %5.0f cm\n", (double)dist[TAG_ID]);
                                 }else{
                                    send[2] = ANCHOR_ID;
                                    send[3] = TAG_ID;
												
                                    memcpy(&send[4],&dist[TAG_ID],2);
                                 check=Checksum_u16(&send[2],6);
                                    memcpy(&send[8],&check,2);
                                    USART_puts(send,10);
                                 }
                       
                    }
                    else
                    {
                        send[2] = ANCHOR_ID;
                        send[3] = TAG_ID;

                        memcpy(&send[4], &dist[TAG_ID], 2);
                        check = Checksum_u16(&send[2], 6);
                        memcpy(&send[8], &check, 2);
                        USART_puts(send, 10);
                    }
                    /* Poll DW1000 until TX frame sent event set. See NOTE 8 below. */
                    while (!(dwt_read32bitreg(SYS_STATUS_ID) & SYS_STATUS_TXFRS))//不断查询芯片状态直到发送完成
                    { };

                    /* Clear TXFRS event. */
                    dwt_write32bitreg(SYS_STATUS_ID, SYS_STATUS_TXFRS);//清楚标志位

                    /* Increment frame sequence number after transmission of the final message (modulo 256). */
                    frame_seq_nb++;
                    time32_reset = 0;
                    GPIO_Toggle(GPIOA, LED_PIN); //LED闪烁
                    jumptime = 0;
                }
                else
                {
                    /* Clear RX error events in the DW1000 status register. */
                    dwt_write32bitreg(SYS_STATUS_ID, SYS_STATUS_ALL_RX_ERR);
                    jumptime = 5; //如果通讯失败，将间隔时间增加5ms，避开因为多标签同时发送引起的冲突。
                }
            }
        }
        else
        {
            /* Clear RX error events in the DW1000 status register. */
            dwt_write32bitreg(SYS_STATUS_ID, SYS_STATUS_ALL_RX_ERR);
            else
            {
                /* Clear RX error events in the DW1000 status register. */
                dwt_write32bitreg(SYS_STATUS_ID, SYS_STATUS_ALL_RX_ERR);
                jumptime = 5;
            }

            /* Execute a delay between ranging exchanges. */
            deca_sleep(RNG_DELAY_MS + jumptime); //休眠固定时间
        }
    }
		
		
   }
    else
    {
        while (1)//接收模式(ANCHOR基站)
        {
            /* Clear reception timeout to start next ranging process. */
            dwt_setrxtimeout(0);//设定接收超时时间，0位没有超时时间

            /* Activate reception immediately. */
            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)))//不断查询芯片状态直到接收成功或者出现错误
            { };

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


                /* Clear good RX frame event in the DW1000 status register. */
                dwt_write32bitreg(SYS_STATUS_ID, SYS_STATUS_RXFCG);//清楚标志位

                /* A frame has been received, read it into the local buffer. */
                frame_len = dwt_read32bitreg(RX_FINFO_ID) & RX_FINFO_RXFL_MASK_1023;//获得接收数据长度

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


                /* 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 = rx_buffer[5];
                rx_poll_msg[5] = TAG_ID;//为多标签通讯服务，防止一次通讯中接收到不同ID标签的数据
                tx_resp_msg[5] = TAG_ID;
                rx_final_msg[5] = TAG_ID;
                if (rx_buffer[9] == 0x21) //判断是否是poll包数据
                {
                    uint32 resp_tx_time;

                    /* Retrieve poll reception timestamp. */
                    poll_rx_ts = get_rx_timestamp_u64();//获得Poll包接收时间T2

                    /* Set send time for response. See NOTE 8 below. */
                    resp_tx_time = (poll_rx_ts + (POLL_RX_TO_RESP_TX_DLY_UUS * UUS_TO_DWT_TIME)) >> 8;//计算Response发送时间T3。
                    dwt_setdelayedtrxtime(resp_tx_time);//设置Response发送时间T3

                    /* Set expected delay and timeout for final message reception. */
                    dwt_setrxaftertxdelay(RESP_TX_TO_FINAL_RX_DLY_UUS);//设置发送完成后开启接收延迟时间
                    dwt_setrxtimeout(FINAL_RX_TIMEOUT_UUS);//接收超时时间

                    /* Write and send the response message. See NOTE 9 below.*/
                    memcpy(&tx_resp_msg[11], &dist[TAG_ID], 2);
                    tx_resp_msg[ALL_MSG_SN_IDX] = frame_seq_nb;
                    dwt_writetxdata(sizeof(tx_resp_msg), tx_resp_msg, 0);//写入发送数据
                    dwt_writetxfctrl(sizeof(tx_resp_msg), 0);//设定发送长度
                    dwt_starttx(DWT_START_TX_DELAYED | DWT_RESPONSE_EXPECTED);//延迟发送，等待接收

                    /* We assume that the transmission is achieved correctly, now poll for reception of expected "final" frame or error/timeout.
                     * See NOTE 7 below. */
                    while (!((status_reg = dwt_read32bitreg(SYS_STATUS_ID)) & (SYS_STATUS_RXFCG | SYS_STATUS_ALL_RX_ERR)))///不断查询芯片状态直到接收成功或者出现错误
                    { };

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

                    if (status_reg & SYS_STATUS_RXFCG)//接收成功
                    {
                        /* Clear good RX frame event and TX frame sent in the DW1000 status register. */
                        dwt_write32bitreg(SYS_STATUS_ID, SYS_STATUS_RXFCG | SYS_STATUS_TXFRS);//清楚标志位

                        /* A frame has been received, read it into the local buffer. */
                        frame_len = dwt_read32bitreg(RX_FINFO_ID) & RX_FINFO_RXFLEN_MASK;//数据长度

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


                        /* 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[9] == 0x23) //判断是否为Fianl包
                        {
                            uint32 poll_tx_ts, resp_rx_ts, final_tx_ts;
                            uint32 poll_rx_ts_32, resp_tx_ts_32, final_rx_ts_32;
                            double Ra, Rb, Da, Db;
                            int64 tof_dtu;

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

                            /* Get timestamps embedded in the final message. */
                            final_msg_get_ts(&rx_buffer[FINAL_MSG_POLL_TX_TS_IDX], &poll_tx_ts);//从接收数据中读取T1，T4，T5
                            final_msg_get_ts(&rx_buffer[FINAL_MSG_RESP_RX_TS_IDX], &resp_rx_ts);
                            final_msg_get_ts(&rx_buffer[FINAL_MSG_FINAL_TX_TS_IDX], &final_tx_ts);

                            /* Compute time of flight. 32-bit subtractions give correct answers even if clock has wrapped. See NOTE 10 below. */
                            poll_rx_ts_32 = (uint32)poll_rx_ts;//使用32位数据计算
                            resp_tx_ts_32 = (uint32)resp_tx_ts;
                            final_rx_ts_32 = (uint32)final_rx_ts;
                            Ra = (double)(resp_rx_ts - poll_tx_ts);//Tround1 = T4 - T1
                            Rb = (double)(final_rx_ts_32 - resp_tx_ts_32);//Tround2 = T6 - T3
                            Da = (double)(final_tx_ts - resp_rx_ts);//Treply2 = T5 - T4
                            Db = (double)(resp_tx_ts_32 - poll_rx_ts_32);//Treply1 = T3 - T2
                            tof_dtu = (int64)((Ra * Rb - Da * Db) / (Ra + Rb + Da + Db));//计算公式

                            tof = tof_dtu * DWT_TIME_UNITS;
                            distance = tof * SPEED_OF_LIGHT;//距离=光速*飞行时间
                            dist2 = distance - dwt_getrangebias(config.chan, (float)distance, config.prf); //距离减去矫正系数

                            dis = dist2 * 100; //dis ä¸ºå•ä½ä¸ºcm的距离
                            dist[TAG_ID] = LP(dis, TAG_ID); //LP ä¸ºä½Žé€šæ»¤æ³¢å™¨ï¼Œè®©æ•°æ®æ›´ç¨³å®š
                            time32_reset = 0;
                            GPIO_Toggle(GPIOA, LED_PIN);
                            if (GPIO_ReadInputDataBit(GPIOA, SW2) != RESET) //通过拨码开关判断数据输出格式
                            {
                                dID = TAG_ID;
                                printf("TAG_ID: %2.0f      ", dID);
                                dID = ANCHOR_ID;
                                printf("ANCHOR_ID: %2.0f      ", dID);
                                printf("Distance: %5.0f cm\n", (double)dist[TAG_ID]);
                            }
                            else
                            {
                                send[2] = ANCHOR_ID;
                                send[3] = TAG_ID;

                                memcpy(&send[4], &dist[TAG_ID], 2);
                                check = Checksum_u16(&send[2], 6);
                                memcpy(&send[8], &check, 2);
                                USART_puts(send, 10);
                            }

                        }
                    }
                    else
                    {
                        /* Clear RX error events in the DW1000 status register. */
                        dwt_write32bitreg(SYS_STATUS_ID, SYS_STATUS_ALL_RX_ERR);
                    }
                }
            }
            else
            {
                /* Clear RX error events in the DW1000 status register. */
                dwt_write32bitreg(SYS_STATUS_ID, SYS_STATUS_ALL_RX_ERR);
            }
        }


    }
}

/*! ------------------------------------------------------------------------------------------------------------------