电子产品世界 » 论坛首页 » DIY与开源设计 » 电子DIY » Let'sdo2026年第3期—加速度传感器参数获取

共1条 1/1 1 跳转至页

Let'sdo2026年第3期—加速度传感器参数获取

工程师
2026-11-16 23:30:08     打赏

本文将基于上一篇帖子中的电机控制代码,使用LIS3DH 加速度计传感器评估板,实现加速度参数获取。

LIS3DH 加速度计传感器使用IIC与开发板进行通信,因此选用开发板上的IIC接口与加速度计传感器评估板进行连接。

image.png

相较于电机控制,在STM32CubeMX中新增了IIC接口用于获取传感器参数

image.png

设计加速度计传感器驱动代码如下,实现三轴加速度数据的获取

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file    lis3dhtr.c
  * @brief   Driver implementation for the LIS3DHTR over I2C.
  *
  *          See lis3dhtr.h for the configuration that is applied on init.
  *          The I2C helpers (ReadReg / WriteReg / ReadMulti) treat the device
  *          as auto-increment capable, which the LIS3DHTR is for the data
  *          registers. For single-byte accesses we still pass length = 1.
  *
  ******************************************************************************
  */
/* USER CODE END Header */
#include "lis3dhtr.h"

#include <stddef.h>

/* USER CODE BEGIN 0 */

/* USER CODE END 0 */

/* ------------------------------------------------------------------------- */
/* Low-level I2C helpers                                                    */
/* ------------------------------------------------------------------------- */

static lis3_status_t LIS3_ReadReg(lis3_t *dev,
                                  uint8_t reg,
                                  uint8_t *data,
                                  uint16_t len)
{
  if (dev == NULL || dev->hi2c == NULL || data == NULL || len == 0U)
  {
    return LIS3_ERR_PARAM;
  }

  /* The LIS3DHTR on this board answers WHO_AM_I only when SUB equals the
   * raw register address (no shift). For multi-byte reads the top bit
   * (0x80) must be OR-ed in to engage the internal address auto-increment
   * so the part walks OUT_X_L, OUT_X_H, OUT_Y_L, ... consecutively.
   *
   * Concretely (verified on the bench):
   *   SUB = 0x0F            -> returns WHO_AM_I = 0x33           (single byte)
   *   SUB = 0x0F | 0x80=0x8F-> also works, but redundant for len=1
   *   SUB = 0x28            -> returns OUT_X_L then *repeats*     (len=6, bug)
   *   SUB = 0x28 | 0x80=0xA8-> returns OUT_X_L..OUT_Z_H correctly (len=6)
   *
   * So:
   *   SUB = reg                       when len == 1
   *   SUB = reg | 0x80                when len  > 1
   */
  uint8_t sub = (uint8_t)(reg | ((len > 1U) ? 0x80U : 0x00U));

  dev->last_hal_status = HAL_I2C_Mem_Read(dev->hi2c,
                                          (uint16_t)(dev->addr << 1),
                                          sub,
                                          I2C_MEMADD_SIZE_8BIT,
                                          data,
                                          len,
                                          100U);
  if (dev->last_hal_status != HAL_OK)
  {
    return LIS3_ERR_I2C;
  }
  return LIS3_OK;
}

static lis3_status_t LIS3_WriteReg(lis3_t *dev,
                                   uint8_t reg,
                                   const uint8_t *data,
                                   uint16_t len)
{
  if (dev == NULL || dev->hi2c == NULL || data == NULL || len == 0U)
  {
    return LIS3_ERR_PARAM;
  }

  /* Same SUB encoding as reads. */
  uint8_t sub = (uint8_t)(reg | ((len > 1U) ? 0x80U : 0x00U));

  dev->last_hal_status = HAL_I2C_Mem_Write(dev->hi2c,
                                           (uint16_t)(dev->addr << 1),
                                           sub,
                                           I2C_MEMADD_SIZE_8BIT,
                                           (uint8_t *)data,
                                           len,
                                           100U);
  if (dev->last_hal_status != HAL_OK)
  {
    return LIS3_ERR_I2C;
  }
  return LIS3_OK;
}

/* ------------------------------------------------------------------------- */
/* Public API                                                               */
/* ------------------------------------------------------------------------- */

lis3_status_t LIS3_ReadID(lis3_t *dev, uint8_t *whoami)
{
  uint8_t id = 0U;
  lis3_status_t st = LIS3_ReadReg(dev, LIS3_REG_WHO_AM_I, &id, 1U);
  if (st != LIS3_OK)
  {
    return st;
  }
  if (whoami != NULL)
  {
    *whoami = id;
  }
  return LIS3_OK;
}

