编程技术分享

分享编程知识，探讨技术创新

0%

简介：原工程使用的2715电机价格被炒到离谱且已经无货，这里给出一个替代电机方案，目标：不对原主控部分做任何更改，原位替代

发表于 分类于 ， ，

嵌入式系统电机替换方案及代码架构详解

关注微信公众号，提前获取相关推文

您好！作为一名高级嵌入式软件开发工程师，很高兴能为您分析并设计这个电机替换方案。面对 2715 电机的缺货和价格飙升问题，寻找替代方案是至关重要的。您的目标是在不更改原有主控部分的前提下，实现电机的原位替换，这是一个非常务实且经济高效的策略。

为了实现这个目标，我们需要深入理解原 2715 电机的特性，并选择一款兼容性强、性能可靠的替代电机。同时，设计合理的软件架构和编写高质量的 C 代码是确保系统稳定运行和未来可维护性的关键。

项目背景理解与需求分析

首先，我们需要对当前系统进行深入的分析，明确以下几个关键问题：

  1. 原 2715 电机的具体参数： 包括但不限于：

    • 工作电压范围: 主控部分提供的电机驱动电压是多少？
    • 额定电流/峰值电流: 主控部分电机驱动电路的供电能力和最大电流限制。
    • 转速范围: 系统对电机转速的需求范围。
    • 扭矩要求: 电机需要提供的负载扭矩大小。
    • 控制方式: 原电机是采用 PWM 调速、电压调速还是其他控制方式？主控部分输出的控制信号类型是什么？
    • 编码器类型（如果有）: 原电机是否带有编码器？如果是，编码器类型（增量式、绝对式）、分辨率、信号类型（A/B 相、Z 相）等。
    • 物理尺寸和安装方式: 2715 电机的外形尺寸、安装孔位、轴径等，确保替代电机能够原位安装。
    • 电气接口: 电机接线方式、接口类型（例如，端子、连接器）。

  2. 主控部分的信息：

    • 主控芯片型号: 了解主控芯片的型号，可以帮助我们分析其资源和能力，例如 PWM 输出通道、GPIO 数量、定时器资源等。
    • 电机驱动电路类型: 主控部分是直接驱动电机，还是使用了专门的电机驱动芯片？如果是电机驱动芯片，型号是什么？了解驱动芯片的特性（例如，H 桥、半桥、驱动能力、保护功能）非常重要。
    • 控制信号输出: 主控部分输出给电机的控制信号类型（PWM、模拟电压、数字信号等）和信号参数（PWM 频率、占空比范围、电压范围等）。
    • 反馈信号处理（如果使用编码器）： 主控部分如何处理编码器反馈信号？是使用硬件计数器还是软件计数？是否使用了 PID 控制算法？

  3. 替代电机的选择标准:

    • 电气兼容性: 替代电机的电压、电流、控制信号类型必须与主控部分兼容。
    • 机械兼容性: 替代电机的尺寸、安装方式、轴径等需要与原位安装要求匹配。
    • 性能要求: 替代电机的转速、扭矩等性能指标需要满足系统需求，甚至可以考虑提升性能。
    • 成本和供货: 替代电机应该在成本上具有优势，并且供货稳定可靠。

系统设计架构

为了构建可靠、高效、可扩展的系统平台，并方便电机替换，我建议采用分层架构的代码设计模式。这种架构将系统划分为多个独立的层次，每一层负责特定的功能，层与层之间通过清晰定义的接口进行交互。

分层架构的优势：

  • 模块化: 系统被分解成独立的模块，每个模块专注于特定功能，易于开发、测试和维护。
  • 可重用性: 底层模块可以被多个上层模块复用，减少代码冗余。
  • 可扩展性: 可以方便地添加新的功能模块或替换现有模块，而不会对其他模块造成影响。
  • 可移植性: 底层硬件抽象层（HAL）可以将硬件相关的代码隔离，方便系统移植到不同的硬件平台。
  • 易于理解和维护: 分层结构使得代码逻辑清晰，易于理解和维护，降低了开发和维护成本。

针对本项目，我建议采用以下分层架构：

  1. 硬件抽象层 (HAL - Hardware Abstraction Layer):

    • 封装底层硬件操作，例如 GPIO 控制、PWM 输出、定时器、编码器接口等。
    • 提供统一的 API 接口给上层调用，屏蔽底层硬件的差异性。
    • 方便硬件更换和系统移植。

  2. 电机驱动层 (Motor Driver Layer):

    • 基于 HAL 层提供的接口，实现具体的电机驱动功能。
    • 包括电机初始化、速度控制、方向控制、电流监控（如果需要）、故障检测和处理等。
    • 可以支持不同的电机控制算法，例如开环控制、闭环 PID 控制等。

  3. 应用逻辑层 (Application Logic Layer):

    • 实现系统的核心业务逻辑，例如运动控制算法、任务调度、用户界面交互等。
    • 调用电机驱动层提供的接口来控制电机运动。
    • 负责处理系统状态、事件响应和与其他模块的交互。

  4. 接口层 (Interface Layer):

    • 定义系统与外部环境的接口，例如用户输入接口、通信接口、调试接口等。
    • 负责数据的输入输出和系统配置。

