UWB-DW1000的TWR测距及代码（五）

已于 2023-04-07 16:05:43 修改
阅读量1.9k 收藏 26
点赞数 9
分类专栏： UWB 无人机 文章标签： 开源 无人机
于 2023-02-24 18:19:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46107106/article/details/129204267
版权

UWB测距过程很简单，两个设备（A和B）。设备A先发送，设备B等待接收

  1. 设备A 发送 P 给 设备B，此时读取时间戳，也可以等收到应答再进行读取，发送时间戳和接收时间戳都会保留最新一次，只要没有被覆盖（发送两次，或者接收两次），都是可以随时读取的。
  2. 设备B 收到P 后，发送R 给设备A，此时读取接收时间戳，和发送 时间戳。
  3. 设备A收到 R 后，发送F给设备B，读取发送时间戳。
  4. 设备B收到 F后，读取接收时间戳。
  5. 设备A 把所有时间戳发给设备B。
  6. 设备B收到 设备A的时间戳，再结合自己的时间戳根据DS——TWR算出两者之间的距离。
  7. 设备B算完距离后再打包发给设备A。
注意，因为时间戳是五个字节的，而我们为了方便发送，是只用了四个字节，舍掉高字节。如果前面的时间戳比后面的时间戳大，说明已经过了一个周期，后者需加上一个周期后再进行计算。因为跑完32位计数都需要 15.65 ps x 2^32 = 67.216ms ,所以不用担心会溢出两次的问题，因为一个测距过程也就是几个毫秒内完成，光速传播。

在这里插入图片描述

//首先发送端
static volatile uint8_t stage;
static uint32_t TX_set_delay_times;
static volatile uint64_t TX_poll_times,TX_resp_times,TX_final_times;
static uint8_t Poll_Buff[]={0x15,0x16,0xab,0,0};        //第一次发送无关数据
static uint8_t Resp_Buff[5]={0};        //接收回应的无关数据的buff
static uint8_t First_Buff[]={0x15,0x16,0xae,0,0,0,0,0,0,0,0,0,0};  //发送第一次发送和接收的时间戳
static uint8_t NO_Buff[5]={0};  //接收无关信息
static uint8_t Final_Buff[9]={0x15,0x16,0xbc,0,0,0,0,0,0};  //发送最后一次发送数据的时间戳

static uint8_t Distance_Buff[13]={0};   //接收距离
//static uint8_t Tx_Final_Buff[]={0x15,0x16,0xae,0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1a,0x1b,0,0};  //最后一次发送时间戳信息过去