lis3_status_t LIS3_SoftReset(lis3_t *dev)
{
  uint8_t ctrl5 = 0U;
  lis3_status_t st;

  st = LIS3_ReadReg(dev, LIS3_REG_CTRL_REG5, &ctrl5, 1U);
  if (st != LIS3_OK)
  {
    return st;
  }
  ctrl5 |= LIS3_CTRL_REG5_BOOT;
  st = LIS3_WriteReg(dev, LIS3_REG_CTRL_REG5, &ctrl5, 1U);
  if (st != LIS3_OK)
  {
    return st;
  }
  HAL_Delay(5U);
  ctrl5 &= (uint8_t)(~LIS3_CTRL_REG5_BOOT);
  return LIS3_WriteReg(dev, LIS3_REG_CTRL_REG5, &ctrl5, 1U);
}

lis3_status_t LIS3_Init(lis3_t *dev)
{
  lis3_status_t st;
  uint8_t whoami = 0U;
  uint8_t tmp;
  const uint8_t probe[2] = { LIS3_I2C_ADDR_SA0_HIGH, LIS3_I2C_ADDR_SA0_LOW };

  if (dev == NULL || dev->hi2c == NULL)
  {
    return LIS3_ERR_PARAM;
  }

  /* Probe the two possible addresses and remember the one that acknowledges. */
  dev->addr = 0U;
  for (uint32_t i = 0U; i < 2U; ++i)
  {
    dev->addr = probe[i];
    st = LIS3_ReadID(dev, &whoami);
    if (st == LIS3_OK && whoami == LIS3_WHO_AM_I_VAL)
    {
      break;
    }
    dev->addr = 0U;
  }

  if (dev->addr == 0U)
  {
    return LIS3_ERR_ID;
  }

  /* Apply the phase-1 configuration:
   *   - CTRL_REG1 = ODR 400 Hz, all axes on, normal power
   *   - CTRL_REG2 = bypass all high-pass filters
   *   - CTRL_REG3 = no interrupts (also disables FIFO-related INT1/INT2)
   *   - CTRL_REG4 = HR mode, +/-8 g, BDU on
   *   - CTRL_REG5 = FIFO off (bypass)
   *   - FIFO_CTRL_REG = Bypass (FM=00)
   */
  tmp = LIS3_CTRL_REG1_ODR_400HZ
      | LIS3_CTRL_REG1_XEN
      | LIS3_CTRL_REG1_YEN
      | LIS3_CTRL_REG1_ZEN;
  st = LIS3_WriteReg(dev, LIS3_REG_CTRL_REG1, &tmp, 1U);
  if (st != LIS3_OK) { return st; }

  tmp = 0x00U;
  st = LIS3_WriteReg(dev, LIS3_REG_CTRL_REG2, &tmp, 1U);
  if (st != LIS3_OK) { return st; }

  tmp = 0x00U;
  st = LIS3_WriteReg(dev, LIS3_REG_CTRL_REG3, &tmp, 1U);
  if (st != LIS3_OK) { return st; }

  tmp = LIS3_CTRL_REG4_HR | LIS3_CTRL_REG4_FS_8G | LIS3_CTRL_REG4_BDU;
  st = LIS3_WriteReg(dev, LIS3_REG_CTRL_REG4, &tmp, 1U);
  if (st != LIS3_OK) { return st; }

  tmp = 0x00U;
  st = LIS3_WriteReg(dev, LIS3_REG_CTRL_REG5, &tmp, 1U);
  if (st != LIS3_OK) { return st; }

  tmp = 0x00U; /* Bypass */
  st = LIS3_WriteReg(dev, LIS3_REG_FIFO_CTRL_REG, &tmp, 1U);
  if (st != LIS3_OK) { return st; }

  return LIS3_OK;
}

lis3_status_t LIS3_ReadAccel(lis3_t *dev, int16_t *x, int16_t *y, int16_t *z)
{
  uint8_t raw[6] = {0};
  lis3_status_t st;

  /* Burst read of the six OUT_X/Y/Z data registers in one I2C transaction.
   * LIS3_ReadReg sets SUB[0] (= IF_ADD_INC) so the part walks the address
   * internally. This is the recommended fast-path. */
  st = LIS3_ReadReg(dev, LIS3_REG_OUT_X_L, raw, 6U);
  if (st != LIS3_OK)
  {
    return st;
  }

  /* HR mode: data is left-aligned 16-bit, low nibble is zero. */
  int16_t xl = (int16_t)(((uint16_t)raw[1] << 8) | raw[0]);
  int16_t yl = (int16_t)(((uint16_t)raw[3] << 8) | raw[2]);
  int16_t zl = (int16_t)(((uint16_t)raw[5] << 8) | raw[4]);

  if (x != NULL) { *x = (int16_t)(xl >> 4); }
  if (y != NULL) { *y = (int16_t)(yl >> 4); }
  if (z != NULL) { *z = (int16_t)(zl >> 4); }
  return LIS3_OK;
}