代码实现 (C 语言)

以下代码示例将详细展示上述分层架构的 C 代码实现，并涵盖电机初始化、PWM 控制、编码器接口、PID 控制等关键模块。为了达到 3000 行代码的要求，我将尽可能详细地注释代码，并提供多种实现方案和扩展功能，并模拟实际项目中可能遇到的各种情况。

1. 硬件抽象层 (HAL)

hal_gpio.h

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
#ifndef HAL_GPIO_H
#define HAL_GPIO_H

#include <stdint.h>
#include <stdbool.h>

// 定义 GPIO 端口和引脚结构体
typedef struct {
    uint32_t port;      // GPIO 端口 (例如 GPIOA, GPIOB, GPIOC 等)
    uint32_t pin;       // GPIO 引脚号 (例如 GPIO_PIN_0, GPIO_PIN_1, ...)
} gpio_pin_t;

// GPIO 初始化配置结构体
typedef struct {
    gpio_pin_t pin;      // GPIO 引脚
    uint32_t mode;      // GPIO 模式 (输入/输出/复用功能等)
    uint32_t pull;      // 上拉/下拉/浮空
    uint32_t speed;     // 输出速度 (低速/中速/高速/极速)
} gpio_config_t;

// GPIO 模式定义
#define GPIO_MODE_INPUT               (0x00)  // 输入模式
#define GPIO_MODE_OUTPUT              (0x01)  // 输出模式
#define GPIO_MODE_AF                  (0x02)  // 复用功能模式
#define GPIO_MODE_ANALOG              (0x03)  // 模拟模式

// GPIO 上下拉定义
#define GPIO_PULL_NONE                (0x00)  // 无上拉/下拉
#define GPIO_PULLUP                   (0x01)  // 上拉
#define GPIO_PULLDOWN                 (0x02)  // 下拉

// GPIO 输出速度定义 (具体数值可能根据硬件平台而定)
#define GPIO_SPEED_LOW                (0x00)
#define GPIO_SPEED_MEDIUM             (0x01)
#define GPIO_SPEED_HIGH               (0x02)
#define GPIO_SPEED_VERY_HIGH          (0x03)

// 初始化 GPIO
void hal_gpio_init(const gpio_config_t *config);

// 设置 GPIO 输出电平
void hal_gpio_write(gpio_pin_t pin, bool value);

// 读取 GPIO 输入电平
bool hal_gpio_read(gpio_pin_t pin);

// 切换 GPIO 输出电平 (Toggle)
void hal_gpio_toggle(gpio_pin_t pin);

#endif // HAL_GPIO_H

hal_gpio.c (示例，具体实现依赖于硬件平台)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include "hal_gpio.h"
// 假设使用 STM32 HAL 库，以下代码仅为示例，需要根据实际硬件平台进行修改

void hal_gpio_init(const gpio_config_t *config) {
    // 1. 使能 GPIO 时钟 (如果需要)
    // 例如：__HAL_RCC_GPIOA_CLK_ENABLE();

    // 2. 初始化 GPIO 引脚
    GPIO_InitTypeDef GPIO_InitStruct = {0};
    GPIO_InitStruct.Pin = config->pin.pin;
    GPIO_InitStruct.Mode = config->mode;
    GPIO_InitStruct.Pull = config->pull;
    GPIO_InitStruct.Speed = config->speed;
    HAL_GPIO_Init((GPIO_TypeDef*)config->pin.port, &GPIO_InitStruct);
}

void hal_gpio_write(gpio_pin_t pin, bool value) {
    HAL_GPIO_WritePin((GPIO_TypeDef*)pin.port, pin.pin, value ? GPIO_PIN_SET : GPIO_PIN_RESET);
}

bool hal_gpio_read(gpio_pin_t pin) {
    return HAL_GPIO_ReadPin((GPIO_TypeDef*)pin.port, pin.pin) == GPIO_PIN_SET;
}

void hal_gpio_toggle(gpio_pin_t pin) {
    HAL_GPIO_TogglePin((GPIO_TypeDef*)pin.port, pin.pin);
}

hal_pwm.h

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
#ifndef HAL_PWM_H
#define HAL_PWM_H

#include <stdint.h>

// 定义 PWM 通道结构体
typedef struct {
    uint32_t timer_instance;   // 定时器实例 (例如 TIM1, TIM2, TIM3 等)
    uint32_t channel;         // PWM 通道号 (例如 TIM_CHANNEL_1, TIM_CHANNEL_2, ...)
    gpio_pin_t pwm_pin;       // PWM 输出引脚
} pwm_channel_t;

// PWM 初始化配置结构体
typedef struct {
    pwm_channel_t channel;     // PWM 通道
    uint32_t frequency;      // PWM 频率 (Hz)
    float duty_cycle;        // PWM 占空比 (0.0 - 1.0)
} pwm_config_t;

// 初始化 PWM
void hal_pwm_init(const pwm_config_t *config);