unsigned char LCD_Buff[10];
//为了减少发送次数，把时间戳放在握手协议里面发了
int main(void)   
{
	  
    uint8 len = 0,i;  
    /* Start with board specific hardware init. */
    peripherals_init();
    printf("hello dwm1000!\r\n");
   // dwt_dumpregisters();
    /* 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(); /* Target specific drive of RSTn line into DW1000 low for a period. */

    spi_set_rate_low();
    if(dwt_initialise(DWT_LOADUCODE) == -1)
    {
        printf("dwm1000 init fail!\r\n");
        OLED_ShowString(0,0,"INIT FAIL");
        while (1)
        {
            STM_EVAL_LEDOn(LED1);
            deca_sleep(100);
            STM_EVAL_LEDOff(LED1);
            deca_sleep(100);
        }
    }
    spi_set_rate_high();

    /* Configure DW1000. See NOTE 6 below. */
    dwt_configure(&config);
    dwt_setleds(2);
    /* Apply default antenna delay value. See NOTE 1 below. */
    dwt_setrxantennadelay(RX_ANT_DLY);
    dwt_settxantennadelay(TX_ANT_DLY);
    OLED_ShowString(0,0,"INIT PASS");
 
    printf("init pass!\r\n");
    deca_sleep(1000);
while(1)
{
	
	dwt_setrxtimeout(8300);    //设置接收超时时间
	dwt_setrxmode(0,0,0);      //设置接收为正常模式
		 
	dwt_writetxdata(sizeof(Poll_Buff), Poll_Buff, 0);
	dwt_writetxfctrl(sizeof(Poll_Buff), 0);
	dwt_starttx(DWT_START_TX_IMMEDIATE|DWT_RESPONSE_EXPECTED);
				
	while (!((status_reg = dwt_read32bitreg(SYS_STATUS_ID)) & (SYS_STATUS_RXFCG | SYS_STATUS_ALL_RX_ERR))) 
	 { }; //等待接收完成
 
 if (status_reg & SYS_STATUS_RXFCG)
{	
dwt_write32bitreg(SYS_STATUS_ID, SYS_STATUS_RXFCG | SYS_STATUS_TXFRS); //清除发送和接收状态
len = dwt_read32bitreg(RX_FINFO_ID) & RX_FINFO_RXFLEN_MASK; //获取接收长度
 if (len <= sizeof(Resp_Buff))
	{
		dwt_readrxdata(Resp_Buff, len, 0);
	}	
if(Resp_Buff[0]==0x15&&Resp_Buff[1]==0x16)  //判断头
{
	if(Resp_Buff[2] ==0xac) //判断特有标置位。每次发都不一样，可理解为每个设备特定标签号或基站编号
		{
			TX_poll_times = get_tx_timestamp_u64();  //获取发送端第一次发送的时间戳
			TX_resp_times = get_rx_timestamp_u64();  //获取发送端接收应答数据的的时间戳
	
//   TX_set_delay_times = (TX_resp_times + (RESP_RX_TO_FINAL_TX_DLY_UUS * UUS_TO_DWT_TIME)) >> 8;  //获取延时发送时间点
//   dwt_setdelayedtrxtime(TX_set_delay_times); //设置延时发送时间点
	
// TX_final_times = (((uint64_t)(TX_set_delay_times&0xfffffffe))<<8) + TX_ANT_DLY;  //获取发送端最后一次发送的时间戳
					
		final_msg_set_ts(&First_Buff[3], TX_poll_times);
		final_msg_set_ts(&First_Buff[7], TX_resp_times);
					
		dwt_writetxdata(sizeof(First_Buff), First_Buff, 0);
		dwt_writetxfctrl(sizeof(First_Buff), 0);
		dwt_starttx(DWT_START_TX_IMMEDIATE|DWT_RESPONSE_EXPECTED);
		
		while (!((status_reg = dwt_read32bitreg(SYS_STATUS_ID)) & (SYS_STATUS_RXFCG | SYS_STATUS_ALL_RX_ERR))) 
	 { }; //等待接收距离完成
					 
 if (status_reg & SYS_STATUS_RXFCG)
		{
//							
		dwt_write32bitreg(SYS_STATUS_ID, SYS_STATUS_RXFCG | SYS_STATUS_TXFRS); //清除发送和接收状态	
		len = dwt_read32bitreg(RX_FINFO_ID) & RX_FINFO_RXFLEN_MASK; //获取接收长度
		if (len <= sizeof(NO_Buff))
			{
				dwt_readrxdata(NO_Buff, len, 0);
			}	
		if((NO_Buff[0]==0x15)&&(NO_Buff[1]==0x16))  //判断头
	{
		if(NO_Buff[2] ==0xad) //判断特有标置位。每次发都不一样，可理解为每个设备特定标签号或基站编号
		{						
		 TX_final_times = get_tx_timestamp_u64();						
	   final_msg_set_ts(&Final_Buff[3], TX_final_times); //将时间戳放入buff发送给接收端
									
		dwt_writetxdata(sizeof(Final_Buff), Final_Buff, 0);
	  dwt_writetxfctrl(sizeof(Final_Buff), 0);
		dwt_starttx(DWT_START_TX_IMMEDIATE|DWT_RESPONSE_EXPECTED);					
	 while (!((status_reg = dwt_read32bitreg(SYS_STATUS_ID)) & (SYS_STATUS_RXFCG | SYS_STATUS_ALL_RX_ERR))) 
				{ }; //等待接收距离完成
									 
	 if (status_reg & SYS_STATUS_RXFCG)
		{ 
			dwt_write32bitreg(SYS_STATUS_ID, SYS_STATUS_RXFCG | SYS_STATUS_TXFRS); //清除发送和接收状态
		  len = dwt_read32bitreg(RX_FINFO_ID) & RX_FINFO_RXFLEN_MASK; //获取接收长度
			if (len <= sizeof(Distance_Buff))
			 {
				dwt_readrxdata(Distance_Buff, len, 0);
			}
		 if((Distance_Buff[0]==0x15)&&(Distance_Buff[1]==0x16))  //判断头
		{
			if(Distance_Buff[2] ==0xdc) //判断特有标置位。每次发都不一样，可理解为每个设备特定标签号或基站编号
		{
			Distance = (double)Distance_Buff[3] +  ((double)Distance_Buff[4])/100;   	//接收距离
			printf("Distance=%lf\r\n",Distance);
			sprintf(LCD_Buff, "Dis:%3.2fm", Distance);										
			OLED_ShowString(0,2,LCD_Buff);
		}
		else 
		{
			printf("接收距离判断特殊位失败\r\n");
		}
									 
	 }
	 else 
		{
			printf("接收距离判断头错误\r\n");
	  }
	  }
	 else
		{
		 printf("TX-F接收失败\r\n");							 
	  }			
	}
	else
	{
	 dwt_write32bitreg(SYS_STATUS_ID, SYS_STATUS_ALL_RX_ERR); //清除错误标志
	 printf("发送端接收距离信息的特有标准错误\r\n");
	}
	}
	else
	{
			printf("发送端接收距离信息的帧头错误\r\n");
	}
	}
	else
	{
		dwt_write32bitreg(SYS_STATUS_ID, SYS_STATUS_ALL_RX_ERR); //清除错误标志
	 }							
	}
else
{
 // stage = POLL;  //数据错误，从头开始	
	printf("发送端应答接收特定标签号错误\r\n");
//	for(i=0;i<len;i++)
//		{
//			 printf("buff[%d]=%x\r\n",i,Tx_Resp_Buff[i]);
//			Tx_Resp_Buff[i] =0;
//		}
		}
	}
	else
	{
		printf("发送端应答接收头错误\r\n");
//	for(i=0;i<len;i++)
//		{
//			printf("buff[%d]=%x\r\n",i,Tx_Resp_Buff[i]);
//			Tx_Resp_Buff[i] =0;
//		}
		}	
	}
	else
	{
		dwt_write32bitreg(SYS_STATUS_ID, SYS_STATUS_ALL_RX_ERR); //清除错误标志
		printf("发送端应答接收数据错误 !\r\n");
//			for(i=0;i<len;i++)
//			{
//			 printf("buff[%d]=%x\r\n",i,Tx_Resp_Buff[i]);
//				Tx_Resp_Buff[i] =0;
//			}
   } 				 
	}													
				
  }