lis3_status_t LIS3_ReadAccelMG(lis3_t *dev,
                               int32_t *x_mg,
                               int32_t *y_mg,
                               int32_t *z_mg)
{
  int16_t x = 0, y = 0, z = 0;
  lis3_status_t st = LIS3_ReadAccel(dev, &x, &y, &z);
  if (st != LIS3_OK)
  {
    return st;
  }

  if (x_mg != NULL) { *x_mg = (int32_t)x * LIS3_SENSITIVITY_HR_8G_MG; }
  if (y_mg != NULL) { *y_mg = (int32_t)y * LIS3_SENSITIVITY_HR_8G_MG; }
  if (z_mg != NULL) { *z_mg = (int32_t)z * LIS3_SENSITIVITY_HR_8G_MG; }
  return LIS3_OK;
}

lis3_status_t LIS3_FIFO_SetMode(lis3_t *dev, lis3_fifo_mode_t mode)
{
  uint8_t ctrl5 = 0U;
  uint8_t fifo_ctrl = 0U;
  lis3_status_t st;

  /* Read both registers first; we must preserve FTH[4:0] when changing
   * FM[1:0] (FIFO_CTRL_REG) and never touch BDU / HR bits in CTRL_REG4. */
  st = LIS3_ReadReg(dev, LIS3_REG_CTRL_REG5, &ctrl5, 1U);
  if (st != LIS3_OK) { return st; }
  st = LIS3_ReadReg(dev, LIS3_REG_FIFO_CTRL_REG, &fifo_ctrl, 1U);
  if (st != LIS3_OK) { return st; }

  if (mode == LIS3_FIFO_BYPASS)
  {
    ctrl5 &= (uint8_t)(~LIS3_CTRL_REG5_FIFO_EN);
    fifo_ctrl = (uint8_t)(fifo_ctrl & 0xF8U); /* clear FM[1:0], keep FTH */
  }
  else
  {
    ctrl5 |= LIS3_CTRL_REG5_FIFO_EN;
    fifo_ctrl = (uint8_t)((fifo_ctrl & 0xF8U) | (mode & 0x03U));
  }

  /* Per the datasheet, set CTRL_REG5.FIFO_EN first, then FIFO_CTRL_REG. */
  st = LIS3_WriteReg(dev, LIS3_REG_CTRL_REG5, &ctrl5, 1U);
  if (st != LIS3_OK) { return st; }
  return LIS3_WriteReg(dev, LIS3_REG_FIFO_CTRL_REG, &fifo_ctrl, 1U);
}

lis3_status_t LIS3_FIFO_SetWatermark(lis3_t *dev, uint8_t level)
{
  uint8_t reg = 0U;
  lis3_status_t st = LIS3_ReadReg(dev, LIS3_REG_FIFO_CTRL_REG, &reg, 1U);
  if (st != LIS3_OK) { return st; }

  /* FIFO_CTRL_REG layout:
   *   bits[7:3] = FTH[4:0]  (watermark level, 0..31)
   *   bits[2]   = 0 (reserved, must be 0)
   *   bits[1:0] = FM[1:0]   (FIFO mode)
   * Preserve FM, clear reserved bit, set new FTH. */
  if (level > 31U) { level = 31U; }
  reg = (uint8_t)((reg & 0x03U) | (level << 3));
  return LIS3_WriteReg(dev, LIS3_REG_FIFO_CTRL_REG, &reg, 1U);
}

lis3_status_t LIS3_FIFO_GetSamples(lis3_t *dev, uint16_t *count)
{
  uint8_t src = 0U;
  lis3_status_t st = LIS3_ReadReg(dev, LIS3_REG_FIFO_SRC_REG, &src, 1U);
  if (st != LIS3_OK) { return st; }
  if (count != NULL) { *count = (uint16_t)(src & 0x1FU); }
  return LIS3_OK;
}

