上期我把 LIS3DHTR 驱动跑通了,串口能刷出加速度读数。但那只是个"能看"的demo,离真正能用还差三件事:
电机没接上 —— 要能远程控制它转起来、停下来;
采样是断的 —— 每 200 ms 读一次,中间 99% 的数据全丢了;
格式不对 —— NanoEdge AI Studio 要的是特定格式的数据集,不是给人看的日志。
这期把这三件事一次做完。
一、先看整体怎么串的
核心思路一句话:所有模块都往同一个环形缓冲里塞原始样本,串口和未来的模型推理各取各的。
LIS3DHTR FIFO (32 样本, 400 Hz) │ │ 一次 I2C 事务, 最多 32 个样本 ▼ ┌─────────────────┐ │ 环形缓冲 │ ← 原始 12 位计数, 800 样本 = 2 个窗口 │ (acq.c) │ └──┬───────────┬──┘ │ │ │ 攒够 400 │ Acq_GetWindow() │ 个样本 │ (给未来的边缘模型) ▼ ▼ 格式化缓冲 边缘模型推理 "X Y Z ..." │ │ HAL_UART_Transmit_IT (中断发送, 不阻塞) ▼ VCP → PC (一行一个 signal)
这么设计的理由很实在:训练数据和推理数据必须来自同一个源。如果训练时是一套路径、部署时是另一套路径,早晚会出现"训练用浮点、推理喂整数"这种对不上的问题。环形缓冲从第一天就是单一数据源,模型接进来的时候不用改采集逻辑。
硬件这边:
这几个引脚有个共同点:全在 Arduino 排针上。查 UM3121 的 I/O 分配表,PB6/PB7 就是 ARD_D15/ARD_D14,PC6/PC7/PC9/PA7 对应 ARD_D9/D8/D10/D11。传感器和电机模块都是插排针就能用,不用画板子。
二、电机:先纠正一个差点让我踩坑的极性问题
我们参考了电机的例程,我本来想直接搬过来。打开代码一看相序表:
* 8-step half-step sequence, LOW-active. */
static const uint8_t halfstep_seq[8][4] = {
{0, 1, 1, 1}, /* step 0: A */
...
};
static void coils_off(void)
{
HAL_GPIO_WritePin(IN1_GPIO_Port, IN1_Pin, GPIO_PIN_SET); // 高
...
}注释里明明白白写着 LOW-active、coils_off 把脚拉高。但这是错的。
标准 ULN2003 的逻辑是:输入高电平 → 达林顿管饱和 → 线圈导通。也就是 HIGH = 通电,LOW = 断电。照抄这段代码的后果是:停机时 coils_off() 把四根线全拉高,四组线圈全部通电,电机不转但一直在发热,握着都烫。
所以我重写了这一段:
/* 8-phase half-step sequence.
* 1 = coil energised (pin HIGH), 0 = coil off (pin LOW).
* The classic 4-phase wave drive is:
* A -> B -> C -> D -> A
* expanded to half steps by energising one coil, then two (A+B), ...
*/
static const uint8_t halfstep_seq[STEP_PHASE_COUNT][4] =
{
{1, 0, 0, 0}, /* phase 0: A */
{1, 1, 0, 0}, /* phase 1: A + B */
{0, 1, 0, 0}, /* phase 2: B */
{0, 1, 1, 0}, /* phase 3: B + C */
{0, 0, 1, 0}, /* phase 4: C */
{0, 0, 1, 1}, /* phase 5: C + D */
{1, 0, 0, 1}, /* phase 6: D */
{1, 0, 1, 1} /* phase 7: D + A */
};
static void coils_off(void)
{
HAL_GPIO_WritePin(MOTOR_IN1_GPIO_Port, MOTOR_IN1_Pin, GPIO_PIN_RESET);
HAL_GPIO_WritePin(MOTOR_IN2_GPIO_Port, MOTOR_IN2_Pin, GPIO_PIN_RESET);
HAL_GPIO_WritePin(MOTOR_IN3_GPIO_Port, MOTOR_IN3_Pin, GPIO_PIN_RESET);
HAL_GPIO_WritePin(MOTOR_IN4_GPIO_Port, MOTOR_IN4_Pin, GPIO_PIN_RESET);
}顺带在 gpio.c 里确认了四个引脚的初始电平就是 RESET(低)——上电瞬间线圈断电,不会有"上电猛抽一下"这种事。
转速为什么只能到 5 rpm
先算清楚,免得以为程序没跑。
CX28BYJ-48 里面是 28BYJ-48,48 步/圈,配 1/64 减速箱。半步模式下 96 个半步转一圈电机轴。
轴转速 = 步进频率 / 96 / 64 × 60 = 500 / 96 / 64 × 60 ≈ 4.9 rpm
就这么慢,是减速箱的物理特性,不是代码问题。 想快一点把 STEP_RATE_MS 从 2 改成 1(1 kHz),约 9.8 rpm,ULN2003 驱动这个负载完全没问题。
实际用下来 4.9 rpm 反而合适——慢到能肉眼跟住,又稳到不会丢步。
电机状态机:非阻塞的写法
电机不能写成阻塞式的 HAL_Delay(2) 死等——那样串口采集就全乱了。改成状态机,Tick() 里用时间戳判断该不该走一步:
void StepMotor_Tick(void)
{
uint32_t now;
if (motor_state != MOTOR_STATE_RUN)
{
return;
}
now = HAL_GetTick();
if ((uint32_t)(now - last_step_tick) >= (uint32_t)step_interval)
{
last_step_tick = now;
phase_index = (uint8_t)((phase_index + 1U) % STEP_PHASE_COUNT);
apply_phase(phase_index);
step_count++;
}
}主循环每次进来调一次 StepMotor_Tick() 就行。Start() / Stop() 只改 volatile 状态变量,所以从串口中断里直接调也安全。
这里用 (uint32_t)(now - last_step_tick) 而不是 now - last_step_tick >= interval 直接比较,是为了处理 tick 计数器回绕。HAL_GetTick 是 32 位,约 49.5 天回绕一次,无符号减法在回绕点仍然正确,直接比较则会漏掉一次。
三、串口命令:两字符状态机
需求很简单:串口发 01 停电机,发 02 转电机。
我用的是 ASCII 字符(串口助手直接手打就行,不用切 HEX 模式)。解析器是个两状态的小状态机:
cmd_id_t CmdParser_Push(uint8_t byte)
{
switch (cmd_state)
{
case 0U:
/* Only '0' starts a valid command. */
if (byte == (uint8_t)'0')
{
cmd_first = byte;
cmd_state = 1U;
}
else
{
cmd_state = 0U;
}
return CMD_NONE;
case 1U:
default:
{
cmd_id_t id = CMD_NONE;
if ((cmd_first == (uint8_t)'0') && (byte == (uint8_t)'1'))
{
id = CMD_STOP;
}
else if ((cmd_first == (uint8_t)'0') && (byte == (uint8_t)'2'))
{
id = CMD_RUN;
}
else
{
id = CMD_ERROR;
}
cmd_state = 0U;
cmd_first = 0U;
return id;
}
}
}关键点是任何不符合预期的字节都会把状态机复位。这样乱码、粘包、半截命令都不会让解析器卡死。
接收走 USART2 的 RXNE 中断,一次收一个字节:
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
if (huart->Instance == COM1_UART)
{
cmd_id_t cmd = CmdParser_Push(com_rx_byte);
if (cmd != CMD_NONE)
{
com_pending_cmd = cmd; /* 只置标志, 主循环里执行 */
}
/* Restart the reception for the next byte. */
(void)HAL_UART_Receive_IT(huart, &com_rx_byte, 1U);
}
}中断里不直接执行命令,只置一个标志位,真正的动作(启停电机)留到主循环。电机启停要改 GPIO 状态、还要串口回一条确认消息,在中断里做这些容易和主循环抢 UART。
有个坑:BSP_COM_Init() 只初始化了 UART 外设和 GPIO,不会打开 NVIC 中断。得自己加:
HAL_NVIC_SetPriority(USART2_IRQn, 5U, 0U); HAL_NVIC_EnableIRQ(USART2_IRQn);
不写这两行,串口一个字节都收不到,而且现象很迷惑——HAL_UART_Receive_IT 返回 HAL_OK(因为它只检查 UART 状态,不检查 NVIC),看起来一切正常,就是没反应。
四、采样改造:从"看一眼"到"连续采"
FIFO 模式:为什么必须开
上期的代码用的是 Bypass 模式——每次读寄存器拿最新一个值,400 Hz 的采样率下每 200 ms 读一次,等于扔掉 99.5% 的数据。
改成 FIFO Stream 模式之后,传感器自己把样本存进 32 深度 的 FIFO,主循环定期去抽。lis3dhtr.c 里提供了三个接口:
接口作用LIS3_StartFifoStream(dev, watermark)切到 Stream 模式并清空残留LIS3_FIFO_GetSamples(dev, &count)读 FIFO 里的样本数LIS3_FIFO_ReadSamples(dev, out, count)一次性取出 count 个样本
突发读:从 N 次事务降到 1 次
原来的 LIS3_FIFO_ReadSamples 是每个样本发一次 6 字节的 I2C 事务。抽满 FIFO 要 32 次事务。
改成一整批:
lis3_status_t LIS3_FIFO_ReadSamples(lis3_t *dev, int16_t *out, uint16_t count)
{
uint8_t raw[LIS3_FIFO_BURST_MAX_SAMPLES * 6U];
uint16_t i;
if (count == 0U) { return LIS3_OK; }
if (out == NULL) { return LIS3_ERR_PARAM; }
if (count > LIS3_FIFO_BURST_MAX_SAMPLES) { return LIS3_ERR_PARAM; }
/* Single I2C transaction for the whole batch.
*
* The LIS3DHTR pops one FIFO entry every time 6 bytes are read from
* OUT_X_L. Because the SUB byte carries the IF_ADD_INC bit (set by
* LIS3_ReadReg whenever len > 1), a burst of count * 6 bytes walks
* through OUT_X_L, OUT_X_H, OUT_Y_L, ... and pops `count` consecutive
* samples from the FIFO.
*/
lis3_status_t st = LIS3_ReadReg(dev, LIS3_REG_OUT_X_L, raw, (uint16_t)(count * 6U));
if (st != LIS3_OK) { return st; }
for (i = 0U; i < count; ++i)
{
const uint8_t *p = &raw[i * 6U];
int16_t xl = (int16_t)(((uint16_t)p[1] << 8) | p[0]);
int16_t yl = (int16_t)(((uint16_t)p[3] << 8) | p[2]);
int16_t zl = (int16_t)(((uint16_t)p[5] << 8) | p[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;
}原理是:每从 OUT_X_L 读满 6 字节,FIFO 就弹出一个样本。地址自增位(SUB 的 bit7)让器件内部自动走完
OUT_X_L→OUT_X_H→OUT_Y_L→…→OUT_Z_H。
抽满 32 个样本从 32 次事务变成 1 次,I2C 流量降到 1/32。
坑一:FSS 只有 5 位,满的时候读回来是 31 不是 32。
FIFO_SRC_REG 的布局是 WTM(7) OVRN(6) EMPTY(5) FSS[4:0]。FSS 是 5 位,根本表示不出 32。FIFO 满的时候器件把 FSS 停在 31,同时把 OVRN 置 1。
原来我直接取 src & 0x1F,结果每次 FIFO 满都少一个样本——而且是静悄悄地少,数据看起来连续,就是数不对。
修法是看 OVRN 位:
uint16_t n = (uint16_t)(src & 0x1FU);
if ((src & 0x40U) != 0U)
{
n = LIS3_FIFO_DEPTH_SAMPLES; /* OVRN set -> the FIFO is full */
}
*count = n;五、NanoEdge AI Studio 数据格式适配
NanoEdge 要什么
查了 NanoEdge AI Studio 的信号文件规格,核心就三条:
1.每个 signal = 固定窗口长度 × 3 轴的整数
2.窗口内字段顺序固定:X₀ Y₀ Z₀ X₁ Y₁ Z₁ ...
3.字段用空格分隔,int 或 float 都行
窗口长度("Number of samples per signal")和窗口时长("AI 串口时间")是绑定的:ODR 400 Hz,窗口 1 s → 400 样本。
三个宏定死一切
#define ACQ_ODR_HZ 400U #define ACQ_SIGNAL_MS 1000U #define ACQ_WINDOW_SAMPLES ((ACQ_ODR_HZ * ACQ_SIGNAL_MS) / 1000U)
改 ACQ_SIGNAL_MS 成 500U,窗口自动变成 200 样本。NanoEdge 工程里的 "Number of samples per signal" 必须同步改,否则训练时窗口 400、部署时喂 200,模型会直接拒绝输入。
对应的输出参数:
项1 s 窗口0.5 s 窗口每轴样本数400200一行字段数1200600实际字节5913 B2957 B串口耗时 @1152000.513 s0.257 sUART 占用率51.3%51.3%
非阻塞发送:这个必须做对
一行 5913 字节,115200 波特率要发 0.513 s。如果用阻塞式的 HAL_UART_Transmit,这 0.513 s 里主循环完全停摆,FIFO 80 ms 就满,数据大面积丢失。
所以用中断发送:
/* Non blocking transmission: the main loop keeps draining the sensor
* FIFO while the line is on the wire. */
if (HAL_UART_Transmit_IT(&hcom_uart[COM1], (uint8_t *)acq_line,
(uint16_t)pos) == HAL_OK)
{
acq_tx_busy = 1;
COM_SetTxLock(1);
}但这带来一个新问题:BSP 的 fputc 用的是阻塞式 HAL_UART_Transmit,如果在线传输期间调 printf,字符会被插到数据行中间,数据集直接废掉。
加了个发送锁:
volatile int com_tx_locked = 0;
void COM_Write(const char *data, uint16_t len)
{
...
/* A signal line is on the wire: writing now would corrupt the data set
* (and the HAL would refuse the transfer anyway because the handle is
* busy). Drop the message. */
if (com_tx_locked)
{
return;
}
(void)HAL_UART_Transmit(&hcom_uart[COM1], (uint8_t *)data, len, 100U);
}传输完成回调里解锁:
void Acq_OnTxComplete(void)
{
acq_tx_busy = 0;
COM_SetTxLock(0);
}顺带确认了一件事:STM32H5 的 HAL 里,gState(发送)和 RxState(接收)是两套独立的状态机,各自有独立的中断使能位。所以 HAL_UART_Transmit_IT 和 HAL_UART_Receive_IT 可以同时挂在同一个句柄上,电机命令的接收不受数据发送影响。
环形缓冲:训练和推理共用一份数据
static int16_t acq_ring[ACQ_RING_CAPACITY * 3U]; static volatile uint32_t acq_ring_write = 0U; static volatile uint32_t acq_ring_read = 0U; static volatile uint32_t acq_ring_total = 0U;
容量是 2 个窗口(800 样本),这样上一个窗口还在发送时,下一个已经在采。
为将来的边缘模型预留了出口:
int Acq_GetWindow(int16_t *out)
{
uint32_t first;
uint32_t idx;
if (out == NULL) { return 0; }
/* Need at least one complete window in the ring. */
if ((acq_ring_total - acq_formatted) < ACQ_WINDOW_SAMPLES)
{
return 0;
}
/* Take the window that ends with the most recent sample. */
first = acq_ring_total - ACQ_WINDOW_SAMPLES;
idx = first % ACQ_RING_CAPACITY;
for (uint32_t i = 0U; i < ACQ_WINDOW_SAMPLES; ++i)
{
out[i * 3U + 0U] = acq_ring[idx * 3U + 0U];
out[i * 3U + 1U] = acq_ring[idx * 3U + 1U];
out[i * 3U + 2U] = acq_ring[idx * 3U + 2U];
idx++;
if (idx >= ACQ_RING_CAPACITY) { idx = 0U; }
}
return 1;
}取出来的是原始 12 位计数,顺序和写进训练文件的一模一样。 模型接进来的时候,采集逻辑一行都不用改。
按键一次采一组
需求是"按键一次采集一组"。实现是:按 USER 启动一个 run,run 里连续输出 100 个 signal(100 行),正好是 NanoEdge 每个类别建议的最少样本量。
void BSP_PB_Callback(Button_TypeDef Button)
{
if (Button == BUTTON_USER)
{
if (Acq_IsRunning())
{
Acq_Stop();
}
else
{
Acq_Start();
}
}
}按键处理在 EXTI 中断上下文,但里面只置标志位:
/* EXTI-context safe */
void Acq_Start(void)
{
acq_pending = 1U;
}真正启动 FIFO、切模式、清缓冲,都在主循环里做。中断里绝对不做 I2C 操作——I2C 超时是毫秒级的,中断里卡一下就够把系统心跳搞乱了。
六、电机控制效果串口反馈

七、AI原始数据采集应用
我们选择分类模型:

选在对应的开发板和数据源:

注意信号采集的规则:

stop状态下的数据采集:

run状态下的数据采集:

选择这两个数据进行训练:

接下来就等吧:

到这里我们的准备工作实际上就做完了,需要等待训练完成,最后的成果就是是通过部署训练完的模型,然后看看能不能正常识别。
我要赚赏金
