电子产品世界 » 论坛首页 » DIY与开源设计 » 电子DIY » 【let'sdo2026年第3期】过程贴-获取并整理电机运行状态(停止与启动)加

共1条 1/1 1 跳转至页

【let'sdo2026年第3期】过程贴-获取并整理电机运行状态(停止与启动)加速度数据,满足NanoEdgeAIStudio工具获取数据要求

工程师
2026-11-17 21:09:22     打赏

本次步进电机驱动使用了单片机的gpio控制步进电机,采取四相八拍模式

具体对应关系为

PB0  --> IN1

PC0  --> IN2

PC2  --> IN3

PC3 --> IN4

具体的gpio配置

motor-gpio.PNG

四个引脚的配置基本一样,就不一一详细展开了

步进电机具体控制逻辑为

板载按键依次切换电机的停止、慢速和快速状态:停止时释放电机线圈;慢速模式下步进间隔为 10 ms,

快速模式为 5 ms。采集数据可按三种状态分别标记为 STOP、SLOW 和 FAST。如果 NanoEdge AI Studio

 项目只训练“停止/运行”两类,则可将慢速、快速数据都归入 RUN;若希望模型识别速度档位,

则应保留三个独立类别。

为保证数据可比,传感器应牢固安装在电机或固定支架上,并保持位置、朝向、紧固方式、

电机负载及供电电压一致。开始采集后,先让电机运行至稳定状态,再保存用于训练的片段;

按键切换速度后的短暂过渡阶段应单独标记或排除,以免把加速过程误当成稳定的慢速或快速数据。

建议每个状态进行多轮独立采集,并记录实验轮次、速度档位、负载和安装条件。采集停止状态时,也应明确电机是否断电或仅释放线圈,因为两种情况的振动背景可能不同。


项目同时添加了freertos操作系统

分为传感器数据采集线程、串口信息发送线程、步进电机控制线程

freertos-task.PNG

当前应用创建了三个 FreeRTOS 任务,职责如下:


传感器任务 functionSensorTask(优先级 2):

初始化 LIS3DH,配置高分辨率、1.344 kHz 输出和 FIFO;

持续读取 FIFO 中的三轴数据并换算为 mg。每采满 256 组三轴样本,就将缓冲区交给 UART 任务。

I²C 出错时会重新初始化传感器。

static void functionSensorTask(void *pvParameters)
{
  hal_i2c_handle_t *i2c = mx_i2c1_i2c_gethandle();
  hal_uart_handle_t *uart = mx_usart2_uart_gethandle();
  uint8_t sample_ready;
  uint8_t batch_index = 0U;
  uint8_t buffer_owned = 0U;
  uint32_t samples_in_batch = 0U;

  (void)pvParameters;
  g_lis3dh_status = lis3dh_init(i2c, uart);

  for (;;)
  {
    if (g_lis3dh_ready == 0U)
    {
      if (buffer_owned != 0U)
      {
        if (xQueueSend(g_lis3dh_free_buffers, &batch_index,
                       portMAX_DELAY) != pdTRUE)
        {
          g_lis3dh_status = HAL_ERROR;
        }
        buffer_owned = 0U;
        samples_in_batch = 0U;
      }

      vTaskDelay(pdMS_TO_TICKS(1000U));
      g_lis3dh_status = lis3dh_init(i2c, uart);
      continue;
    }

    g_lis3dh_status = lis3dh_read_sample(i2c, g_lis3dh_i2c_address,
                                         &sample_ready);
    if (g_lis3dh_status != HAL_OK)
    {
      g_lis3dh_ready = 0U;
      continue;
    }

    if (sample_ready != 0U)
    {
      if (buffer_owned == 0U)
      {
        if (xQueueReceive(g_lis3dh_free_buffers, &batch_index,
                          portMAX_DELAY) != pdTRUE)
        {
          g_lis3dh_status = HAL_ERROR;
          g_lis3dh_ready = 0U;
          continue;
        }
        buffer_owned = 1U;
      }

      if (buffer_owned != 0U)
      {
        g_lis3dh_sample_batch[batch_index][samples_in_batch].x_mg =
            g_lis3dh_sample.x_mg;
        g_lis3dh_sample_batch[batch_index][samples_in_batch].y_mg =
            g_lis3dh_sample.y_mg;
        g_lis3dh_sample_batch[batch_index][samples_in_batch].z_mg =
            g_lis3dh_sample.z_mg;
        samples_in_batch++;

        if (samples_in_batch == LIS3DH_SAMPLES_PER_LINE)
        {
          if (xQueueSend(g_lis3dh_ready_buffers, &batch_index,
                         portMAX_DELAY) == pdTRUE)
          {
            buffer_owned = 0U;
            samples_in_batch = 0U;
          }
          else
          {
            g_lis3dh_status = HAL_ERROR;
            g_lis3dh_ready = 0U;
          }
        }
      }
    }

    if (sample_ready == 0U)
    {
      vTaskDelay(1U);
    }
  }
}

串口任务 functionUartTask(优先级 1):

等待传感器任务提交的批次,将其中 256 组三轴数据格式化后通过 USART2 发送;

发送完成后归还缓冲区,供传感器任务继续采集。

