陀螺仪LSM6DSOW开发(4)----中断获取FIFO数据

记帖

已于 2024-07-31 19:18:01 修改

阅读量290

点赞数 14

分类专栏：传感器 stm32cube 单片机文章标签： STM32CUBEMX 欧拉角 MotionFX LSM6DSOW MEMS 陀螺仪角速度

于 2024-07-31 00:19:22 首次发布

本文链接：https://blog.csdn.net/qq_24312945/article/details/140810020

版权

单片机同时被 3 个专栏收录

252 篇文章 153 订阅

订阅专栏

stm32cube

132 篇文章 59 订阅

订阅专栏

传感器

88 篇文章 3 订阅

订阅专栏

概述

本文将探讨如何使用中断机制获取FIFO数据并应用MotionFX库解析空间坐标。MotionFX库是一种用于传感器融合的强大工具，可以将加速度计、陀螺仪和磁力计的数据融合在一起，实现精确的姿态和位置估计。本文将介绍如何初始化和配置MotionFX库，使用中断机制读取FIFO中的传感器数据。FIFO可以作为数据缓冲区，存储传感器的临时数据，防止数据丢失，特别是在处理器忙于其他任务时。本文将利用这些数据进行空间坐标的解析。本章案例基于上节的demo进行修改。

最近在弄ST和瑞萨RA的课程，需要样片的可以加群申请：615061293 。

在这里插入图片描述

视频教学

https://www.bilibili.com/video/BV1Tm42137BS/

陀螺仪LSM6DSOW开发(4)----中断获取FIFO数据

样品申请

https://www.wjx.top/vm/OhcKxJk.aspx#

源码下载

https://download.csdn.net/download/qq_24312945/89602062

硬件准备

首先需要准备一个开发板，这里我准备的是自己绘制的开发板，需要的可以进行申请。
主控为STM32H503CB，陀螺仪为LSM6DSOW，磁力计为LIS2MDL。

在这里插入图片描述

开启LED

配置PB14为输出模式。

在这里插入图片描述

开启INT中断

陀螺仪LSM6DSOW的中断管脚接到了PB0，需要将PB0设置为中端口。

在这里插入图片描述

开启中断。

在这里插入图片描述

中断读取传感器数据

为了使用回调函数并获取FIFO中的数据，在main.c定义了以下变量。

/// 用于存储FIFO中读取的数据，每条数据包含7个字节（1个标签字节和6个数据字节）
uint8_t fifo_data[10*2][7];
stmdev_ctx_t dev_ctx;
uint8_t wmflag = 0;
uint16_t num = 0;
lsm6dso_fifo_tag_t reg_tag;
axis3bit16_t dummy;

// FIFO中当前存储的数据数量
uint16_t fifo_num = 0;
// FIFO中断标志，用于标记是否有新的FIFO数据可供读取
uint8_t fifo_flag=0;

static int16_t *datax;
static int16_t *datay;
static int16_t *dataz;


float acc_x,acc_y,acc_z;
float gyr_x,gyr_y,gyr_z;
uint32_t deltatime_1,deltatime_2;
uint8_t deltatime_first=0;
int out_num=0;

需要注意优化等级。

在这里插入图片描述

完整初始化如下所示。

  /* USER CODE BEGIN 2 */
	printf("HELLO!\n");
  HAL_GPIO_WritePin(CS1_GPIO_Port, CS1_Pin, GPIO_PIN_SET);
  HAL_GPIO_WritePin(SA0_GPIO_Port, SA0_Pin, GPIO_PIN_RESET);
  HAL_GPIO_WritePin(CS2_GPIO_Port, CS2_Pin, GPIO_PIN_SET);
	HAL_Delay(100);
	
	

  /* Uncomment to configure INT 1 */
  lsm6dso_pin_int1_route_t int1_route;	
  /* Initialize mems driver interface */
  dev_ctx.write_reg = platform_write;
  dev_ctx.read_reg = platform_read;
  dev_ctx.mdelay = platform_delay;
  dev_ctx.handle = &SENSOR_BUS;
  /* Init test platform */