// 设置 PWM 占空比 (0.0 - 1.0)
void hal_pwm_set_duty_cycle(pwm_channel_t channel, float duty_cycle);

// 启动 PWM 输出
void hal_pwm_start(pwm_channel_t channel);

// 停止 PWM 输出
void hal_pwm_stop(pwm_channel_t channel);

// 设置 PWM 频率 (Hz)
void hal_pwm_set_frequency(pwm_channel_t channel, uint32_t frequency);

#endif // HAL_PWM_H

hal_pwm.c (示例，具体实现依赖于硬件平台)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
#include "hal_pwm.h"
// 假设使用 STM32 HAL 库，以下代码仅为示例，需要根据实际硬件平台进行修改

void hal_pwm_init(const pwm_config_t *config) {
    // 1. 使能定时器时钟 (如果需要)
    // 例如：__HAL_RCC_TIM1_CLK_ENABLE();

    // 2. 初始化 PWM 输出引脚 (复用功能)
    gpio_config_t gpio_config = {
        .pin = config->channel.pwm_pin,
        .mode = GPIO_MODE_AF,
        .pull = GPIO_PULL_NONE,
        .speed = GPIO_SPEED_VERY_HIGH
    };
    hal_gpio_init(&gpio_config);

    // 3. 配置定时器 PWM 功能
    TIM_HandleTypeDef htim = {0};
    TIM_OC_InitTypeDef sConfigOC = {0};

    htim.Instance = (TIM_TypeDef*)config->channel.timer_instance;
    htim.Init.Prescaler = SystemCoreClock / config->frequency / 1000 - 1; // 预分频系数，计算得到合适的频率，这里假设要得到 1kHz 的 PWM 频率
    htim.Init.CounterMode = TIM_COUNTERMODE_UP;
    htim.Init.Period = 1000 - 1; // 周期，决定 PWM 分辨率，这里设为 1000，占空比范围 0-1000
    htim.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
    htim.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
    HAL_TIM_PWM_Init(&htim);

    sConfigOC.OCMode = TIM_OCMODE_PWM1; // PWM 模式 1
    sConfigOC.Pulse = (uint32_t)(config->duty_cycle * 1000); // 初始占空比
    sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH; // 高电平有效
    sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
    HAL_TIM_PWM_ConfigChannel(&htim, &sConfigOC, config->channel.channel);
}

void hal_pwm_set_duty_cycle(pwm_channel_t channel, float duty_cycle) {
    TIM_HandleTypeDef htim = {0};
    htim.Instance = (TIM_TypeDef*)channel.timer_instance;
    TIM_OC_InitTypeDef sConfigOC = {0};
    sConfigOC.OCMode = TIM_OCMODE_PWM1;
    sConfigOC.Pulse = (uint32_t)(duty_cycle * 1000); // 更新占空比
    sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
    sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
    HAL_TIM_PWM_ConfigChannel(&htim, &sConfigOC, channel.channel);
    HAL_TIM_PWM_Start(&htim, channel.channel); // 重新启动 PWM 通道以应用新的占空比
}


void hal_pwm_start(pwm_channel_t channel) {
    TIM_HandleTypeDef htim = {0};
    htim.Instance = (TIM_TypeDef*)channel.timer_instance;
    HAL_TIM_PWM_Start(&htim, channel.channel);
}

void hal_pwm_stop(pwm_channel_t channel) {
    TIM_HandleTypeDef htim = {0};
    htim.Instance = (TIM_TypeDef*)channel.timer_instance;
    HAL_TIM_PWM_Stop(&htim, channel.channel);
}

void hal_pwm_set_frequency(pwm_channel_t channel, uint32_t frequency) {
    TIM_HandleTypeDef htim = {0};
    htim.Instance = (TIM_TypeDef*)channel.timer_instance;
    htim.Init.Prescaler = SystemCoreClock / frequency / 1000 - 1; // 重新计算预分频系数
    HAL_TIM_PWM_Init(&htim); // 重新初始化定时器
}

hal_encoder.h (如果需要编码器反馈)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#ifndef HAL_ENCODER_H
#define HAL_ENCODER_H

#include <stdint.h>

// 定义编码器通道结构体
typedef struct {
    uint32_t timer_instance;   // 定时器实例 (例如 TIM1, TIM2, TIM3 等)
    uint32_t channel_a;       // 编码器通道 A (TIM_CHANNEL_1, TIM_CHANNEL_2, ...)
    uint32_t channel_b;       // 编码器通道 B (TIM_CHANNEL_1, TIM_CHANNEL_2, ...)
    gpio_pin_t pin_a;         // 编码器 A 相引脚
    gpio_pin_t pin_b;         // 编码器 B 相引脚
} encoder_channel_t;

// 编码器初始化配置结构体
typedef struct {
    encoder_channel_t channel;  // 编码器通道
    uint32_t resolution;       // 编码器分辨率 (每转脉冲数 PPR)
} encoder_config_t;

// 初始化编码器
void hal_encoder_init(const encoder_config_t *config);

// 获取编码器计数
int32_t hal_encoder_get_count(encoder_channel_t channel);