lis3_status_t LIS3_FIFO_GetRaw(lis3_t *dev, uint8_t *src)
{
  return LIS3_ReadReg(dev, LIS3_REG_FIFO_SRC_REG, src, 1U);
}

lis3_status_t LIS3_ReadRegByte(lis3_t *dev, uint8_t reg, uint8_t *out)
{
  return LIS3_ReadReg(dev, reg, out, 1U);
}

lis3_status_t LIS3_FIFO_ReadSamples(lis3_t *dev, int16_t *out, uint16_t count)
{
  if (count == 0U) { return LIS3_OK; }
  if (out == NULL) { return LIS3_ERR_PARAM; }

  /* Per-sample, 6-byte burst read. The driver helper sets SUB[7] (the
   * IF_ADD_INC bit on this part) so the part walks through OUT_X_L,
   * OUT_X_H, OUT_Y_L, ... in a single I2C transaction. */
  for (uint16_t i = 0U; i < count; ++i)
  {
    uint8_t raw[6] = {0};
    lis3_status_t st = LIS3_ReadReg(dev, LIS3_REG_OUT_X_L, raw, 6U);
    if (st != LIS3_OK) { return st; }

    int16_t xl = (int16_t)(((uint16_t)raw[1] << 8) | raw[0]);
    int16_t yl = (int16_t)(((uint16_t)raw[3] << 8) | raw[2]);
    int16_t zl = (int16_t)(((uint16_t)raw[5] << 8) | raw[4]);

    out[3U * i + 0U] = (int16_t)(xl >> 4);
    out[3U * i + 1U] = (int16_t)(yl >> 4);
    out[3U * i + 2U] = (int16_t)(zl >> 4);
  }
  return LIS3_OK;
}

lis3_status_t LIS3_StartFifoStream(lis3_t *dev, uint8_t watermark)
{
  lis3_status_t st;
  uint8_t dummy = 0U;

  /* Make sure CTRL_REG1/4 are set (HR + 400 Hz + XYZ + BDU). LIS3_Init
   * already does this, but allow the caller to use this function on its
   * own. */

  /* 1) Program the watermark level first while we are still in Bypass so
   *    there is no risk of triggering WTM right after switching mode. */
  st = LIS3_FIFO_SetWatermark(dev, watermark);
  if (st != LIS3_OK) { return st; }

  /* 2) Switch to Stream mode (FM=10) and turn on FIFO_EN together. */
  st = LIS3_FIFO_SetMode(dev, LIS3_FIFO_STREAM);
  if (st != LIS3_OK) { return st; }

  /* 3) Flush any pre-existing sample by reading FIFO_SRC_REG once. The
   *    hardware pops the oldest entry on each OUT_X..Z burst, so a
   *    single dummy read here is enough to clear what the part had
   *    stored before the mode change. */
  (void)LIS3_ReadReg(dev, LIS3_REG_FIFO_SRC_REG, &dummy, 1U);
  return LIS3_OK;
}

lis3_status_t LIS3_StopFifo(lis3_t *dev)
{
  return LIS3_FIFO_SetMode(dev, LIS3_FIFO_BYPASS);
}

/* USER CODE BEGIN 1 */

/**
 * Diagnostic helper: try every plausible SUB-encoding for the LIS3DHTR
 * family and print the byte the part actually returns for WHO_AM_I.
 *
 * The LIS3DH datasheet defines SUB as [A7..A1 | IF_ADD_INC], which
 * would mean SUB = (reg << 1) | (auto_inc). However, several reference
 * drivers (H3LIS331DL on RPi, Arduino LIS3DHTR breakout code) just
 * pass the raw register address as SUB and the part still answers
 * correctly. We let the chip decide which encoding it wants.
 */
lis3_status_t LIS3_Diag_ProbeWhoAmI(I2C_HandleTypeDef *hi2c,
                                    uint8_t addr,
                                    uint8_t *out_byte)
{
  static const struct
  {
    const char *label;
    uint8_t     sub;
  } variants[] = {
    { "reg"        , 0x0F        },
    { "reg<<1"     , 0x0F << 1   },
    { "reg|0x80"   , 0x0F | 0x80 },
  };

  for (uint32_t i = 0U; i < sizeof(variants) / sizeof(variants[0]); ++i)
  {
    uint8_t b = 0xFFU;
    HAL_StatusTypeDef r = HAL_I2C_Mem_Read(
        hi2c,
        (uint16_t)(addr << 1),
        variants[i].sub,
        I2C_MEMADD_SIZE_8BIT,
        &b, 1U, 100U);
    printf("[DIAG] addr=0x%02X sub=%s (0x%02X) -> r=%d byte=0x%02X\r\n",
           (unsigned)addr, variants[i].label, (unsigned)variants[i].sub,
           (int)r, (unsigned)b);
    if (r == HAL_OK && b == LIS3_WHO_AM_I_VAL)
    {
      if (out_byte != NULL) { *out_byte = b; }
      return LIS3_OK;
    }
  }
  return LIS3_ERR_ID;
}