//首先接收端
#define CYCLE (4294967295.0) //一个周期

unsigned char LCD_Buff[10];
static volatile uint8_t stage;

static  uint32_t TX_poll_times,TX_resp_times,TX_final_times;
static  uint32_t RX_poll_times,RX_resp_times,RX_final_times;

static volatile uint64_t RX_poll_times_64,RX_resp_times_64,RX_final_times_64;
	

static uint8_t Poll_Buff[5]={0};                //第一次接收数据的buff
static uint8_t Resp_Buff[5]={0x15,0x16,0xac,0,0};   //回应无关数据给发送端数据的buff
static uint8_t First_Buff[13]={0};  //  接收发送端第一次发送和接收的时间戳
static uint8_t NO_Buff[5]={0x15,0x16,0xad,0,0};     //回应无关信息
static uint8_t Final_Buff[9]={0};     //接收发送端最后一次发送的时间戳

static uint8_t Distance_Buff[13]={0x15,0x16,0xdc,0,0,0,0}; //发送距离

 double Ra,Rb,Da,Db,Distance;

int tof_dtu;

int main(void)
{
    
    uint8 len = 0,i;
    /* Start with board specific hardware init. */
    peripherals_init();
    printf("hello dwm1000!\r\n");
   // dwt_dumpregisters();
    /* 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(); /* Target specific drive of RSTn line into DW1000 low for a period. */

    spi_set_rate_low();
    if(dwt_initialise(DWT_LOADUCODE) == -1)
    {
        printf("dwm1000 init fail!\r\n");
        OLED_ShowString(0,0,"INIT FAIL");
        while (1)
        {
            STM_EVAL_LEDOn(LED1);
            deca_sleep(100);
            STM_EVAL_LEDOff(LED1);
            deca_sleep(100);
        }
    }
    spi_set_rate_high();

    /* Configure DW1000. See NOTE 6 below. */
    dwt_configure(&config);
    dwt_setleds(1);
    /* Apply default antenna delay value. See NOTE 1 below. */
    dwt_setrxantennadelay(RX_ANT_DLY);
    dwt_settxantennadelay(TX_ANT_DLY);
    OLED_ShowString(0,0,"INIT PASS");

    printf("init pass!\r\n");

    while(1)
		{
			
 dwt_setrxtimeout(0);  
 dwt_setrxmode(0,0,0);   
 dwt_rxenable(0);

 while (!((status_reg = dwt_read32bitreg(SYS_STATUS_ID)) & (SYS_STATUS_RXFCG | SYS_STATUS_ALL_RX_ERR)))
	{ };
	
	if (status_reg & SYS_STATUS_RXFCG)
	{
			
	 dwt_write32bitreg(SYS_STATUS_ID, SYS_STATUS_RXFCG | SYS_STATUS_TXFRS); //清除发送和接收状态

			
		len = dwt_read32bitreg(RX_FINFO_ID) & RX_FINFO_RXFL_MASK_1023;
		
			if (len <= sizeof(Poll_Buff))
			{
					dwt_readrxdata(Poll_Buff, len, 0);
			}
			
			if(Poll_Buff[0]==0x15&&Poll_Buff[1]==0x16)  //判断头
		{
				if(Poll_Buff[2] ==0xab) //判断特有标置位。每次发都不一样，可理解为每个设备特定标签号或基站编号
				{
					RX_poll_times_64 = get_rx_timestamp_u64();  //获取接收端第一次接收数据的的时间戳
					
			 dwt_setrxaftertxdelay(0);  //设置发送接收后打开接收的延时时间
			 dwt_setrxtimeout(6800);    //设置接收超时时间
			 dwt_setrxmode(0,0,0);      //设置接收为正常模式
			
			 dwt_writetxdata(sizeof(Resp_Buff), Resp_Buff, 0);
			 dwt_writetxfctrl(sizeof(Resp_Buff), 0);
			 dwt_starttx(DWT_START_TX_IMMEDIATE|DWT_RESPONSE_EXPECTED);	

			 while (!((status_reg = dwt_read32bitreg(SYS_STATUS_ID)) & (SYS_STATUS_RXFCG | SYS_STATUS_ALL_RX_ERR)))
			{ };
		
		if (status_reg & SYS_STATUS_RXFCG)
		{
				
			dwt_write32bitreg(SYS_STATUS_ID, SYS_STATUS_RXFCG | SYS_STATUS_TXFRS); //清除发送和接收状态
				
			len = dwt_read32bitreg(RX_FINFO_ID) & RX_FINFO_RXFL_MASK_1023;
		//	printf("len =%d\r\n",len);
				if (len <= sizeof(First_Buff))
				{
						dwt_readrxdata(First_Buff, len, 0);
				}
				
				if(First_Buff[0]==0x15&&First_Buff[1]==0x16)  //判断头
			{
					if(First_Buff[2] ==0xae) //判断特有标置位。每次发都不一样，可理解为每个设备特定标签号或基站编号
	{			
		RX_resp_times_64 = get_tx_timestamp_u64();  //获取接收端第一次发送数据的的时间戳
		RX_final_times_64 = get_rx_timestamp_u64();  //获取接收端最后一次接收的时间戳
						
		final_msg_get_ts(&First_Buff[3], &TX_poll_times);
		final_msg_get_ts(&First_Buff[7], &TX_resp_times);

						
		RX_poll_times = (uint32_t)RX_poll_times_64;
		RX_resp_times = (uint32_t)RX_resp_times_64;		
		RX_final_times = (uint32_t)RX_final_times_64;    //得到接收端的时间戳
						
		dwt_writetxdata(sizeof(NO_Buff), NO_Buff, 0);
		dwt_writetxfctrl(sizeof(NO_Buff), 0);
	   dwt_starttx(DWT_START_TX_IMMEDIATE|DWT_RESPONSE_EXPECTED);	

	 while (!((status_reg = dwt_read32bitreg(SYS_STATUS_ID)) & (SYS_STATUS_RXFCG | SYS_STATUS_ALL_RX_ERR)))
					{ }; 
					 
	if (status_reg & SYS_STATUS_RXFCG)
		{
			dwt_write32bitreg(SYS_STATUS_ID, SYS_STATUS_RXFCG | SYS_STATUS_TXFRS); //清除发送和接收状态
	 len = dwt_read32bitreg(RX_FINFO_ID) & RX_FINFO_RXFL_MASK_1023;
		//	printf("len =%d\r\n",len);
	 if (len <= sizeof(Final_Buff))
			 {
				dwt_readrxdata(Final_Buff, len, 0);
			}
	 if(Final_Buff[0]==0x15&&Final_Buff[1]==0x16)  //判断头
			{
			if(Final_Buff[2] ==0xbc) //判断特有标置位。每次发都不一样，可理解为每个设备特定标签号或基站编号
			{
			 final_msg_get_ts(&Final_Buff[3], &TX_final_times); //提取发送端的时间戳
						
			// printf("/*****************************************************/\r\n");
						
//						Ra = (double)(TX_resp_times - TX_poll_times);
//						Da = (double)(TX_final_times - TX_resp_times);
//						Rb = (double)(RX_final_times - RX_resp_times);
//						Db = (double)(RX_resp_times - RX_poll_times);
//														
				if(TX_resp_times > TX_poll_times)  //判断是否超过一周期
				{
					Ra = (double)((double)TX_resp_times - (double)TX_poll_times);
				}
				else
				{
						//	 printf("/****************************/\r\n");
				 Ra = (double)((double)TX_resp_times - (double)TX_poll_times);
						//	 printf("Ra=%lf\r\n",Ra);
				 Ra += CYCLE;   //加上周期
							// printf("Ra=%lf\r\n",Ra);
				}
		
				if(TX_final_times > TX_resp_times)
				{
					Da = (double)((double)TX_final_times - (double)TX_resp_times);
				}
				else
				{
							// printf("/****************************/\r\n");
								
				 Da = (double)((double)TX_final_times - (double)TX_resp_times);
						//	 printf("Da=%lf\r\n",Da);
				 Da += CYCLE;
						//	 printf("Da=%lf\r\n",Da);
				}
						
				if(RX_final_times > RX_resp_times)
				{		
				 Rb = (double)((double)RX_final_times - (double)RX_resp_times);
				}
				else
				{
							 //printf("/****************************/\r\n"); 
			  Rb = (double)((double)RX_final_times - (double)RX_resp_times);
							// printf("Rb=%lf\r\n",Rb);
		 	  Rb += CYCLE;
							// printf("Rb=%lf\r\n",Rb);
			 }
						
			if(RX_resp_times > RX_poll_times)  
			{
				Db = (double)(RX_resp_times - RX_poll_times);
			}
			else
			{
					//printf("/****************************/\r\n");
			 Db = (double)((double)RX_resp_times - (double)RX_poll_times);
				//	printf("Db=%lf\r\n",Db);
			Db += CYCLE;
				//	printf("Db=%lf\r\n",Db);
		}					
			Distance =0;
			tof_dtu = (int64)((Ra * Rb - Da * Db) / (Ra + Rb + Da + Db));
			tof = tof_dtu * DWT_TIME_UNITS;
			Distance = tof * SPEED_OF_LIGHT;
					
					//printf("Dis=%f\r\n",Distance);
					
		Distance = Distance - dwt_getrangebias(config.chan,(float)Distance, config.prf);//距离减去矫正系数
						
					
//						printf("Ra =%lf\r\n",Ra);
//						printf("Rb =%lf\r\n",Rb);
//						printf("Da =%lf\r\n",Da);
//						printf("Db =%lf\r\n",Db);
                          													
//						printf("Ra-Db =%lf\r\n",Ra-Db);
//						printf("Rb-Da =%lf\r\n",Rb-Da);
//												
				printf("Dis=%f\r\n",Distance);
				int temp =0;
				temp = (int)(Distance*100);
					//printf("temp=%d\r\n",temp);
				Distance_Buff[3] = temp/100; //取整
				Distance_Buff[4] = temp%100; //取小数   //打包发送距离
					
//					printf("/**************************************************/\r\n");	
//					printf("TX_poll_times =%u\r\n",TX_poll_times);
//					printf("RX_poll_times =%u\r\n",RX_poll_times);
//					printf("RX_resp_times =%u\r\n",RX_resp_times);
//					printf("TX_resp_times =%u\r\n",TX_resp_times);
//					printf("TX_final_times =%u\r\n",TX_final_times);
//					printf("RX_final_times =%u\r\n",RX_final_times);
//								

//					printf("Distance_Buff[3]=%d\r\n",Distance_Buff[3]);
//					printf("Distance_Buff[4]=%d\r\n",Distance_Buff[4]);
				sprintf(LCD_Buff, "Dis:%3.2fm", Distance);
												
				OLED_ShowString(0,2,LCD_Buff);
					
						
				dwt_writetxdata(sizeof(Distance_Buff), Distance_Buff, 0);
				dwt_writetxfctrl(sizeof(Distance_Buff), 0);
			  dwt_starttx(DWT_START_TX_IMMEDIATE);	
			}
			else
			{
				printf("端接收接收最后一次时间戳失败\r\n");
			}
				}
			}
			else
		{
			dwt_write32bitreg(SYS_STATUS_ID, SYS_STATUS_ALL_RX_ERR);
			printf("接收发送端最后一次时间戳失败\r\n");
		}
	}
		else
			{ 
					//stage = POLL;  //数据错误，从头开始
					
		printf("接收端最后一次接收特定标签号错误\r\n");
//					for(i=0;i<len;i++)
//					{
//						printf("buff[%d]=%x\r\n",i,Rx_Final_Buff[i]);
//						Rx_Final_Buff[i] =0;
//				}
		}
		
	 }
		else
	{ 
			 //stage = POLL;  //数据错误，从头开始
			
		printf("接收端最后一次接收头错误\r\n");
			 
//			for(i=0;i<len;i++)
//			{
//				printf("buff[%d]=%x\r\n",i,Rx_Final_Buff[i]);
//				Rx_Final_Buff[i] =0;
//			}
		 }
		
	}
 else
	{
		dwt_write32bitreg(SYS_STATUS_ID, SYS_STATUS_ALL_RX_ERR);
			//stage = POLL;
//									
	printf("接收端最后一次接收数据错误\r\n");
//									 
//			for(i=0;i<len;i++)
//			{
//				printf("buff[%d]=%x\r\n",i,Rx_Final_Buff[i]);
//				Rx_Final_Buff[i] =0;
//			}
			
	}							 
				}
	else
		{
			printf("接收端第一次接收特定标签号错误\r\n");
//					for(i=0;i<len;i++)
//					{
//						printf("buff[%d]=%x\r\n",i,Rx_Poll_Buff[i]);
//						Rx_Poll_Buff[i] =0;
//					}
				}
		
  }
	else
	{ 
			printf("接收端第一次接收头错误\r\n");
//			 for(i=0;i<len;i++)
//					{
//						printf("buff[%d]=%x\r\n",i,Rx_Poll_Buff[i]);
//						Rx_Poll_Buff[i] =0;
//					}
		 }	
	}
 else
	{	
	dwt_write32bitreg(SYS_STATUS_ID, SYS_STATUS_ALL_RX_ERR);
//										stage = POLL;
//									
	printf("接收端第一次接收数据错误\r\n");
//			for(i=0;i<len;i++)
//				{
//					printf("buff[%d]=%x\r\n",i,Rx_Poll_Buff[i]);
//					Rx_Poll_Buff[i] =0;
//				}
	}
	}
}
吾与春风皆过客
关注
  • 9
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 18
    评论