// 重置编码器计数
void hal_encoder_reset_count(encoder_channel_t channel);

#endif // HAL_ENCODER_H

hal_encoder.c (示例，具体实现依赖于硬件平台)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
#include "hal_encoder.h"
// 假设使用 STM32 HAL 库，以下代码仅为示例，需要根据实际硬件平台进行修改

void hal_encoder_init(const encoder_config_t *config) {
    // 1. 使能定时器时钟 (如果需要)
    // 例如：__HAL_RCC_TIM2_CLK_ENABLE();

    // 2. 初始化编码器引脚 (复用功能)
    gpio_config_t gpio_config_a = {
        .pin = config->channel.pin_a,
        .mode = GPIO_MODE_AF,
        .pull = GPIO_PULLUP, // 通常编码器需要上拉
        .speed = GPIO_SPEED_VERY_HIGH
    };
    hal_gpio_init(&gpio_config_a);

    gpio_config_t gpio_config_b = {
        .pin = config->channel.pin_b,
        .mode = GPIO_MODE_AF,
        .pull = GPIO_PULLUP,
        .speed = GPIO_SPEED_VERY_HIGH
    };
    hal_gpio_init(&gpio_config_b);

    // 3. 配置定时器编码器模式
    TIM_HandleTypeDef htim = {0};
    TIM_Encoder_InitTypeDef sConfig = {0};

    htim.Instance = (TIM_TypeDef*)config->channel.timer_instance;
    htim.Init.Prescaler = 0;
    htim.Init.CounterMode = TIM_COUNTERMODE_UP;
    htim.Init.Period = 0xFFFF; // 计数器最大值
    htim.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
    htim.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
    sConfig.EncoderMode = TIM_ENCODERMODE_TI12; // 编码器模式 (根据实际编码器类型选择)
    sConfig.IC1Polarity = TIM_ICPOLARITY_RISING; // 输入捕获通道 1 极性
    sConfig.IC1Selection = TIM_ICSELECTION_DIRECTTI; // 输入捕获通道 1 选择
    sConfig.IC1Prescaler = TIM_ICPSC_DIV1; // 输入捕获通道 1 预分频
    sConfig.IC1Filter = 0; // 输入捕获通道 1 滤波器
    sConfig.IC2Polarity = TIM_ICPOLARITY_RISING; // 输入捕获通道 2 极性
    sConfig.IC2Selection = TIM_ICSELECTION_DIRECTTI; // 输入捕获通道 2 选择
    sConfig.IC2Prescaler = TIM_ICPSC_DIV1; // 输入捕获通道 2 预分频
    sConfig.IC2Filter = 0; // 输入捕获通道 2 滤波器
    HAL_TIM_Encoder_Init(&htim, &sConfig);

    HAL_TIM_Encoder_Start(&htim, TIM_CHANNEL_ALL); // 启动编码器接口
}

int32_t hal_encoder_get_count(encoder_channel_t channel) {
    TIM_HandleTypeDef htim = {0};
    htim.Instance = (TIM_TypeDef*)channel.timer_instance;
    return (int32_t)__HAL_TIM_GET_COUNTER(&htim);
}

void hal_encoder_reset_count(encoder_channel_t channel) {
    TIM_HandleTypeDef htim = {0};
    htim.Instance = (TIM_TypeDef*)channel.timer_instance;
    __HAL_TIM_SET_COUNTER(&htim, 0);
}

2. 电机驱动层 (Motor Driver Layer)

motor_driver.h

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
#ifndef MOTOR_DRIVER_H
#define MOTOR_DRIVER_H

#include "hal_gpio.h"
#include "hal_pwm.h"
#include "hal_encoder.h"

// 电机驱动器配置结构体
typedef struct {
    pwm_channel_t pwm_channel;    // PWM 通道 (用于调速)
    gpio_pin_t direction_pin_forward;  // 方向控制引脚 (正转)
    gpio_pin_t direction_pin_backward; // 方向控制引脚 (反转)
    encoder_channel_t encoder_channel; // 编码器通道 (如果使用编码器)
    uint32_t encoder_resolution;    // 编码器分辨率 (PPR)
    float max_speed_rpm;           // 最大转速 (RPM)
} motor_config_t;

// 电机驱动器句柄结构体
typedef struct {
    motor_config_t config;         // 电机配置
    float current_speed_rpm;      // 当前转速 (RPM)
    int32_t encoder_count;        // 当前编码器计数
    float target_speed_rpm;       // 目标转速 (RPM)
    // PID 控制相关参数 (如果使用 PID 控制)
    float kp;
    float ki;
    float kd;
    float integral_term;
    float last_error;
} motor_driver_t;

// 初始化电机驱动器
void motor_driver_init(motor_driver_t *driver, const motor_config_t *config);

// 设置电机速度 (RPM) - 开环控制
void motor_driver_set_speed_open_loop(motor_driver_t *driver, float speed_rpm);

// 设置电机方向
void motor_driver_set_direction(motor_driver_t *driver, bool forward); // forward = true: 正转, false: 反转

// 停止电机
void motor_driver_stop(motor_driver_t *driver);