//  platform_init();
  /* Wait sensor boot time */
  platform_delay(BOOT_TIME);
  /* Check device ID */
  lsm6dso_device_id_get(&dev_ctx, &whoamI);
	printf("LSM6DSO_ID=0x%x,whoamI=0x%x",LSM6DSO_ID,whoamI);
  if (whoamI != LSM6DSO_ID)
    while (1);

  /* Restore default configuration */
  lsm6dso_reset_set(&dev_ctx, PROPERTY_ENABLE);

  do {
    lsm6dso_reset_get(&dev_ctx, &rst);
  } while (rst);

  /* Disable I3C interface */
  lsm6dso_i3c_disable_set(&dev_ctx, LSM6DSO_I3C_DISABLE);
  /* Enable Block Data Update */
  lsm6dso_block_data_update_set(&dev_ctx, PROPERTY_ENABLE);
  /* Set full scale */
  lsm6dso_xl_full_scale_set(&dev_ctx, LSM6DSO_2g);
  lsm6dso_gy_full_scale_set(&dev_ctx, LSM6DSO_2000dps);
  /* Set FIFO watermark (number of unread sensor data TAG + 6 bytes
   * stored in FIFO) to 10 samples
   */
  lsm6dso_fifo_watermark_set(&dev_ctx, 10);
  /* Set FIFO batch XL/Gyro ODR to 12.5Hz */
  lsm6dso_fifo_xl_batch_set(&dev_ctx, LSM6DSO_XL_BATCHED_AT_417Hz);
  lsm6dso_fifo_gy_batch_set(&dev_ctx, LSM6DSO_GY_BATCHED_AT_417Hz);
  /* Set FIFO mode to Stream mode (aka Continuous Mode) */
  lsm6dso_fifo_mode_set(&dev_ctx, LSM6DSO_STREAM_MODE);
  /* Enable drdy 75 μs pulse: uncomment if interrupt must be pulsed */
  lsm6dso_data_ready_mode_set(&dev_ctx, LSM6DSO_DRDY_PULSED);
  /* Uncomment if interrupt generation on Free Fall INT1 pin */
  lsm6dso_pin_int1_route_get(&dev_ctx, &int1_route);
  int1_route.fifo_th = PROPERTY_ENABLE;
  lsm6dso_pin_int1_route_set(&dev_ctx, int1_route);
  /* Uncomment if interrupt generation on Free Fall INT2 pin */
  //lsm6dso_pin_int2_route_get(&dev_ctx, &int2_route);
  //int2_route.reg.int2_ctrl.int2_fifo_th = PROPERTY_ENABLE;
  //lsm6dso_pin_int2_route_set(&dev_ctx, &int2_route);
  /* Set Output Data Rate */
  lsm6dso_xl_data_rate_set(&dev_ctx, LSM6DSO_XL_ODR_417Hz);
  lsm6dso_gy_data_rate_set(&dev_ctx, LSM6DSO_GY_ODR_417Hz);



	lsm6dso_fifo_timestamp_decimation_set(&dev_ctx, LSM6DSO_DEC_1);
  /* Enable timestamp */
  lsm6dso_timestamp_set(&dev_ctx, PROPERTY_ENABLE);

  /* USER CODE END 2 */

开启时间戳

FIFO_CTRL4 (0Ah) 寄存器用于配置LSM6DSOW传感器的FIFO行为，包括时间戳批处理减量、温度数据批处理速率和FIFO模式选择。该寄存器包含多个字段，每个字段的功能如下所述。
DEC_TS_BATCH 位于 FIFO_CTRL4 (0Ah) 寄存器中，用于配置时间戳在FIFO中的批处理减量。它决定了时间戳数据在FIFO中写入的频率。

在这里插入图片描述

CTRL10_C 寄存器用于启用和配置LSM6DSOW传感器的时间戳计数器。启用时间戳计数器可以在数据记录过程中提供精确的时间标记，以便更好地分析和同步传感器数据。
TIMESTAMP_EN: 用于启用或禁用时间戳计数器。

在这里插入图片描述

时间戳单位为25us，当启用时间戳计数器时，计数器的值可以从以下寄存器读取：TIMESTAMPO (40h)，TIMESTAMP1 (41h)，TIMESTAMP2 (42h)，TIMESTAMP3 (43h)
在这里插入图片描述

	lsm6dso_fifo_timestamp_decimation_set(&dev_ctx, LSM6DSO_DEC_1);
  /* Enable timestamp */
  lsm6dso_timestamp_set(&dev_ctx, PROPERTY_ENABLE);

中断配置

在stm32h5xx_it.c中添加回调函数引用。

/* USER CODE BEGIN 0 */
extern void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin);


/* USER CODE END 0 */

处理PB0外部中断线0（EXTI Line0）的中断。

/**
  * @brief This function handles EXTI Line0 interrupt.
  */
