电子产品世界 » 论坛首页 » DIY与开源设计 » 电子DIY » 【let'sdo2026年第3期】过程贴-电机驱动以及数据采集

共1条 1/1 1 跳转至页

【let'sdo2026年第3期】过程贴-电机驱动以及数据采集

高工
2026-11-15 09:52:35     打赏

上期我把 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)


        这么设计的理由很实在:训练数据和推理数据必须来自同一个源。如果训练时是一套路径、部署时是另一套路径,早晚会出现"训练用浮点、推理喂整数"这种对不上的问题。环形缓冲从第一天就是单一数据源,模型接进来的时候不用改采集逻辑。

硬件这边:

器件型号接口引脚
主控NUCLEO-H533RE——
加速度计LIS3DHTRI2C1PB6=SCL、PB7=SDA
步进电机CX28BYJ-48ULN2003 四相PC7/PC6/PC9/PA7
串口ST-LINK VCPUSART2PA2=TX、PA3=RX

        这几个引脚有个共同点:全在 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 超时是毫秒级的,中断里卡一下就够把系统心跳搞乱了。

六、电机控制效果串口反馈

ac5d9d78-ae2b-499b-854e-522185bf2257.png

七、AI原始数据采集应用

我们选择分类模型:

0d523a34-9c21-472d-b1c0-59f07d77cb30.png

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

da3e012f-f0e2-4fa8-8d88-a05a979dd04e.png


注意信号采集的规则:

c2fd69b7-f51f-4bc6-8ab6-d32ef2876cb7.png

stop状态下的数据采集:

5936c1d1-8a4e-4e49-a14e-20f969abd05d.png

run状态下的数据采集:

49e3f599-a9a2-4d9a-a61e-f3bb1de8083e.png

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

926a5c69-464d-42db-935c-694ae63294d6.png

接下来就等吧:

393e248b-5a5d-4401-8b2b-d1e02eb8b342.png

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





关键词: 电机     驱动     数据采集    

共1条 1/1 1 跳转至页

回复

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