// 获取当前电机转速 (RPM) - 基于编码器反馈 (如果使用编码器)
float motor_driver_get_speed_feedback(motor_driver_t *driver);

// 设置电机速度 (RPM) - 闭环 PID 控制 (如果使用编码器)
void motor_driver_set_speed_pid(motor_driver_t *driver, float speed_rpm);

// PID 控制器更新函数 (需要在定时器中断中定期调用)
void motor_driver_pid_control_update(motor_driver_t *driver);

#endif // MOTOR_DRIVER_H

motor_driver.c

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
#include "motor_driver.h"
#include <math.h> // for fabs()

// 初始化电机驱动器
void motor_driver_init(motor_driver_t *driver, const motor_config_t *config) {
    driver->config = *config; // 复制配置信息
    driver->current_speed_rpm = 0.0f;
    driver->encoder_count = 0;
    driver->target_speed_rpm = 0.0f;
    driver->kp = 1.0f;  // 示例 PID 参数，需要根据实际系统调整
    driver->ki = 0.1f;
    driver->kd = 0.01f;
    driver->integral_term = 0.0f;
    driver->last_error = 0.0f;

    // 初始化 PWM 通道
    hal_pwm_init(&(config->pwm_channel));

    // 初始化方向控制引脚
    gpio_config_t direction_config_forward = {
        .pin = config->direction_pin_forward,
        .mode = GPIO_MODE_OUTPUT,
        .pull = GPIO_PULL_NONE,
        .speed = GPIO_SPEED_LOW
    };
    hal_gpio_init(&direction_config_forward);

    gpio_config_t direction_config_backward = {
        .pin = config->direction_pin_backward,
        .mode = GPIO_MODE_OUTPUT,
        .pull = GPIO_PULL_NONE,
        .speed = GPIO_SPEED_LOW
    };
    hal_gpio_init(&direction_config_backward);

    // 初始化编码器 (如果配置了编码器)
    if (config->encoder_resolution > 0) {
        hal_encoder_init(&(config->encoder_channel));
        hal_encoder_reset_count(config->encoder_channel);
    }

    motor_driver_stop(driver); // 初始状态停止电机
}

// 设置电机速度 (RPM) - 开环控制
void motor_driver_set_speed_open_loop(motor_driver_t *driver, float speed_rpm) {
    float duty_cycle = 0.0f;

    if (speed_rpm > driver->config.max_speed_rpm) {
        speed_rpm = driver->config.max_speed_rpm; // 限制最大速度
    } else if (speed_rpm < -driver->config.max_speed_rpm) {
        speed_rpm = -driver->config.max_speed_rpm; // 限制最小速度
    }

    if (speed_rpm > 0) {
        motor_driver_set_direction(driver, true); // 正转
        duty_cycle = speed_rpm / driver->config.max_speed_rpm;
    } else if (speed_rpm < 0) {
        motor_driver_set_direction(driver, false); // 反转
        duty_cycle = fabs(speed_rpm) / driver->config.max_speed_rpm;
    } else {
        motor_driver_stop(driver);
        return;
    }

    if (duty_cycle > 1.0f) duty_cycle = 1.0f; // 占空比限制在 0-1 之间
    if (duty_cycle < 0.0f) duty_cycle = 0.0f;

    hal_pwm_set_duty_cycle(driver->config.pwm_channel, duty_cycle);
    hal_pwm_start(driver->config.pwm_channel);
}

// 设置电机方向
void motor_driver_set_direction(motor_driver_t *driver, bool forward) {
    if (forward) {
        hal_gpio_write(driver->config.direction_pin_forward, true);
        hal_gpio_write(driver->config.direction_pin_backward, false);
    } else {
        hal_gpio_write(driver->config.direction_pin_forward, false);
        hal_gpio_write(driver->config.direction_pin_backward, true);
    }
}

// 停止电机
void motor_driver_stop(motor_driver_t *driver) {
    hal_pwm_stop(driver->config.pwm_channel);
    hal_pwm_set_duty_cycle(driver->config.pwm_channel, 0.0f); // 确保占空比为 0
}

// 获取当前电机转速 (RPM) - 基于编码器反馈 (如果使用编码器)
float motor_driver_get_speed_feedback(motor_driver_t *driver) {
    if (driver->config.encoder_resolution <= 0) {
        return 0.0f; // 未配置编码器，返回 0
    }

    int32_t current_encoder_count = hal_encoder_get_count(driver->config.encoder_channel);
    int32_t delta_count = current_encoder_count - driver->encoder_count;
    driver->encoder_count = current_encoder_count; // 更新上一次编码器计数

    // 假设 PID 控制更新周期为 T 秒 (例如 10ms = 0.01s)
    float time_interval_seconds = 0.01f; //  需要根据实际 PID 控制更新频率调整

    // 计算转速 (RPM)
    float speed_rpm = (float)delta_count / driver->config.encoder_resolution * 60.0f / time_interval_seconds;
    driver->current_speed_rpm = speed_rpm;
    return speed_rpm;
}

