概述

本文档详细介绍了如何使用匿名助手的上位机实现加速度计和陀螺仪数据的可视化显示。内容涵盖了加速度计和陀螺仪的工作原理、上位机通信协议、数据处理流程以及具体的代码实现。通过本文档，读者可以了解如何通过串口通讯协议将传感器数据发送到上位机，并进行实时的曲线显示和数据分析。

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

在这里插入图片描述

视频教学

[https://www.bilibili.com/video/BV1L6aGz4ELL]

样品申请

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

源码下载

[https://download.csdn.net/download/qq_24312945/92884648]

硬件准备

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

在这里插入图片描述

参考程序

https://github.com/CoreMaker-lab/LSM6DSV80X

https://gitee.com/CoreMaker/LSM6DSV80X

参考坐标系

在这里插入图片描述

加速度计工作方式

假设立方体在外太空，那里的一切都是失重的，球会简单地漂浮在立方体的中心。

在这里插入图片描述

现在，假设每面墙代表一个特定的轴。
如果我们突然以 1g 的加速度向左移动盒子（单个 G 力 1g 相当于重力加速度 9.8 m/s 2），球无疑会撞到墙壁 X。如果我们测量球对墙壁施加的力X，我们可以得到沿X轴的输出值为1g。

在这里插入图片描述

让我们看看当我们把那个立方体放在地球上时会发生什么。球将简单地落在墙 Z 上，施加 1g 的力，如下图所示：

在这里插入图片描述

在这种情况下，盒子没有移动，但我们仍然在 Z 轴上得到 1g 的读数。这是因为重力（实际上是加速度的一种形式）以 1g 的力向下拉球。
虽然此模型并不完全代表真实世界的加速度计传感器是如何构建的，但它通常有助于理解为什么加速度计的输出信号通常以 ±g 为单位指定，或者为什么加速度计在静止时在 z 轴上读数为 1g，或者您可以在不同方向上获得什么样的加速度计读数。

上位机通讯

这里使用的是匿名助手的上位机
https://gitee.com/anotc/AnoAssistant
有专门的通讯协议

在这里插入图片描述

串口通讯协议格式如下所示，需要注意传输为小端模式传输。
在这里插入图片描述

对应的源地址和目标地址分别为0xFD和0xFE。

在这里插入图片描述

我们只需要上报加速度和陀螺仪数据，所以功能码为0x01，数据长度为0x0D，需要主要为小端模式传输。

在这里插入图片描述

加速度演示

实测移动模块分别为X、Y、Z轴向下，可以看见数值基本上为1000mg。
在这里插入图片描述

加速度曲线显示

设置数据列表->添加波形，可以添加加速度或者角速度曲线
在这里插入图片描述

可以通过右下角设置具体显示。
在这里插入图片描述

陀螺仪工作方式

加速度计测量线性加速度，而陀螺仪测量角旋转。为此，他们测量了科里奥利效应产生的力。
陀螺仪是一种运动传感器，能够感测物体在一轴或多轴上的旋转角速度。它能够精确地感测自由空间中复杂的移动动作，因此成为追踪物体移动方位和旋转动作的必要设备。与加速计和电子罗盘不同，陀螺仪不需要依赖外部力量（如重力或磁场），可以自主地发挥其功能。因此，从理论上讲，只使用陀螺仪就可以完成姿态导航的任务。

在这里插入图片描述

陀螺仪的每个通道检测一个轴的旋转。也就是说陀螺仪通过测量自身的旋转状态，判断出设备当前运动状态，是向前、向后、向上、向下、向左还是向右呢，是加速（角速度）还是减速（角速度）呢，都可以实现，但是要判断出设备的方位（东西南北），陀螺仪就没有办法。

在这里插入图片描述

MEMS陀螺仪主要利用科里奥利力（旋转物体在有径向运动时所受到的切向力）原理，公开的微机械陀螺仪均采用振动物体传感角速度的概念，利用振动来诱导和探测科里奥利力。
MEMS陀螺仪的核心是一个微加工机械单元，在设计上按照一个音叉机制共振运动，通过科里奥利力原理把角速率转换成一个特定感测结构的位移。

在这里插入图片描述

两个相同的质量块以方向相反的做水平震荡。当外部施加一个角速率，就会出现一个科氏力，力的方向垂直于质量运动方向，如垂直方向箭头所示。产生的科氏力使感测质量发生位移，位移大小与所施加的角速率大小成正比，科氏力引起的电容变化即可计算出角速率大小。
科里奥利效应指出，当质量 (m) 以速度 (v) 沿特定方向移动并施加外部角速率 (Ω)（红色箭头）时，科里奥利效应会产生一个力（黄色箭头），导致质量垂直移动。该位移的值与应用的角速率直接相关。

在这里插入图片描述

均值修改

修改取均值数据，增加帧率。

#define    CNT_FOR_OUTPUT       10

高 g 加速度

在很多传统的 MEMS 惯性传感器中，内置的加速度计满量程通常是 ±2g / ±4g / ±8g / ±16g，用来覆盖常见的运动和姿态检测。但在一些特殊场景下，例如跌落检测、冲击监测、工业振动分析、运动器械的高速动作捕捉，普通的低 g 加速度计很容易因为量程不足而饱和，导致数据失真。为了解决这个问题，高 g 加速度计应运而生。
这里用罗盘针来显示高 g 数据。
在这里插入图片描述

上报源码

/* 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);
	
	lsm6dsv80x_reset_t rst;
  stmdev_ctx_t dev_ctx;
	// 累加器和计数器，用于计算均值
  double_t lowg_xl_sum[3], hg_xl_sum[3], gyro_sum[3], temp_sum;
  uint16_t lowg_xl_cnt = 0, hg_xl_cnt = 0, gyro_cnt = 0, temp_cnt = 0;

  /* 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 */
  lsm6dsv80x_device_id_get(&dev_ctx, &whoamI);
	printf("LSM6DSV80X_ID=0x%x,whoamI=0x%x",LSM6DSV80X_ID,whoamI);
  if (whoamI != LSM6DSV80X_ID)
    while (1);

  /* Restore default configuration */
  lsm6dsv80x_reset_set(&dev_ctx, LSM6DSV80X_RESTORE_CTRL_REGS);
  do {
    lsm6dsv80x_reset_get(&dev_ctx, &rst);
  } while (rst != LSM6DSV80X_READY);

  /* Enable Block Data Update */
  lsm6dsv80x_block_data_update_set(&dev_ctx, PROPERTY_ENABLE);
	
  /* Set Output Data Rate.
   * Selected data rate have to be equal or greater with respect
   * with MLC data rate.
   */
	// 设置量程与输出数据速率
  lsm6dsv80x_xl_data_rate_set(&dev_ctx, LSM6DSV80X_ODR_AT_480Hz);
  lsm6dsv80x_hg_xl_data_rate_set(&dev_ctx, LSM6DSV80X_HG_XL_ODR_AT_480Hz, 1);
  lsm6dsv80x_gy_data_rate_set(&dev_ctx, LSM6DSV80X_ODR_AT_480Hz);

  /* Set full scale */
  lsm6dsv80x_xl_full_scale_set(&dev_ctx, LSM6DSV80X_16g);
  lsm6dsv80x_hg_xl_full_scale_set(&dev_ctx, LSM6DSV80X_80g);
  lsm6dsv80x_gy_full_scale_set(&dev_ctx, LSM6DSV80X_4000dps);

  /* Configure filtering chain */
  filt_settling_mask.drdy = PROPERTY_ENABLE;
  filt_settling_mask.irq_xl = PROPERTY_ENABLE;
  filt_settling_mask.irq_g = PROPERTY_ENABLE;
  lsm6dsv80x_filt_settling_mask_set(&dev_ctx, filt_settling_mask);
  lsm6dsv80x_filt_gy_lp1_set(&dev_ctx, PROPERTY_ENABLE);
  lsm6dsv80x_filt_gy_lp1_bandwidth_set(&dev_ctx, LSM6DSV80X_GY_ULTRA_LIGHT);
  lsm6dsv80x_filt_xl_lp2_set(&dev_ctx, PROPERTY_ENABLE);
  lsm6dsv80x_filt_xl_lp2_bandwidth_set(&dev_ctx, LSM6DSV80X_XL_STRONG);

  lowg_xl_sum[0] = lowg_xl_sum[1] = lowg_xl_sum[2] = 0.0;
  hg_xl_sum[0] = hg_xl_sum[1] = hg_xl_sum[2] = 0.0;
  gyro_sum[0] = gyro_sum[1] = gyro_sum[2] = 0.0;
  temp_sum = 0.0;

	
	int16_t	acc_int16[3]	={0,0,0};
	int16_t	gyr_int16[3]		={0,0,0};	
	float acc[3] = {0};
	float gyr[3] = {0};
	uint8_t data[21]={0};
	data[0]=0xAB;//帧头
	data[1]=0xFD;//源地址
	data[2]=0xFE;//目标地址		
	data[3]=0x01;//功能码ID	
	data[4]=0x0D;//数据长度LEN
	data[5]=0x00;//数据长度LEN 13

	uint8_t sumcheck = 0;
	uint8_t addcheck = 0;	
	
	int16_t	h_acc_int16[3]	={0,0,0};
	float h_acc[3] = {0};
	uint8_t h_data[17]={0};
	h_data[0]=0xAB;//帧头
	h_data[1]=0xFD;//源地址
	h_data[2]=0xFE;//目标地址		
	h_data[3]=0x02;//功能码ID	
	h_data[4]=0x09;//数据长度LEN
	h_data[5]=0x00;//数据长度LEN 13

	uint8_t h_sumcheck = 0;
	uint8_t h_addcheck = 0;		
  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
		
    lsm6dsv80x_data_ready_t drdy;

    /* Read output only if new xl value is available */
    lsm6dsv80x_flag_data_ready_get(&dev_ctx, &drdy);
		// 低g加速度数据
    if (drdy.drdy_xl) {
      /* Read acceleration field data */
      memset(data_raw_motion, 0x00, 3 * sizeof(int16_t));
      lsm6dsv80x_acceleration_raw_get(&dev_ctx, data_raw_motion);
      acceleration_mg[0] = lsm6dsv80x_from_fs16_to_mg(data_raw_motion[0]);
      acceleration_mg[1] = lsm6dsv80x_from_fs16_to_mg(data_raw_motion[1]);
      acceleration_mg[2] = lsm6dsv80x_from_fs16_to_mg(data_raw_motion[2]);

      lowg_xl_sum[0] += acceleration_mg[0];
      lowg_xl_sum[1] += acceleration_mg[1];
      lowg_xl_sum[2] += acceleration_mg[2];
      lowg_xl_cnt++;
    }
		// 高g加速度数据		
    if (drdy.drdy_hgxl) {
      /* Read acceleration field data */
      memset(data_raw_motion, 0x00, 3 * sizeof(int16_t));
      lsm6dsv80x_hg_acceleration_raw_get(&dev_ctx, data_raw_motion);
      acceleration_mg[0] = lsm6dsv80x_from_fs80_to_mg(data_raw_motion[0]);
      acceleration_mg[1] = lsm6dsv80x_from_fs80_to_mg(data_raw_motion[1]);
      acceleration_mg[2] = lsm6dsv80x_from_fs80_to_mg(data_raw_motion[2]);

      hg_xl_sum[0] += acceleration_mg[0];
      hg_xl_sum[1] += acceleration_mg[1];
      hg_xl_sum[2] += acceleration_mg[2];
      hg_xl_cnt++;
    }
		// 陀螺仪数据
    /* Read output only if new xl value is available */
    if (drdy.drdy_gy) {
      /* Read angular rate field data */
      memset(data_raw_motion, 0x00, 3 * sizeof(int16_t));
      lsm6dsv80x_angular_rate_raw_get(&dev_ctx, data_raw_motion);
      angular_rate_mdps[0] = lsm6dsv80x_from_fs4000_to_mdps(data_raw_motion[0]);
      angular_rate_mdps[1] = lsm6dsv80x_from_fs4000_to_mdps(data_raw_motion[1]);
      angular_rate_mdps[2] = lsm6dsv80x_from_fs4000_to_mdps(data_raw_motion[2]);

      gyro_sum[0] += angular_rate_mdps[0];
      gyro_sum[1] += angular_rate_mdps[1];
      gyro_sum[2] += angular_rate_mdps[2];
      gyro_cnt++;
    }

    if (drdy.drdy_temp) {
      /* Read temperature data */
      memset(&data_raw_temperature, 0x00, sizeof(int16_t));
      lsm6dsv80x_temperature_raw_get(&dev_ctx, &data_raw_temperature);
      temperature_degC = lsm6dsv80x_from_lsb_to_celsius(data_raw_temperature);
      temp_sum += temperature_degC;
      temp_cnt++;
    }

    if (lowg_xl_cnt >= CNT_FOR_OUTPUT) {
      /* print media low-g xl data */
      acceleration_mg[0] = lowg_xl_sum[0] / lowg_xl_cnt;
      acceleration_mg[1] = lowg_xl_sum[1] / lowg_xl_cnt;
      acceleration_mg[2] = lowg_xl_sum[2] / lowg_xl_cnt;

			acc_int16[0]=(int16_t)(acceleration_mg[0]);
			acc_int16[1]=(int16_t)(acceleration_mg[1]);	
			acc_int16[2]=(int16_t)(acceleration_mg[2]);	
			
//      printf("lg xl (media of %d samples) [mg]:%4.2ft%4.2ft%4.2frn",
//              lowg_xl_cnt, acceleration_mg[0], acceleration_mg[1], acceleration_mg[2]);


			
			
      lowg_xl_sum[0] = lowg_xl_sum[1] = lowg_xl_sum[2] = 0.0;
      lowg_xl_cnt = 0;

      /* print media high-g xl data */
      acceleration_mg[0] = hg_xl_sum[0] / hg_xl_cnt;
      acceleration_mg[1] = hg_xl_sum[1] / hg_xl_cnt;
      acceleration_mg[2] = hg_xl_sum[2] / hg_xl_cnt;

			h_acc_int16[0]=(int16_t)(acceleration_mg[0]);
			h_acc_int16[1]=(int16_t)(acceleration_mg[1]);	
			h_acc_int16[2]=(int16_t)(acceleration_mg[2]);

//      printf("hg xl (media of %d samples) [mg]:%4.2ft%4.2ft%4.2frn",
//              hg_xl_cnt, acceleration_mg[0], acceleration_mg[1], acceleration_mg[2]);

      hg_xl_sum[0] = hg_xl_sum[1] = hg_xl_sum[2] = 0.0;
      hg_xl_cnt = 0;

      /* print media gyro data */
      angular_rate_mdps[0] = gyro_sum[0] / gyro_cnt;
      angular_rate_mdps[1] = gyro_sum[1] / gyro_cnt;
      angular_rate_mdps[2] = gyro_sum[2] / gyro_cnt;

			gyr_int16[0]=(int16_t)(angular_rate_mdps[0]/10);		
			gyr_int16[1]=(int16_t)(angular_rate_mdps[1]/10);	
			gyr_int16[2]=(int16_t)(angular_rate_mdps[2]/10);	

//      printf("gyro (media of %d samples) [mdps]:%4.2ft%4.2ft%4.2frn",
//              gyro_cnt, angular_rate_mdps[0], angular_rate_mdps[1], angular_rate_mdps[2]);

      gyro_sum[0] = gyro_sum[1] = gyro_sum[2] = 0.0;
      gyro_cnt = 0;

      /* print media temperature data */
      temperature_degC = temp_sum / temp_cnt;
//      printf("Temperature (media of %d samples) [degC]:%6.2frnrn",
//              temp_cnt, temperature_degC);

      temp_cnt = 0;
      temp_sum = 0.0;
						
		data[7]=acc_int16[0] >>8;//ACC_X
		data[6]=acc_int16[0];
		data[9]=acc_int16[1] >>8;//ACC_Y
		data[8]=acc_int16[1];
		data[11]=acc_int16[2] >>8;//ACC_Z
		data[10]=acc_int16[2];
		
		data[13]=gyr_int16[0] >>8;//GYR_X 
		data[12]=gyr_int16[0];		
		data[15]=gyr_int16[1] >>8;//GYR_Y 
		data[14]=gyr_int16[1];			
		data[17]=gyr_int16[2] >>8;//GYR_Z 
		data[16]=gyr_int16[2];	
		
		data[18]=0;	

		sumcheck = 0;
		addcheck = 0;
		for(uint16_t i=0; i < 19; i++)
		{
			sumcheck += data[i]; //从帧头开始，对每一字节进行求和，直到 DATA 区结束
			addcheck += sumcheck; //每一字节的求和操作，进行一次 sumcheck 的累加
		}
		data[19]=sumcheck;
		data[20]=addcheck;
					
		HAL_UART_Transmit(&huart1 , (uint8_t *)&data, 21, 0xFFFF);			
		
		h_data[7]=h_acc_int16[0] >>8;//ACC_X
		h_data[6]=h_acc_int16[0];
		h_data[9]=h_acc_int16[1] >>8;//ACC_Y
		h_data[8]=h_acc_int16[1];
		h_data[11]=h_acc_int16[2] >>8;//ACC_Z
		h_data[10]=h_acc_int16[2];
		
		h_data[12]=0;
		h_data[13]=0;
		h_data[14]=0;
		
		h_sumcheck = 0;
		h_addcheck = 0;
		for(uint16_t i=0; i < 15; i++)
		{
			h_sumcheck += h_data[i]; //从帧头开始，对每一字节进行求和，直到 DATA 区结束
			h_addcheck += h_sumcheck; //每一字节的求和操作，进行一次 sumcheck 的累加
		}
		h_data[15]=h_sumcheck;
		h_data[16]=h_addcheck;

		HAL_UART_Transmit(&huart1 , (uint8_t *)&h_data, 17, 0xFFFF);		


		
			
   }		

		
		
    /* USER CODE END WHILE */

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