/**
 * Diagnostic helper: read 6 bytes starting at OUT_X_L and print them
 * under each of the SUB encodings so we can see which one actually
 * returns the accelerometer data.
 */
void LIS3_Diag_ProbeAccel(I2C_HandleTypeDef *hi2c, uint8_t addr)
{
  static const struct
  {
    const char *label;
    uint8_t     sub;
  } variants[] = {
    { "reg"        , 0x28        },
    { "reg<<1"     , 0x28 << 1   },
    { "reg|0x80"   , 0x28 | 0x80 },
  };

  for (uint32_t i = 0U; i < sizeof(variants) / sizeof(variants[0]); ++i)
  {
    uint8_t raw[6] = {0};
    HAL_StatusTypeDef r = HAL_I2C_Mem_Read(
        hi2c,
        (uint16_t)(addr << 1),
        variants[i].sub,
        I2C_MEMADD_SIZE_8BIT,
        raw, 6U, 100U);
    printf("[DIAG] accel sub=%s (0x%02X) r=%d raw={%02X %02X %02X %02X %02X %02X}\r\n",
           variants[i].label, (unsigned)variants[i].sub, (int)r,
           (unsigned)raw[0], (unsigned)raw[1], (unsigned)raw[2],
           (unsigned)raw[3], (unsigned)raw[4], (unsigned)raw[5]);
  }
}

/* USER CODE END 1 */

在主函数方面,由于我们需要实现的是传感器参数的读取,而电机控制依赖于时钟中断,因此可以将电机控制的相关函数放入stm32h5xx_it.c,使电机的控制依赖滴答定时器

/**
  * @brief This function handles System tick timer.
  */
void SysTick_Handler(void)
{
  /* USER CODE BEGIN SysTick_IRQn 0 */

  /* USER CODE END SysTick_IRQn 0 */
  HAL_IncTick();
  /* USER CODE BEGIN SysTick_IRQn 1 */
  StepMotor_Tick();
  /* USER CODE END SysTick_IRQn 1 */
}

这样我们就可以在主函数中调用输出加速度计参数接口了

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  lis3dev.hi2c = &hi2c1;
  lis3_status_t status = LIS3_Init(&lis3dev);
  if (status != LIS3_OK)
  {
    char message[48];
    int length = snprintf(message, sizeof(message), "# LIS3 init error: %d\r\n", (int)status);
    if (length > 0 && (size_t)length < sizeof(message))
    {
      COM_Write(message, (uint16_t)length);
    }
    Error_Handler();
  }

  {
    uint32_t primask = __get_PRIMASK();
    __disable_irq();
    StepMotor_Init();
    motor_initialized = 1U;
    __set_PRIMASK(primask);
  }
  {
    static const char header[] = "# acceleration mg: x y z\r\n";
    COM_Write(header, (uint16_t)(sizeof(header) - 1U));
  }
  uint32_t last_report = HAL_GetTick();

  while (1)
  {

    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
    uint32_t now = HAL_GetTick();
    if ((uint32_t)(now - last_report) >= ACCEL_REPORT_INTERVAL_MS)
    {
      int32_t x, y, z;
      char message[64];
      int length;
      last_report = now;
      status = LIS3_ReadAccelMG(&lis3dev, &x, &y, &z);
      if (status == LIS3_OK)
      {
        length = snprintf(message, sizeof(message), "%ld %ld %ld\r\n",
                          (long)x, (long)y, (long)z);
      }
      else
      {
        length = snprintf(message, sizeof(message), "# LIS3 read error: %d\r\n", (int)status);
      }
      if (length <= 0 || (size_t)length >= sizeof(message))
      {
        Error_Handler();
      }
      COM_Write(message, (uint16_t)length);
    }
  }
  /* USER CODE END 3 */
}

实现效果如下,可以看到在串口输出了加速度计数据,每行包含xyz三个轴的加速度值

image.png

完整工程代码如下

accelerometer_get.zip




关键词: 加速度     STM32H5    

共1条 1/1 1 跳转至页

回复

匿名不能发帖!请先 [ 登陆 注册 ]