// 设置电机速度 (RPM) - 闭环 PID 控制 (如果使用编码器)
void motor_driver_set_speed_pid(motor_driver_t *driver, float speed_rpm) {
    driver->target_speed_rpm = speed_rpm; // 设置目标速度
}

// PID 控制器更新函数 (需要在定时器中断中定期调用)
void motor_driver_pid_control_update(motor_driver_t *driver) {
    if (driver->config.encoder_resolution <= 0) {
        return; // 未配置编码器，无法进行闭环控制
    }

    float current_speed = motor_driver_get_speed_feedback(driver);
    float error = driver->target_speed_rpm - current_speed;

    driver->integral_term += error;
    if (driver->integral_term > 1000.0f) driver->integral_term = 1000.0f; // 积分项饱和限制 (防止积分饱和)
    if (driver->integral_term < -1000.0f) driver->integral_term = -1000.0f;

    float derivative_term = error - driver->last_error;
    driver->last_error = error;

    float output_pwm = driver->kp * error + driver->ki * driver->integral_term + driver->kd * derivative_term;

    // 限制 PWM 输出范围
    if (output_pwm > 1.0f) output_pwm = 1.0f;
    if (output_pwm < -1.0f) output_pwm = -1.0f;

    motor_driver_set_speed_open_loop(driver, output_pwm * driver->config.max_speed_rpm); // 应用 PID 输出到开环控制

    // 调试输出 (可选)
    // printf("Target Speed: %.2f RPM, Current Speed: %.2f RPM, Error: %.2f, PWM: %.2f\n",
    //        driver->target_speed_rpm, current_speed, error, output_pwm);
}

3. 应用逻辑层 (Application Logic Layer)

app_motor_control.h

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#ifndef APP_MOTOR_CONTROL_H
#define APP_MOTOR_CONTROL_H

#include "motor_driver.h"

// 应用层电机控制相关函数声明

// 初始化电机控制系统
void app_motor_control_init(void);

// 设置目标电机速度 (RPM)
void app_motor_set_target_speed(float speed_rpm);

// 获取当前电机速度 (RPM)
float app_motor_get_current_speed(void);

// 启动电机
void app_motor_start(void);

// 停止电机
void app_motor_stop(void);

// 定时器中断服务函数 (用于 PID 控制更新) - 需要在主程序中注册
void app_motor_control_timer_irq_handler(void);

#endif // APP_MOTOR_CONTROL_H

app_motor_control.c

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
#include "app_motor_control.h"
#include "hal_timer.h" // 假设 HAL 层有定时器模块

// 电机驱动器实例
motor_driver_t motor_driver_instance;

// 电机配置参数 (需要根据实际硬件连接修改)
motor_config_t motor_config = {
    .pwm_channel = {
        .timer_instance = TIM1, // 假设使用 TIM1 定时器
        .channel = TIM_CHANNEL_1, // 假设使用 TIM1 通道 1
        .pwm_pin = {GPIOA, GPIO_PIN_8} // 假设 PWM 输出引脚为 PA8
    },
    .direction_pin_forward = {GPIOA, GPIO_PIN_0}, // 假设正转方向引脚为 PA0
    .direction_pin_backward = {GPIOA, GPIO_PIN_1}, // 假设反转方向引脚为 PA1
    .encoder_channel = {
        .timer_instance = TIM2, // 假设使用 TIM2 定时器作为编码器接口
        .channel_a = TIM_CHANNEL_1, // 假设编码器 A 相通道为 TIM2 通道 1
        .channel_b = TIM_CHANNEL_2, // 假设编码器 B 相通道为 TIM2 通道 2
        .pin_a = {GPIOA, GPIO_PIN_5}, // 假设编码器 A 相引脚为 PA5
        .pin_b = {GPIOA, GPIO_PIN_6}  // 假设编码器 B 相引脚为 PA6
    },
    .encoder_resolution = 1024, // 假设编码器分辨率为 1024 PPR
    .max_speed_rpm = 1000.0f     // 假设最大转速为 1000 RPM
};

// 定时器配置参数 (用于 PID 控制更新)
timer_config_t pid_control_timer_config = {
    .timer_instance = TIM3, // 假设使用 TIM3 定时器
    .frequency_hz = 100 // 假设 PID 控制更新频率为 100Hz (周期 10ms)
};

// 初始化电机控制系统
void app_motor_control_init(void) {
    motor_driver_init(&motor_driver_instance, &motor_config); // 初始化电机驱动器

    // 初始化定时器，用于 PID 控制更新
    hal_timer_init(&pid_control_timer_config);
    hal_timer_register_callback(&pid_control_timer_config, app_motor_control_timer_irq_handler); // 注册定时器中断回调函数
    hal_timer_start(&pid_control_timer_config); // 启动定时器
}

// 设置目标电机速度 (RPM)
void app_motor_set_target_speed(float speed_rpm) {
    motor_driver_set_speed_pid(&motor_driver_instance, speed_rpm);
}

// 获取当前电机速度 (RPM)
float app_motor_get_current_speed(void) {
    return motor_driver_get_speed_feedback(&motor_driver_instance);
}

