1. 项目缘起:为什么选择STM32F103C8T6与ADXL345?
大家好,我是老李,一个在嵌入式领域摸爬滚打了十多年的“老码农”。今天想和大家聊聊一个既经典又实用的项目——用STM32F103C8T6和ADXL345加速度传感器做一个嵌入式计步器。你可能觉得,现在手机、手环计步功能都烂大街了,自己做这个有啥意思?嘿,这你就不懂了。自己动手从零搭建一个计步系统,从硬件接线、驱动编写,到算法调试、步数显示,这整个过程能让你把嵌入式开发的“十八般武艺”都练一遍。尤其是那个动态阈值算法,调通了之后,那种成就感,可比单纯调用一个现成的API爽多了。
我选择STM32F103C8T6这块“蓝宝”开发板,原因很简单:它便宜、皮实、资料多。作为ARM Cortex-M3内核的经典款,72MHz的主频处理传感器数据绰绰有余,丰富的GPIO和通信接口让它能轻松驾驭各种外设。最关键的是,社区生态极其成熟,你遇到的几乎所有坑,网上都能找到前人的脚印。而ADXL345呢,是一款非常经典的数字三轴加速度计,分辨率高、功耗低,还支持I2C和SPI两种通信方式,对于学习和项目原型开发来说,简直是绝配。这个组合,可以说是嵌入式入门到进阶的“黄金搭档”,既能让你理解底层硬件通信,又能深入算法核心,性价比超高。
这个项目最终要实现的目标是:将ADXL345佩戴在身上(比如放在口袋里),单片机实时读取加速度数据,通过一套算法精准地识别出步伐,并将步数显示在一块小OLED屏幕上。听起来不复杂,对吧?但里面涉及的知识点可不少:I2C总线通信、传感器数据读取与处理、数字滤波、动态阈值计算、状态机判断等等。我会把我实际开发中踩过的坑、调试的技巧、参数的调整心得,都毫无保留地分享出来。咱们不玩虚的,直接上干货,保证你跟着做,就能得到一个能跑起来的计步器。
2. 硬件搭建与通信基础:让STM32和ADXL345“对上话”
2.1 硬件连接与I2C地址选择
万事开头难,咱们先从硬件连接说起。你需要准备的材料很简单:一块STM32F103C8T6核心板(或者最小系统板)、一个ADXL345模块(通常自带电平转换和上拉电阻)、一块OLED显示屏(用于显示步数),以及若干杜邦线。
ADXL345模块的引脚通常印得很清楚。我们使用I2C通信,所以关键引脚是VCC、GND、SDA(数据线)、SCL(时钟线)。还有一个非常重要的引脚叫SDO/ALT ADDRESS,它决定了传感器的I2C从机地址。当这个引脚接高电平(或悬空,模块内部可能已上拉)时,设备地址是0x1D(写地址0x3A,读地址0x3B);当它接地时,设备地址变为0x53(写地址0xA6,读地址0xA7)。我强烈建议你把它接地,使用0xA6/0xA7这个地址,因为这是最常见、最不容易冲突的配置。接线时,记得将STM32的I2C引脚(例如PB6-SCL, PB7-SDA)与模块对应连接,并且VCC接3.3V,千万别接5V,否则可能损坏传感器。
这里有个我踩过的坑:早期一些模块可能没有在SDA和SCL线上集成上拉电阻。I2C总线是开漏输出,必须依靠上拉电阻才能输出高电平。如果模块上没有(通常是一个4.7kΩ或10kΩ的贴片电阻),你就需要在STM32的这两个引脚到3.3V之间,各外接一个4.7kΩ的电阻,否则通信根本无法建立。现在大多数模块都集成了,但检查一下总没错。
2.2 软件I2C驱动实现
接下来是软件部分。首先我们需要实现I2C的底层驱动。虽然STM32有硬件I2C外设,但它的配置相对复杂,而且早年有些库的硬件I2C稳定性口碑一般。所以很多教程,包括我这次,都选择用GPIO口模拟的“软件I2C”。它的好处是时序完全可控,移植性强,理解起来也更直观。
软件I2C的本质就是用两个普通的GPIO口,按照I2C协议的时序图,模拟出起始信号、停止信号、发送一个比特(位)、接收一个比特、发送应答(ACK)和非应答(NACK)的过程。代码看起来有点繁琐,但结构很清晰。下面是我常用的一个软件I2C初始化与基本函数集的核心片段,我加了详细注释:
// 首先,定义SDA和SCL对应的GPIO引脚,这里以PB6, PB7为例
#define I2C_SCL_PORT GPIOB
#define I2C_SCL_PIN GPIO_Pin_6
#define I2C_SDA_PORT GPIOB
#define I2C_SDA_PIN GPIO_Pin_7
// 初始化函数,将引脚配置为开漏输出模式,并先拉高
void MyI2C_Init(void) {
GPIO_InitTypeDef GPIO_InitStructure;
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE); // 使能时钟
// SCL线初始化
GPIO_InitStructure.GPIO_Pin = I2C_SCL_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD; // 开漏输出
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(I2C_SCL_PORT, &GPIO_InitStructure);
// SDA线初始化
GPIO_InitStructure.GPIO_Pin = I2C_SDA_PIN;
GPIO_Init(I2C_SDA_PORT, &GPIO_InitStructure);
// 初始状态拉高总线
GPIO_SetBits(I2C_SCL_PORT, I2C_SCL_PIN);
GPIO_SetBits(I2C_SDA_PORT, I2C_SDA_PIN);
}
// 产生I2C起始信号:SCL高电平期间,SDA产生一个下降沿
void MyI2C_Start(void) {
SDA_OUT(); // 设置SDA为输出模式
I2C_SDA_HIGH();
I2C_SCL_HIGH();
delay_us(5); // 短暂延时,满足建立时间
I2C_SDA_LOW();
delay_us(5);
I2C_SCL_LOW(); // 钳住总线,准备发送数据
}
// 产生I2C停止信号:SCL高电平期间,SDA产生一个上升沿
void MyI2C_Stop(void) {
SDA_OUT();
I2C_SDA_LOW();
I2C_SCL_HIGH();
delay_us(5);
I2C_SDA_HIGH();
delay_us(5);
}
// 发送一个字节(8位),从高位开始
uint8_t MyI2C_SendByte(uint8_t byte) {
uint8_t i, ack_bit;
SDA_OUT();
for (i = 0; i < 8; i++) {
if (byte & 0x80) I2C_SDA_HIGH(); // 判断最高位
else I2C_SDA_LOW();
delay_us(2);
I2C_SCL_HIGH();
delay_us(5); // 保证SCL高电平周期大于4.7us
I2C_SCL_LOW();
delay_us(2);
byte <<= 1; // 左移一位,准备发送下一位
}
// 读取应答位
SDA_IN(); // 切换SDA为输入模式,读取从机应答
I2C_SDA_HIGH(); // 主机释放SDA线
delay_us(2);
I2C_SCL_HIGH();
delay_us(5);
ack_bit = GPIO_ReadInputDataBit(I2C_SDA_PORT, I2C_SDA_PIN); // 读取SDA电平
I2C_SCL_LOW();
SDA_OUT(); // 切换回输出模式,为后续操作做准备
return ack_bit; // 返回0表示应答,1表示非应答
}
写驱动时,最需要注意的就是时序。I2C协议对SCL高电平和低电平的持续时间有要求,标准模式是100kHz,快速模式是400kHz。我们用delay_us()函数来产生微秒级延时,模拟这个时序。延时不能太短,否则从设备来不及反应;也不能太长,否则整体通信速度太慢。我实测下来,在72MHz主频下,每个delay_us(5)是比较稳定的选择。调试时,如果通信失败,第一个要怀疑的就是时序问题,可以用逻辑分析仪或者示波器抓一下SDA和SCL的波形,看看起始、停止、数据位的波形是否符合规范。
3. ADXL345传感器驱动与数据读取
3.1 传感器初始化与配置
硬件通了,下一步就是和ADXL345“握手”,把它配置成我们想要的工作模式。这需要通过I2C向它的内部寄存器写入特定的值。ADXL345的数据手册有几十页,但对于计步应用,我们只需要关注几个关键寄存器。
首先,我们必须知道设备的地址。前面说了,我让SDO引脚接地,所以写地址是0xA6,读地址是0xA7。在代码里,我们通常定义写地址ADXL345_WRITE 0xA6。初始化流程一般是这样的:上电 -> 等待一小段时间(比如10ms)让传感器稳定 -> 依次配置几个寄存器。
这里我给出一个经过我实测可用的初始化函数,并解释每个配置的作用:
#define ADXL345_ADDRESS_WRITE 0xA6
#define ADXL345_ADDRESS_READ 0xA7
void ADXL345_Init(void) {
MyI2C_Init(); // 初始化I2C引脚
delay_ms(10); // 上电延时,非常重要!
// 1. 设置数据格式(寄存器0x31):选择量程和分辨率
// 0x0B = 0000 1011:Bit3置1启用全分辨率(13位),Bit1:0为11表示±16g量程
// 对于计步,±4g或±8g也够用,但±16g容错性更好。
ADXL345_WriteReg(0x31, 0x0B);
// 2. 设置带宽速率(寄存器0x2C):决定数据输出速率和带宽
// 0x08 = 0000 1000:输出数据速率设为12.5Hz。这个值很关键!
// 计步不需要太高频率,12.5Hz意味着每秒采样12.5次,完全能捕捉步行节奏。
// 太高频率会引入更多高频噪声,增加处理负担;太低则会丢失步态特征。
ADXL345_WriteReg(0x2C, 0x08);
// 3. 电源控制(寄存器0x2D):开启测量模式
// 0x08 = 0000 1000:Bit3置1,进入测量模式。其他位保持默认(如不启用休眠等)。
ADXL345_WriteReg(0x2D, 0x08);
// 4. 使能DATA_READY中断(寄存器0x2E):可选,我们采用查询方式,这里先不使能
// ADXL345_WriteReg(0x2E, 0x80);
// 5. 偏移校准(寄存器0x1E, 0x1F, 0x20):这是提高精度的关键一步!
// 传感器静止水平放置时,理想状态下X、Y轴输出应为0,Z轴输出为重力加速度(约256 LSB @ ±2g)。
// 但实际上每个传感器都有零漂。你需要先读取静止时的数据,计算偏移量,再写回。
// 这里先写0,我们后面专门讲校准。
ADXL345_WriteReg(0x1E, 0x00); // X轴偏移
ADXL345_WriteReg(0x1F, 0x00); // Y轴偏移
ADXL345_WriteReg(0x20, 0x00); // Z轴偏移
}
这里重点说一下**输出数据速率(ODR)**的选择。数据手册给出了从0.1Hz到3200Hz的多种选择。对于计步,12.5Hz或25Hz是一个甜点。人的步行频率大概在1-2.5步/秒,跑步会更高一些。根据奈奎斯特采样定理,采样频率至少是信号最高频率的两倍。12.5Hz的采样率足以捕捉步态,同时能有效抑制远高于步频的高频噪声(比如手部抖动),相当于自带了一个低通滤波的效果。如果你设为100Hz或更高,你会发现原始数据“毛刺”非常多,后续滤波算法压力会很大。
3.2 读取三轴加速度数据
配置好后,ADXL345就会以设定的速率不断测量加速度,并把数据更新到其数据寄存器中(地址0x32到0x37)。我们需要做的就是周期性地去读取这6个字节(X轴2字节、Y轴2字节、Z轴2字节)。
读取多个字节的I2C操作有个小技巧:发送完寄存器起始地址后,发送一个重复起始条件(Repeated Start),而不是停止条件,然后发送读地址,就可以连续读取多个字节。单片机每读取一个字节后,需要发送一个应答(ACK),告诉传感器“我还要读下一个”;读取最后一个字节后,发送非应答(NACK),然后停止条件。下面这个函数实现了连续读取6字节并合成三个16位有符号数(补码格式)的功能:
// 从ADXL345读取X,Y,Z三轴的原始数据(16位有符号整数)
void ADXL345_ReadXYZ(short *pX, short *pY, short *pZ) {
uint8_t buffer[6];
uint8_t i;
// 1. 发送起始条件 + 写地址 + 要读取的寄存器起始地址 (0x32)
MyI2C_Start();
MyI2C_SendByte(ADXL345_ADDRESS_WRITE); // 发送写地址
// 通常MyI2C_SendByte内部会检查ACK,这里省略了ACK检查的代码
MyI2C_SendByte(0x32); // 发送数据寄存器起始地址
// 2. 发送重复起始条件 + 读地址
MyI2C_Start(); // 重复起始条件
MyI2C_SendByte(ADXL345_ADDRESS_READ); // 发送读地址
// 3. 连续读取6个字节数据
for (i = 0; i < 6; i++) {
// 读取一个字节。注意:前5个字节需要主机回复ACK,最后一个字节回复NACK
buffer[i] = MyI2C_ReceiveByte();
if (i == 5) {
MyI2C_SendAck(1); // 发送NACK (1)
} else {
MyI2C_SendAck(0); // 发送ACK (0)
}
}
// 4. 发送停止条件
MyI2C_Stop();
// 5. 合成数据。注意:ADXL345的数据是低位字节在前!
*pX = (short)(((uint16_t)buffer[1] << 8) | buffer[0]);
*pY = (short)(((uint16_t)buffer[3] << 8) | buffer[2]);
*pZ = (short)(((uint16_t)buffer[5] << 8) | buffer[4]);
}
拿到原始数据后,你可以通过串口打印出来看看。把传感器静止水平放置,理论上X=0, Y=0, Z=+256(假设量程是±2g,1g对应256 LSB)。但你很可能会看到X=+5, Y=-12, Z=268这样的值。这就是零漂。为了获得更准确的结果,我们需要进行简单的校准:记录静止时各轴的输出值,取其相反数,写入对应的偏移寄存器(0x1E, 0x1F, 0x20)。注意,偏移寄存器的单位是15.6mg/LSB,而数据输出是3.9mg/LSB(13位,±4g时),所以写入的值应该是 偏移量 = -(实测值 / 4)。例如,静止时X轴读数为+8,那么应向0x1E寄存器写入 -8 / 4 = -2(以二进制补码形式)。校准后,静止输出会更接近理想值。
4. 计步算法的核心:动态阈值与线性移位寄存器
好了,现在我们能稳定地读取到三轴加速度数据了。但这些原始数据就像一团乱麻,直接看根本看不出步伐。接下来就是最核心、最有趣的部分——算法。我们将实现一个基于动态阈值和线性移位寄存器的轻量级计步算法。这个算法源自ADI官方的应用笔记,效果不错,计算量也适合在STM32上运行。
4.1 均值滤波:给数据“降噪”
传感器数据天生带有噪声,可能是电路噪声,也可能是微小的手部颤动。第一步就是滤波。我们采用最简单的滑动均值滤波。它的思想是:连续取N个采样值,求其算术平均值作为当前的有效值。这能平滑掉高频的随机噪声。
#define FILTER_WINDOW_SIZE 4 // 滤波窗口大小,我一般取4
typedef struct {
short x;
short y;
short z;
} AxisData_t; // 三轴数据结构体
AxisData_t filterBuffer[FILTER_WINDOW_SIZE]; // 滤波缓冲区
uint8_t filterIndex = 0; // 缓冲区索引
// 均值滤波函数,输入最新原始数据,输出滤波后的数据
AxisData_t Moving_Average_Filter(AxisData_t newSample) {
AxisData_t filtered = {0, 0, 0};
static uint8_t count = 0;
static AxisData_t sum = {0, 0, 0};
// 更新滑动窗口和总和
sum.x = sum.x - filterBuffer[filterIndex].x + newSample.x;
sum.y = sum.y - filterBuffer[filterIndex].y + newSample.y;
sum.z = sum.z - filterBuffer[filterIndex].z + newSample.z;
filterBuffer[filterIndex] = newSample;
filterIndex = (filterIndex + 1) % FILTER_WINDOW_SIZE;
// 如果还没填满窗口,递增计数
if (count < FILTER_WINDOW_SIZE) {
count++;
}
// 计算平均值
filtered.x = sum.x / count;
filtered.y = sum.y / count;
filtered.z = sum.z / count;
return filtered;
}
这个函数实现了一个高效的滑动窗口。它不需要每次都对整个数组求和,而是维护一个总和变量,减去最旧的值,加上最新的值。这样计算量是常数,非常适合嵌入式系统。窗口大小FILTER_WINDOW_SIZE是个可调参数。太小了滤波效果不好,太大了会导致响应迟钝,可能漏掉快速的步伐变化。经过我的测试,在12.5Hz采样率下,窗口大小设为4(即约0.32秒的数据)是一个很好的平衡点。
4.2 动态阈值:自适应步伐检测的门槛
滤波后的数据波形看起来规整了一些,但如何判断一步呢?最直观的想法是设定一个固定的加速度阈值,超过就算一步。但问题来了:不同的人走路力度不同,同一个人走路和跑步的幅度也不同,传感器佩戴的位置(口袋、手腕)也会导致信号幅度差异巨大。固定阈值要么太敏感(误检),要么太迟钝(漏检)。
动态阈值就是为了解决这个问题而生的。它的核心思想是:系统持续监测最近一段时间内加速度的最大值和最小值,并以它们的中点作为当前判断步伐的阈值。这个阈值会随着你的运动状态自动调整。当你快跑时,加速度变化剧烈,最大最小值差距大,阈值也随之升高;当你慢走时,变化平缓,阈值就降低。
我们通常以50个滤波后的样本(约4秒的数据)为一个周期,来更新这个动态阈值。以下是关键的数据结构和更新函数:
#define SAMPLE_SIZE_FOR_THRESHOLD 50 // 用于计算动态阈值的样本数
typedef struct {
AxisData_t max; // 过去50个样本中的最大值
AxisData_t min; // 过去50个样本中的最小值
} DynamicThreshold_t;
DynamicThreshold_t threshold; // 全局阈值结构体
AxisData_t sampleWindow[SAMPLE_SIZE_FOR_THRESHOLD]; // 样本窗口
uint16_t sampleCount = 0;
// 更新动态阈值(每收集满SAMPLE_SIZE_FOR_THRESHOLD个样本调用一次)
void Update_Dynamic_Threshold(AxisData_t newFilteredSample) {
static uint16_t index = 0;
AxisData_t currentMax, currentMin;
// 1. 将新样本存入窗口
sampleWindow[index] = newFilteredSample;
index = (index + 1) % SAMPLE_SIZE_FOR_THRESHOLD;
// 2. 如果窗口未满,直接返回,不更新阈值
sampleCount++;
if (sampleCount < SAMPLE_SIZE_FOR_THRESHOLD) {
return;
}
// 3. 窗口已满,寻找过去50个样本中的最大值和最小值
currentMax.x = sampleWindow[0].x;
currentMax.y = sampleWindow[0].y;
currentMax.z = sampleWindow[0].z;
currentMin = currentMax; // 初始化最小值
for (int i = 1; i < SAMPLE_SIZE_FOR_THRESHOLD; i++) {
// 更新最大值
if (sampleWindow[i].x > currentMax.x) currentMax.x = sampleWindow[i].x;
if (sampleWindow[i].y > currentMax.y) currentMax.y = sampleWindow[i].y;
if (sampleWindow[i].z > currentMax.z) currentMax.z = sampleWindow[i].z;
// 更新最小值
if (sampleWindow[i].x < currentMin.x) currentMin.x = sampleWindow[i].x;
if (sampleWindow[i].y < currentMin.y) currentMin.y = sampleWindow[i].y;
if (sampleWindow[i].z < currentMin.z) currentMin.z = sampleWindow[i].z;
}
// 4. 更新全局阈值结构体
threshold.max = currentMax;
threshold.min = currentMin;
// 动态阈值 = (max + min) / 2,这个计算在步伐判断时实时进行
}
这个函数会在主循环中,每获得一个新的滤波样本就被调用一次。当收集满50个样本后,它就会更新一次最大值和最小值。注意,我们并没有在这里直接计算阈值 (max+min)/2,而是保存了最大最小值。因为在步伐判断时,我们需要用上一次更新的阈值来判断当前的样本,以避免使用正在计算中的、不稳定的阈值。这就是为什么结构体里叫old_max和old_min(在代码中我简化了,实际应用时最好区分新旧)。
4.3 线性移位寄存器:捕捉有效的波峰波谷
有了动态阈值,我们还需要一个机制来准确判断加速度波形何时“穿过”这个阈值。直接拿当前采样值和阈值比较会产生大量误触发,因为噪声可能使信号在阈值附近来回抖动多次。
线性移位寄存器(或称为双样本寄存器) 就是为了解决这个问题。它只保存两个关键的样本:new_sample(较新的样本)和old_sample(较旧的样本)。它的更新规则很巧妙:
- 无论何时,
old_sample总是被赋值为上一次的new_sample。 - 新的滤波样本
cur_sample是否能成为新的new_sample,取决于它和当前new_sample的差值是否超过一个预设的动态精度(DYNAMIC_PRECISION)。- 如果
|cur_sample - new_sample| > DYNAMIC_PRECISION,说明发生了显著变化,则更新:new_sample = cur_sample。 - 否则,
new_sample保持不变。
- 如果
这个“动态精度”就像一个死区,滤除了微小的、无意义的波动。只有变化足够大的样本才会被记录,这样new_sample和old_sample就分别代表了最近两个“显著变化点”的加速度值。步伐通常对应着一个先上升后下降的波形,我们用这两个点来判断是否形成了一个完整的波峰。
#define DYNAMIC_PRECISION 30 // 动态精度,需要根据实测调整
typedef struct {
AxisData_t new_sample;
AxisData_t old_sample;
} ShiftRegister_t;
ShiftRegister_t sReg; // 线性移位寄存器
// 更新线性移位寄存器
void Update_Shift_Register(AxisData_t cur_filtered_sample) {
// 无条件将旧的new_sample移入old_sample
sReg.old_sample = sReg.new_sample;
// 判断X轴变化是否显著,决定是否更新new_sample
if (abs(cur_filtered_sample.x - sReg.new_sample.x) > DYNAMIC_PRECISION) {
sReg.new_sample.x = cur_filtered_sample.x;
} // 否则new_sample.x保持不变
// Y轴同理
if (abs(cur_filtered_sample.y - sReg.new_sample.y) > DYNAMIC_PRECISION) {
sReg.new_sample.y = cur_filtered_sample.y;
}
// Z轴同理
if (abs(cur_filtered_sample.z - sReg.new_sample.z) > DYNAMIC_PRECISION) {
sReg.new_sample.z = cur_filtered_sample.z;
}
}
DYNAMIC_PRECISION 这个值需要根据你的实际数据调整。太小了,噪声会导致寄存器频繁更新,失去滤波意义;太大了,可能会漏掉小幅度的步伐。我一般从20到50之间开始尝试。你可以通过串口打印出滤波后的数据,观察步行时单个轴的变化幅度,取这个幅度的1/5到1/3作为初始值。
5. 步伐判断逻辑与系统整合
5.1 找到“最活跃轴”与最终判决
人体运动时,加速度会在三个轴上都有投影,但总有一个轴的变化是最明显的。例如,把计步器竖着放在裤袋里,上下运动的加速度主要反映在Z轴上;横着放在口袋里,前后摆动的加速度可能主要反映在X或Y轴上。我们的算法需要自适应地找到这个“最活跃轴”,然后只根据这个轴的数据来判断步伐。
如何定义“最活跃”?我们使用过去50个样本中,该轴加速度的**变化范围(最大值减最小值)**来衡量。变化范围最大,且超过一个最小活跃阈值(ACTIVE_PRECISION,比如40)的轴,就被判定为最活跃轴。
#define ACTIVE_PRECISION 40 // 最小活跃度阈值
// 判断当前最活跃的轴
char Find_Most_Active_Axis(DynamicThreshold_t *th) {
short x_range = abs(th->max.x - th->min.x);
short y_range = abs(th->max.y - th->min.y);
short z_range = abs(th->max.z - th->min.z);
char activeAxis = 0; // 0表示无活跃轴
if (x_range >= ACTIVE_PRECISION && x_range >= y_range && x_range >= z_range) {
activeAxis = 'X';
} else if (y_range >= ACTIVE_PRECISION && y_range >= x_range && y_range >= z_range) {
activeAxis = 'Y';
} else if (z_range >= ACTIVE_PRECISION && z_range >= x_range && z_range >= y_range) {
activeAxis = 'Z';
}
return activeAxis; // 返回 'X', 'Y', 'Z' 或 0
}
找到最活跃轴后,步伐判决的最终条件就清晰了:
- 计算该轴的动态阈值:
threshold = (old_max + old_min) / 2。 - 检查线性移位寄存器中该轴的数据:如果
old_sample > threshold且new_sample < threshold,则认为发生了一次“从阈值以上穿越到阈值以下”的过程,这正好对应了步伐中加速度达到波峰后开始下降的瞬间,计为一步。
这个“峰谷检测”逻辑非常符合步行时加速度的物理特征。以下是完整的步伐检测函数:
// 主步伐检测函数,返回当前总步数
uint32_t Detect_Step(DynamicThreshold_t *th, ShiftRegister_t *sr, AxisData_t cur_sample) {
static uint32_t stepCount = 0; // 静态变量,保存步数
char activeAxis;
short currentThreshold;
// 1. 更新动态阈值(内部会判断是否满50个样本)
Update_Dynamic_Threshold(cur_sample);
// 2. 更新线性移位寄存器
Update_Shift_Register(cur_sample);
// 3. 寻找最活跃轴
activeAxis = Find_Most_Active_Axis(th);
// 4. 根据最活跃轴进行判决
switch (activeAxis) {
case 'X':
currentThreshold = (th->max.x + th->min.x) / 2;
if (sr->old_sample.x > currentThreshold && sr->new_sample.x < currentThreshold) {
stepCount++;
}
break;
case 'Y':
currentThreshold = (th->max.y + th->min.y) / 2;
if (sr->old_sample.y > currentThreshold && sr->new_sample.y < currentThreshold) {
stepCount++;
}
break;
case 'Z':
currentThreshold = (th->max.z + th->min.z) / 2;
if (sr->old_sample.z > currentThreshold && sr->new_sample.z < currentThreshold) {
stepCount++;
}
break;
default:
// 没有活跃轴,不计数
break;
}
return stepCount;
}
5.2 主循环与系统调试
最后,我们把所有模块整合到主函数里,形成一个完整的系统流程。主循环的任务很简单:以一定时间间隔(例如80ms,对应12.5Hz)读取传感器数据 -> 滤波 -> 调用Detect_Step函数 -> 更新显示。
#include "stm32f10x.h"
#include "oled.h" // 假设你有一个OLED显示驱动
#include "adxl345.h"
#include "filter.h"
#include "step_algo.h"
int main(void) {
// 硬件初始化
SystemInit();
delay_init();
OLED_Init();
ADXL345_Init();
// 算法数据结构初始化
DynamicThreshold_t dynThresh = {0};
ShiftRegister_t shiftReg = {0};
AxisData_t rawData, filteredData;
uint32_t steps = 0;
OLED_ShowString(1, 1, "Step Counter");
OLED_ShowString(2, 1, "Steps:");
delay_ms(1000); // 等待系统稳定
while (1) {
// 1. 读取原始数据
ADXL345_ReadXYZ(&rawData.x, &rawData.y, &rawData.z);
// 2. 均值滤波
filteredData = Moving_Average_Filter(rawData);
// 3. 核心步伐检测算法
steps = Detect_Step(&dynThresh, &shiftReg, filteredData);
// 4. 显示步数
OLED_ShowNum(2, 7, steps, 5); // 在OLED第2行第7列显示步数
// 5. 控制采样率,延时约80ms (1000ms/12.5Hz = 80ms)
delay_ms(80);
}
}
调试是整个项目的重中之重。不要指望代码一次就能完美运行。你需要借助串口打印这个强大的工具。把关键数据,比如滤波后的某个轴数据、动态阈值、移位寄存器里的old_sample和new_sample、以及识别出的步数,实时打印到电脑串口助手上。然后拿着开发板走几步,观察数据变化。你会看到加速度波形如何起伏,阈值如何自适应调整,以及步伐触发时old_sample和new_sample是如何跨越阈值的。通过调整FILTER_WINDOW_SIZE、DYNAMIC_PRECISION、ACTIVE_PRECISION这些参数,观察计步准确率的变化,这个过程本身就是对算法理解最深化的时刻。
我自己的调试经验是,先把传感器静止放置,确保读数稳定,动态阈值变化很小。然后用手匀速地上下晃动模拟步伐,看算法能否稳定计数。最后才是实际佩戴行走测试。可能会遇到快速晃动误计数的问题,这可以通过引入“时间窗口”限制(比如两步之间至少间隔300ms)来改善。也可能遇到慢走漏计,可以尝试稍微降低ACTIVE_PRECISION和DYNAMIC_PRECISION。多调几次,你就能得到一个在大多数场景下都表现可靠的计步器了。
304



被折叠的 条评论
为什么被折叠?