void EXTI0_IRQHandler(void)
{
  /* USER CODE BEGIN EXTI0_IRQn 0 */
	HAL_GPIO_EXTI_Callback(GPIO_PIN_0);
  /* USER CODE END EXTI0_IRQn 0 */
  HAL_GPIO_EXTI_IRQHandler(INT1_Pin);
  /* USER CODE BEGIN EXTI0_IRQn 1 */

  /* USER CODE END EXTI0_IRQn 1 */
}

在main.c中添加回调函数的定义，检查中断是否由 GPIO_PIN_0 引脚触发，每次发生中断时从传感器获取当前的FIFO状态，并存储在 fifo_status 变量中。读取FIFO数据，并将这些数据存储在一个全局数组 fifo_data 中，以便在主循环或其他地方进行处理。通过切换 LED 的状态，可以直观地了解中断的发生。

void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin){
	
	if(GPIO_Pin == GPIO_PIN_0)
	{
		HAL_GPIO_TogglePin(LED1_GPIO_Port, LED1_Pin);
    /* Read watermark flag */
    lsm6dso_fifo_wtm_flag_get(&dev_ctx, &wmflag);

    if (wmflag > 0) {
			fifo_flag=1;
      /* Read number of samples in FIFO */
      lsm6dso_fifo_data_level_get(&dev_ctx, &num);
			fifo_num=num;
//					printf("num=%d\n",num);
      for(int i=0;i<num;i++)  {
        /* Read FIFO tag */
        lsm6dso_fifo_sensor_tag_get(&dev_ctx, &reg_tag);
				fifo_data[i][0]=reg_tag;
				memset(data_raw_acceleration.u8bit, 0x00, 3 * sizeof(int16_t));
				lsm6dso_fifo_out_raw_get(&dev_ctx, data_raw_acceleration.u8bit);			
				fifo_data[i][1]=data_raw_acceleration.u8bit[0];
				fifo_data[i][2]=data_raw_acceleration.u8bit[1];
				fifo_data[i][3]=data_raw_acceleration.u8bit[2];
				fifo_data[i][4]=data_raw_acceleration.u8bit[3];
				fifo_data[i][5]=data_raw_acceleration.u8bit[4];
				fifo_data[i][6]=data_raw_acceleration.u8bit[5];		
//	printf("f1=%d f2=%d",fifo_data[i][1],fifo_data[i][2]);			
				
//        switch (reg_tag) {
//          case LSM6DSO_XL_NC_TAG:
//            memset(data_raw_acceleration.u8bit, 0x00, 3 * sizeof(int16_t));
//            lsm6dso_fifo_out_raw_get(&dev_ctx, data_raw_acceleration.u8bit);
//            acceleration_mg[0] =
//              lsm6dso_from_fs2_to_mg(data_raw_acceleration.i16bit[0]);
//            acceleration_mg[1] =
//              lsm6dso_from_fs2_to_mg(data_raw_acceleration.i16bit[1]);
//            acceleration_mg[2] =
//              lsm6dso_from_fs2_to_mg(data_raw_acceleration.i16bit[2]);
//            printf("Acceleration [mg]:%4.2f\t%4.2f\t%4.2f\r\n",
//                    acceleration_mg[0], acceleration_mg[1], acceleration_mg[2]);
//            break;

//          case LSM6DSO_GYRO_NC_TAG:
//            memset(data_raw_angular_rate.u8bit, 0x00, 3 * sizeof(int16_t));
//            lsm6dso_fifo_out_raw_get(&dev_ctx, data_raw_angular_rate.u8bit);
//            angular_rate_mdps[0] =
//              lsm6dso_from_fs2000_to_mdps(data_raw_angular_rate.i16bit[0]);
//            angular_rate_mdps[1] =
//              lsm6dso_from_fs2000_to_mdps(data_raw_angular_rate.i16bit[1]);
//            angular_rate_mdps[2] =
//              lsm6dso_from_fs2000_to_mdps(data_raw_angular_rate.i16bit[2]);
//            printf("Angular rate [mdps]:%4.2f\t%4.2f\t%4.2f\r\n",
//                    angular_rate_mdps[0], angular_rate_mdps[1], angular_rate_mdps[2]);
//            break;

//					
//          case LSM6DSO_TIMESTAMP_TAG:	
//						/* Read temperature data */
//						memset(&data_raw_timestamp, 0x00, sizeof(int16_t));
//            lsm6dso_fifo_out_raw_get(&dev_ctx, data_raw_timestamp.u8bit);
//						uint32_t timestamp=0;
//						timestamp+= data_raw_timestamp.u8bit[0];
//						timestamp+= data_raw_timestamp.u8bit[1]<<8;					
//						timestamp+= data_raw_timestamp.u8bit[2]<<16;						
//						timestamp+= data_raw_timestamp.u8bit[3]<<24;						
//						printf("timestamp=%d\r\n",
//              timestamp);
//            break;				
//					
//					
//					
//					
//          default:
//            /* Flush unused samples */
//            memset(dummy.u8bit, 0x00, 3 * sizeof(int16_t));
//            lsm6dso_fifo_out_raw_get(&dev_ctx, dummy.u8bit);
//            break;
//        }
      }
    }		
		
	}
}