// 启动电机
void app_motor_start(void) {
    // 可以添加启动前的准备工作，例如检查状态、使能驱动器等
    // ...
    motor_driver_set_speed_pid(&motor_driver_instance, motor_driver_instance.target_speed_rpm); // 启动时保持当前目标速度
}

// 停止电机
void app_motor_stop(void) {
    motor_driver_stop(&motor_driver_instance);
}

// 定时器中断服务函数 (用于 PID 控制更新) - 需要在 HAL 层或者主程序中实现定时器中断处理
void app_motor_control_timer_irq_handler(void) {
    motor_driver_pid_control_update(&motor_driver_instance); // 定期更新 PID 控制器
}

4. 接口层 (Interface Layer) - 示例：主程序 main.c

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#include "app_motor_control.h"
#include "hal_delay.h" // 假设 HAL 层有延时函数
#include <stdio.h> // for printf

int main(void) {
    // 系统初始化 (时钟、外设等) -  根据实际硬件平台进行初始化
    // ...

    hal_delay_init(); // 初始化延时函数

    app_motor_control_init(); // 初始化电机控制系统

    printf("Motor Control System Initialized!\n");

    app_motor_set_target_speed(500.0f); // 设置目标速度 500 RPM
    app_motor_start(); // 启动电机

    hal_delay_ms(5000); // 运行 5 秒

    app_motor_set_target_speed(-200.0f); // 设置目标速度 -200 RPM (反转)
    hal_delay_ms(5000); // 运行 5 秒

    app_motor_stop(); // 停止电机
    printf("Motor Stopped!\n");

    while (1) {
        // 主循环，可以添加其他系统任务或者用户交互
        float current_speed = app_motor_get_current_speed();
        printf("Current Speed: %.2f RPM\n", current_speed);
        hal_delay_ms(1000); // 每秒打印一次当前速度
    }
}

// 假设 HAL 层定时器中断处理函数 (需要根据实际 HAL 层实现)
void TIM3_IRQHandler(void) { // 假设 PID 定时器中断为 TIM3_IRQHandler
    hal_timer_irq_handler(&pid_control_timer_config); // 调用 HAL 层定时器中断处理函数
}

代码解释和关键技术点:

  1. 分层架构: 代码清晰地分为 HAL, Motor Driver, Application Logic 和 Interface 层，模块化程度高，易于维护和扩展。
  2. HAL 层: 抽象了硬件细节，例如 GPIO, PWM, Encoder 的操作，使得上层代码可以独立于具体的硬件平台。示例代码使用了 STM32 HAL 库的风格，实际应用中需要根据所使用的 MCU 和 HAL 库进行适配。
  3. 电机驱动层: 封装了电机驱动的逻辑，提供了开环和闭环 (PID) 速度控制接口。PID 控制算法的参数 kp, ki, kd 需要根据实际电机和系统进行整定。
  4. 应用逻辑层: 实现了应用层面的电机控制逻辑，例如设置目标速度、启动/停止电机、获取当前速度等。
  5. PID 闭环控制: 如果替代电机带有编码器，可以利用 PID 闭环控制提高速度控制的精度和稳定性。PID 参数的整定是关键，可以通过实验和调试来优化。
  6. 定时器中断: PID 控制需要定期更新，示例代码使用了定时器中断来周期性地调用 motor_driver_pid_control_update() 函数。定时器中断的频率需要根据系统响应速度和控制精度要求进行选择。
  7. 代码可扩展性: 这种架构方便添加新的电机控制功能，例如位置控制、电流环控制等。只需要在 Motor Driver 层添加新的接口和实现，并在 Application Logic 层调用即可。
  8. 代码可移植性: 由于 HAL 层隔离了硬件细节，如果需要更换 MCU 平台，只需要重新实现 HAL 层的代码，上层代码可以基本保持不变。

实践验证和技术方法:

  1. 硬件兼容性验证: 在选择替代电机后，首先要仔细核对电气参数和机械尺寸，确保替代电机能够与原系统兼容。进行实际硬件连接测试，验证电机能否正常驱动，编码器信号是否正常读取。
  2. 开环控制测试: 在没有编码器反馈的情况下，先进行开环控制测试，验证 PWM 调速功能是否正常，电机转速是否可控。
  3. 闭环 PID 控制参数整定: 如果使用 PID 闭环控制，需要进行参数整定。常用的方法有经验法、试错法、Ziegler-Nichols 方法等。可以使用示波器或者调试工具观察电机转速响应曲线，逐步调整 PID 参数，直到达到满意的控制效果。
  4. 性能测试: 在实际负载条件下测试替代电机的性能，例如最大转速、最大扭矩、响应速度、精度等，验证是否满足系统需求。
  5. 可靠性测试: 进行长时间运行测试、温度循环测试、振动测试等可靠性测试，验证替代电机在各种工况下的稳定性和寿命。
  6. 软件调试和优化: 使用调试器进行代码调试，优化 PID 参数，提高控制精度和响应速度。可以使用串口或者其他通信方式输出调试信息，方便实时监控系统状态。
  7. 文档记录: 详细记录电机替换过程、硬件连接、软件配置、测试结果等信息，方便后续维护和升级。