static void functionUartTask(void *pvParameters)
{
  hal_uart_handle_t *uart = mx_usart2_uart_gethandle();
  uint8_t batch_index;

  (void)pvParameters;
  for (;;)
  {
    if (xQueueReceive(g_lis3dh_ready_buffers, &batch_index,
                      portMAX_DELAY) == pdTRUE)
    {
      g_lis3dh_uart_status = lis3dh_uart_print_sample_batch(
          uart, g_lis3dh_sample_batch[batch_index]);
      if (xQueueSend(g_lis3dh_free_buffers, &batch_index,
                     portMAX_DELAY) != pdTRUE)
      {
        g_lis3dh_uart_status = HAL_ERROR;
      }
    }
  }
}

电机任务 functionMotorTask(优先级 1):

轮询并消抖 PC13 按键,按停止、慢速、快速的顺序切换电机状态;

运行时按四相八拍序列驱动 GPIO。停止时释放线圈、LED 常亮;

慢速时电机步进间隔为 10 ms,LED 每 1 秒切换一次;

快速时步进间隔为 5 ms,LED 每 250 ms 切换一次(完整亮灭周期 500 ms)。

static void functionMotorTask(void *pvParameters)
{
  TickType_t now = xTaskGetTickCount();
  TickType_t button_candidate_since = now;
  TickType_t last_step_tick = now;
  TickType_t last_led_toggle = now;
  const TickType_t debounce_ticks =
      pdMS_TO_TICKS(STEPPER_BUTTON_DEBOUNCE_MS);
  hal_gpio_pin_state_t button_candidate =
      HAL_GPIO_ReadPin(BUTTON_PORT, BUTTON_PIN);
  hal_gpio_pin_state_t button_stable = button_candidate;
  stepper_mode_t mode = STEPPER_MODE_STOPPED;
  uint8_t led_on = 1U;
  uint8_t pattern_index = 0U;

  (void)pvParameters;
  stepper_release();
  HAL_GPIO_WritePin(LED_PORT, LED_PIN, LED_ACTIVE_STATE);

  for (;;)
  {
    hal_gpio_pin_state_t button_state =
        HAL_GPIO_ReadPin(BUTTON_PORT, BUTTON_PIN);

    now = xTaskGetTickCount();
    if (button_state != button_candidate)
    {
      button_candidate = button_state;
      button_candidate_since = now;
    }
    else if ((button_candidate != button_stable) &&
             ((now - button_candidate_since) >= debounce_ticks))
    {
      button_stable = button_candidate;
      if (button_stable == HAL_GPIO_PIN_SET)
      {
        stepper_mode_t previous_mode = mode;

        if (mode == STEPPER_MODE_STOPPED)
        {
          mode = STEPPER_MODE_SLOW;
        }
        else if (mode == STEPPER_MODE_SLOW)
        {
          mode = STEPPER_MODE_FAST;
        }
        else
        {
          mode = STEPPER_MODE_STOPPED;
        }

        if (mode == STEPPER_MODE_STOPPED)
        {
          stepper_release();
          pattern_index = 0U;
          led_on = 1U;
          HAL_GPIO_WritePin(LED_PORT, LED_PIN, LED_ACTIVE_STATE);
        }
        else
        {
          if (previous_mode == STEPPER_MODE_STOPPED)
          {
            pattern_index = 0U;
            stepper_set_pattern(pattern_index);
            pattern_index = (uint8_t)((pattern_index + 1U) % 8U);
          }
          led_on = 1U;
          HAL_GPIO_WritePin(LED_PORT, LED_PIN, LED_ACTIVE_STATE);
          last_led_toggle = now;
        }

        last_step_tick = now;
      }
    }

    if (mode != STEPPER_MODE_STOPPED)
    {
      TickType_t step_interval =
          pdMS_TO_TICKS((mode == STEPPER_MODE_SLOW) ?
                            STEPPER_SLOW_STEP_INTERVAL_MS :
                            STEPPER_FAST_STEP_INTERVAL_MS);
      TickType_t led_phase_interval =
          pdMS_TO_TICKS((mode == STEPPER_MODE_SLOW) ?
                            LED_SLOW_PHASE_INTERVAL_MS :
                            LED_FAST_PHASE_INTERVAL_MS);

      if ((now - last_step_tick) >= step_interval)
      {
        stepper_set_pattern(pattern_index);
        pattern_index = (uint8_t)((pattern_index + 1U) % 8U);
        last_step_tick = now;
      }

      if ((now - last_led_toggle) >= led_phase_interval)
      {
        led_on = (led_on == 0U) ? 1U : 0U;
        HAL_GPIO_WritePin(LED_PORT, LED_PIN,
                          (led_on != 0U) ? LED_ACTIVE_STATE :
                                           LED_INACTIVE_STATE);
        last_led_toggle = now;
      }
    }

    vTaskDelay(1U);
  }
}

其中传感器任务负责采集,UART 任务负责发送,两者通过双缓冲和队列交接数据,

避免串口发送阻塞采样。

上述单个任务基本都是ai辅助生成的,生成之后烧录进开发板即可通过串口工具观察数据输出

sscon-log.PNG

可以观察到串口正常输出加速度数据,每256组数据输出一次。

接下来就可以使用ai工具从串口采集数据了

data-record.PNG








共1条 1/1 1 跳转至页

回复

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