主程序

在主循环中检查FIFO中断标志，如果有新的FIFO数据，则读取并处理这些数据。

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
	if(fifo_flag)// 如果 FIFO 中断标志被设置
	{		
		uint8_t acc_flag=0,gyr_flag=0;//加速度角速度标志位
		uint8_t deltatime_flag=0;//时间标志位		
		printf("fifo_num=%d\n",fifo_num);
		for(int i=0;i<fifo_num;i++)// 遍历 FIFO 数据数组
		{
			// 获取数据指针
			datax = (int16_t *)&fifo_data[i][1];
			datay = (int16_t *)&fifo_data[i][3];
			dataz = (int16_t *)&fifo_data[i][5];
				
			// 根据数据标签处理不同类型的数据
			switch (fifo_data[i][0]) {
        case LSM6DSO_XL_NC_TAG:// 加速度数据
					acc_flag=1;				
					acc_x=lsm6dso_from_fs2_to_mg(*datax);
					acc_y=lsm6dso_from_fs2_to_mg(*datay);
					acc_z=lsm6dso_from_fs2_to_mg(*dataz);		
					printf("Acceleration [mg]:%4.2f\t%4.2f\t%4.2f\r\n",
                    acc_x, acc_y, acc_z);				
          break;				
        case LSM6DSO_GYRO_NC_TAG:// 角速度数据
					gyr_flag=1;
					gyr_x=lsm6dso_from_fs2000_to_mdps(*datax);
					gyr_y=lsm6dso_from_fs2000_to_mdps(*datay);
					gyr_z=lsm6dso_from_fs2000_to_mdps(*dataz);	
					printf("Angular rate [mdps]:%4.2f\t%4.2f\t%4.2f\r\n",
									gyr_x,gyr_y,gyr_z);			
          break;				
        case LSM6DSO_TIMESTAMP_TAG:// 时间戳数据
					deltatime_flag=1;
			 /* 读取时间戳数据 */
				uint32_t timestamp=0;
						timestamp+= fifo_data[i][1];
						timestamp+= fifo_data[i][2]<<8;					
						timestamp+= fifo_data[i][3]<<16;						
						timestamp+= fifo_data[i][4]<<24;	
					if(deltatime_first==0)//第一次
					{
						deltatime_1=timestamp;
						deltatime_2=deltatime_1;
						deltatime_first=1;
					}
					else
					{
						deltatime_2=timestamp;
					}
					printf("timestamp=%d\r\n",timestamp);							
          break;	
        default:
          break;				
				}
			// 如果加速度、角速度和时间戳数据都已获取
			if(acc_flag&&gyr_flag&&deltatime_flag)
			{
//				lsm6dso_motion_fx_determin();// 调用 MotionFX 处理函数
				acc_flag=0;
				gyr_flag=0;
				deltatime_flag=0;
				deltatime_1=deltatime_2;	// 更新时间戳		
			}						
		}

		// 清除 FIFO 标志和数据量
		fifo_flag=0;
		fifo_num=0;
		
		}

		
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
  }
  /* USER CODE END 3 */

演示

由于分别开启了加速度，角速度，时间戳到FIFO，FIFO溢出阈值设置为10，那么到12的时候数据溢出进行打印。
时间戳数据16697842-16697746=96*25us=2400us。
速率为416HZ，即2.4ms

在这里插入图片描述

记帖

关注

14
点赞
踩
12

收藏

觉得还不错? 一键收藏
打赏
0
评论
陀螺仪LSM6DSOW开发(4)----中断获取FIFO数据

文将探讨如何使用中断机制获取FIFO数据并应用MotionFX库解析空间坐标。MotionFX库是一种用于传感器融合的强大工具，可以将加速度计、陀螺仪和磁力计的数据融合在一起，实现精确的姿态和位置估计。本文将介绍如何初始化和配置MotionFX库，使用中断机制读取FIFO中的传感器数据。FIFO可以作为数据缓冲区，存储传感器的临时数据，防止数据丢失，特别是在处理器忙于其他任务时。本文将利用这些数据进行空间坐标的解析。本章案例基于上节的demo进行修改。
复制链接

扫一扫