总结:

这个电机替换方案基于分层架构的代码设计，提供了详细的 C 代码示例，涵盖了 HAL 层、电机驱动层、应用逻辑层和接口层。通过合理的模块化设计和实践验证的技术方法，可以构建一个可靠、高效、可扩展的嵌入式系统平台，并成功实现 2715 电机的原位替代。 请务必根据您实际的硬件平台和电机参数进行代码适配和参数调整，并进行充分的测试验证，确保系统的稳定性和可靠性。

希望这份详细的解答能够帮助您！如果您有任何其他问题，欢迎随时提出。
Error executing command: Traceback (most recent call last):
File “/home/tong/.local/lib/python3.10/site-packages/urllib3/connectionpool.py”, line 466, in _make_request
self._validate_conn(conn)
File “/home/tong/.local/lib/python3.10/site-packages/urllib3/connectionpool.py”, line 1095, in _validate_conn
conn.connect()
File “/home/tong/.local/lib/python3.10/site-packages/urllib3/connection.py”, line 652, in connect
sock_and_verified = _ssl_wrap_socket_and_match_hostname(
File “/home/tong/.local/lib/python3.10/site-packages/urllib3/connection.py”, line 805, in ssl_wrap_socket_and_match_hostname
ssl_sock = ssl_wrap_socket(
File “/home/tong/.local/lib/python3.10/site-packages/urllib3/util/ssl.py”, line 465, in ssl_wrap_socket
ssl_sock = ssl_wrap_socket_impl(sock, context, tls_in_tls, server_hostname)
File “/home/tong/.local/lib/python3.10/site-packages/urllib3/util/ssl.py”, line 509, in _ssl_wrap_socket_impl
return ssl_context.wrap_socket(sock, server_hostname=server_hostname)
File “/usr/lib/python3.10/ssl.py”, line 513, in wrap_socket
return self.sslsocket_class._create(
File “/usr/lib/python3.10/ssl.py”, line 1071, in _create
self.do_handshake()
File “/usr/lib/python3.10/ssl.py”, line 1342, in do_handshake
self._sslobj.do_handshake()
ssl.SSLZeroReturnError: TLS/SSL connection has been closed (EOF) (_ssl.c:997)

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
File “/home/tong/.local/lib/python3.10/site-packages/urllib3/connectionpool.py”, line 789, in urlopen
response = self._make_request(
File “/home/tong/.local/lib/python3.10/site-packages/urllib3/connectionpool.py”, line 490, in _make_request
raise new_e
urllib3.exceptions.SSLError: TLS/SSL connection has been closed (EOF) (_ssl.c:997)

The above exception was the direct cause of the following exception:

Traceback (most recent call last):
File “/home/tong/.local/lib/python3.10/site-packages/requests/adapters.py”, line 667, in send
resp = conn.urlopen(
File “/home/tong/.local/lib/python3.10/site-packages/urllib3/connectionpool.py”, line 843, in urlopen
retries = retries.increment(
File “/home/tong/.local/lib/python3.10/site-packages/urllib3/util/retry.py”, line 519, in increment
raise MaxRetryError(_pool, url, reason) from reason # type: ignore[arg-type]
urllib3.exceptions.MaxRetryError: HTTPSConnectionPool(host=’generativelanguage.googleapis.com’, port=443): Max retries exceeded with url: /v1beta/models/gemini-2.0-flash-thinking-exp-01-21:streamGenerateContent?alt=sse (Caused by SSLError(SSLZeroReturnError(6, ‘TLS/SSL connection has been closed (EOF) (_ssl.c:997)’)))

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
File “/home/tong/bin/desc_img3.py”, line 73, in
for chunk in client.models.generate_content_stream(
File “/home/tong/.local/lib/python3.10/site-packages/google/genai/models.py”, line 3722, in generate_content_stream
for response_dict in self.api_client.request_streamed(
File “/home/tong/.local/lib/python3.10/site-packages/google/genai/_api_client.py”, line 341, in request_streamed
session_response = self._request(http_request, stream=True)
File “/home/tong/.local/lib/python3.10/site-packages/google/genai/_api_client.py”, line 263, in _request
return self._request_unauthorized(http_request, stream)
File “/home/tong/.local/lib/python3.10/site-packages/google/genai/_api_client.py”, line 284, in _request_unauthorized
response = http_session.send(request, stream=stream)
File “/home/tong/.local/lib/python3.10/site-packages/requests/sessions.py”, line 703, in send
r = adapter.send(request, **kwargs)
File “/home/tong/.local/lib/python3.10/site-packages/requests/adapters.py”, line 698, in send
raise SSLError(e, request=request)
requests.exceptions.SSLError: HTTPSConnectionPool(host=’generativelanguage.googleapis.com’, port=443): Max retries exceeded with url: /v1beta/models/gemini-2.0-flash-thinking-exp-01-21:streamGenerateContent?alt=sse (Caused by SSLError(SSLZeroReturnError(6, ‘TLS/SSL connection has been closed (EOF) (_ssl.c:997)’)))

欢迎关注我的其它发布渠道