专栏目录
UWB中TOF测距法的公式推导
tyst08的专栏
05-24 1万+
UWB中TOF测距法的公式推导 UWB常用测距方法有两种：飞行时间测距法（TOF）和到达时间差法（TDOA）。这里说一下TOF。网上很多地方都给了公式，但是缺了过程推导，这里补上，有像我一样纠结公式是怎么来的同学可以参考。 TOF 飞行时间法（Time of Flight，TOF）是一种双向测距技术，它通过测量UWB信号在基站与标签之间往返的飞行时间来计算距离。根据数学关系，一点到已知点的距离为常数，那么这点一定在以已知点为圆心，以该常数为半径的圆上。有两个已知点，就有两个交点。以三个已知点和距离作三个圆，
DW1000 PDOA测距官方算法说明文档
11-19
DW1000 PDOA测距官方算法说明文档 AOA TDOA PDOA ....
UWB STM32+DW1000 TWR测距代码（1标签与3基站测距）
12-07
STM32 搭配UWB进行双边双向测距功能代码（1标签与3基站测距）
DWM1000 测距原理简单分析 之 SS-TWR代码分析2 -- [蓝点无限]
weixin_30410999的博客
11-19 1142
蓝点DWM1000 模块已经打样测试完毕，有兴趣的可以申请购买了，更多信息参见蓝点论坛 正文： 首先将SS 原理介绍中的图片拿过来，将图片印在脑海里。 对于DeviceA 和 DeviceB来说，初始化代码都一样，而后面部分是一个while循环，一直执行测距任务。 DeviceA(ex_06a_ss_twr_init) 部分代码 1 tx_poll_msg[AL...
超宽带技术实现UWB定位：dw1000模块双边双向测距，研创物联提供全套资料，支持多基站标签配置切换，上位机测距显示解算坐标，OLED显示板上位置信息
最新发布
PDMNxGfLhWG的博客
05-01 1374
此外，还可以找到研创物联官方资料和网上的开源资料。同时，研创物联还提供了一套基于QT5的上位机源码，该源码支持连接官方上位机，可以实现测距显示和定位坐标解算，并在界面上显示位置信息。对于使用UWB定位技术的开发人员来说，研创物联提供了丰富的资料和代码，可以帮助他们进行开发和应用。知识点和领域范围：UWB定位、超宽带技术、dw1000模块、双边双向测距、基站、标签、USB虚拟串口、信道、速率、上位机、测距显示、定位坐标解算、位置显示、原理图、PCB设计、手册、中文翻译、研创物联、开源资料、OLED显示屏。
STM32+DWM1000开发uwb测距系列教程之二：源码分析及源码移植（基于STM32 cubemx+keil MDK）
wo4fisher的博客
05-07 1万+
1.本篇简介 STM32+DWM1000开发uwb测距系列教程之一 上一篇 文章主要简单介绍了一下官方最新示例代码的打开和基本工程目录结构。 本篇在前一篇的基础上，进行工程移植，移植思路是，首先保持官方口味不变，因为官方代码应该是正常可用的，另外例程丰富；其次是尽可能使用cube mx，在不考虑程序执行效率的外加因素的情况下，stm32开发，使用cubemx 是最快捷方便的，并且出错概率也是最小的...
DW1000-概述
FIScanf的博客
09-04 5536
DW1000DW1000（官方网站）是一个完全集成的低功耗射频收发器，遵循IEEE 802.15.4-2011 超宽带标准。它可以被用于双向测距或者TDOA定位系统中，精度为10cm。它使用了从3.5Ghz-6.5Ghz的6个射频频段，支持100kbps、850kbps、6.8Mbps的数据速率，并且可以在多径环境下进行处理，所以可在高反射的环境下应用。
【物联网无线通信技术】UWB定位从理论到实现（DW1000）
铁路十六宿舍的博客
07-30 8254
本篇文章介绍了物联网中一种比较主流的室内定位技术-UWB。首先通过概述让读者了解这项技术的优势，然后借由Qorvo提供的一整套实时定位系统，自上而下的庖丁解牛这项技术，帮助读者更加直观的理解这项技术的实现。
STM32+DWM1000开发uwb测距系列教程之三：使用官方例程实现p2p双向 twr测距
wo4fisher的博客
05-07 5981
目录1 往期链接2 官方例程3 代码简讲3.1 初始化流程3.2 标签具体数据收发流程3.3 基站数据收发流程4 测试 1 往期链接 STM32+DWM1000开发uwb测距系列教程之一：官方例程简介 STM32+DWM1000开发uwb测距系列教程之二：源码分析及源码移植（基于STM32 cubemx+keil MDK） 2 官方例程 在官方例程的examples目录中，05a和05b是基于t...
UWB-DW1000初始化、发送和接收详解（一）
吾与春风皆过客
12-07 7046
UWB通信，DWM1000板子的DW1000初始化配置，以及发送和接收详解
dwm1000 用c语言控制,DWM1000 测距原理简单分析(示例代码)
weixin_42298646的博客
05-20 1722
DWM1000 超宽带测距，使用的TOF(time of fly) 的方式，也就是计算无线电磁波传输时间，通过传输的时间换算成距离。 电磁波传输速率和光速一样，速度是299792.458km/s，可参见百度百科。如果想通过测试这个传播时间换算距离，那么就需要非常高的内部时钟。然。。。并不是有了高速的内部时钟即可测距，还需要一点，数据送达天线的精确时间，也就是我们发送数据时，何时将数据送到天线，以及...
UWB（DW1000+STM32）Keil工程代码
03-16
UWB（DW1000+STM32）Keil工程代码：1个Tag+3个Anchor进行TWR-DS测距，测距数据由串口传递给WIFI透传模块，在同一个局域网的WIFI终端进行数据处理/定位算法。
UWB相关源码资料 研创物联mini3s源码资料UWB相关资料 dwm1000模块 uwb定位 ds-twr测距 dw1000
07-13
UWB相关源码资料 研创物联mini3s源码资料UWB相关资料 dwm1000模块 uwb定位 ds-twr测距 dw1000模块，双边双向测距，研创物联代码，最多支持4基站8标签测距，基站和标签、信道、速率等配置可通过USB虚拟串口进行切换，...
UWB定位STM32源码_1基站多标签_2.7z
02-25
国外bitcraze公司的UWB室内定位开源程序，包含twr和tdoa2和tdoa3三种定位模式，非常具有参考价值！这是经过实测的源码，亲测可用，定位原理是使用TOF方法的6次双向双边真实测距方法，可实现多基站多信标的定位，三个...
aps013_dw1000_and_two_way_ranging.pdf
04-15
uwb测距中常用的TWR方式，two way ranging
UWB定位问题（TOA定位matlab实现）
qq_40276082的博客
04-17 5995
四点定位（Four-Anchor Positioning）是一种基于距离测量的定位方法，通常采用TOA方法来计算目标物体到每个基站的距离。通过测量目标物体到至少四个基站的距离，并利用三角定位等算法计算出目标物体的位置。因此，四点定位属于TOA定位方法的一种。在UWB精确定位中，四点定位（Four-Anchor Positioning）是一种常用的定位方法，它需要至少四个固定在空间中的基站来定位目标物体的位置。四点定位的基本原理是通过测量目标物体到每个基站的距离，计算出目标物体的位置。
UWB协议：IEEE 802.15.4A‐2011学习
热门推荐
miffywm的博客
05-30 1万+
UWB基带项目笔记1. PHY协议1.1 发送处理1.1.1 SHR1.1.2 PHR1.1.3 DATA1.2 接收处理三级目录2. MAC协议2.1 SHR同步过程 1. PHY协议 UWB phy处理基本流程如下框图： UWB PHY相关参数： 1.1 发送处理 1.1.1 SHR SHR preamble位于PHR前，用于AGC设置，天线分集选择，定时采集，粗频偏和细频偏恢复，分组和帧同步，信道估计，测距前沿信号跟踪。 preamble相关设置参数： SHR包含两部分： 1）SYNC 长度种类
dw1000信标码_DW1000PA UWB大功率无线测距模块使用说明书
weixin_39947351的博客
12-21 1082
DW1000PATR3.9-TT无线测距模块是基于DecaWave射频集成芯片DW1000 的射频模块， DW1000芯片是基于UWB(Ultra Wide Band)频段的一款无线收发器。DW1000PATR3.9-TT模块内置PA/LNA射频前端，支持双向TOF测距或者TDOA定位系统，精度达到10cm并且支持速率最高达到6.8Mbps。一、产品特点：●工作电压：2.8 ~ 3.6V●工作频段...
DW1000是什么--超宽带 (UWB) 低功耗、低成本收发器 IC 适用于定位标签精准定位
CC18025394486的博客
03-26 686
它不需要使用传统通信体制中的载波，而是通过发送和接收具有纳秒或纳秒级以下的极窄脉冲来传输数据。在体育赛事和娱乐活动中，DW1000 可以应用于选手或者观众的定位。通过在选手或者观众身上搭载 DW1000 模块，可以实时追踪其位置信息，提供精确的比赛成绩或者导航服务。用户可以通过智能手机或者其他设备，实时监测和控制家居内的各种设备，提升生活便利性和舒适度。在物流仓储领域，DW1000 可以用于货物的准确定位和追踪。通过在货物上搭载 DW1000 模块，可以实时监测货物的位置信息，提高物流效率和准确性。
f103+dw1000uwb定位代码
08-01
f103 dw1000uwb定位代码是指使用STM32F103微控制器和DW1000UWB模块进行定位的代码。DW1000UWB模块是一种基于超宽带技术的无线通信模块，可以实现高精度的室内定位。 在编写f103 dw1000uwb定位代码时，首先需要初始化STM32F103微控制器和DW1000UWB模块。这包括配置微控制器的引脚、时钟和中断等，以及设置DW1000UWB模块的通信参数和协议等。 然后，在代码中需要实现基于DW1000UWB模块的定位算法。定位算法可以通过接收来自多个DW1000UWB模块的信号，并利用超宽带的测距和三角定位原理计算目标的位置。通过测量到的信号到达时间差(TDOA)或相位差(ToF)来实现测距。 进一步，可以使用三角定位算法来计算目标的准确位置。这需要至少三个DW1000UWB模块来测量到目标的信号，并计算得到目标的坐标。通过对算法进行优化和校准，可以提高定位的精度和稳定性。 最后，可以在代码中添加其他功能，如数据传输、信号处理和错误处理等。通过将这些功能与定位算法结合起来，可以实现更为强大和全面的定位系统。 总之，f103 dw1000uwb定位代码是关于使用STM32F103微控制器和DW1000UWB模块进行定位的代码，通过初始化和配置微控制器和模块，实现定位算法和相关功能，可以实现高精度的室内定位。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 18
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值