本文将基于上一篇帖子中的电机控制代码,使用LIS3DH 加速度计传感器评估板,实现加速度参数获取。
LIS3DH 加速度计传感器使用IIC与开发板进行通信,因此选用开发板上的IIC接口与加速度计传感器评估板进行连接。

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

设计加速度计传感器驱动代码如下,实现三轴加速度数据的获取
/* 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, ®, 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, ®, 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三个轴的加速度值

完整工程代码如下
我要赚赏金
