GPT4o编写步进电机控制代码

 我给出的要求如下：

基于STM32F407 HAL库，写一个步进电机控制程序，需要控制8个步进电机，我会给出描述步进电机的结构体变量，基于这些变量需要你做出以下功能，电机脉冲通过定时器中断翻转脉冲引脚的电平实现，零点位置在最小限位和最大限位中间，运行的距离根据脉冲数而定。功能1：电机复位功能，电机向最小限位方向运行，接收到最小限位信号时停止，再向零点位置运行，到达零点位置后清零当前脉冲数计数。功能2：向指定方向运行指定脉冲数。结构体变量如下enum DIR_E
{
 DIR_Forward = 0,                                                    
 DIR_Backward                                                      
}; 

typedef struct {
    GPIO_TypeDef* port;      
    uint16_t pin;
} GpioPin_t;

typedef struct {
    GpioPin_t en;         //使能引脚
    GpioPin_t dir;        //方向引脚
    GpioPin_t pul;        //脉冲引脚
    GpioPin_t home;       //零点检测引脚，低电平有效
    GpioPin_t limit_min;  //最小位置检测引脚，低电平有效
    GpioPin_t limit_max;  //最大位置检测引脚，低电平有效
    int32_t PUL_pin_Alter; 
} MotorPins_t;

/**
 * @brief 步进电机结构体
 */
typedef struct {
    MotorPins_t pins;                   //控制引脚定义
    TIM_HandleTypeDef* htim;            //高速定时器
    TIM_HandleTypeDef* slow_htim;       //低速定时器
    int32_t total_steps;                //* 总移动步数计数器*/
    __IO int32_t  g_step_position;      /* 当前位置脉冲数 */
    __IO int32_t  a_step_position;      /* 目标位置脉冲数 */
    enum DIR_E dir;                        //电机方向
    enum DIR_E p_dir;                      //电机正方向 需要初始化设置
    int32_t home_offset;                //和零点位置偏差脉冲数
    uint8_t home_ready;                 //是否复位 1：已复位 0未复位。
    uint8_t motion_sta;                 //* 是否在运动？0：停止，1：运动 */

} StepperMotor_s;

要能够实现多个电机同时运行动作，给我一份完整的程序，C文件和H文件，包括8路电机参数、定时器和引脚的初始化，total_steps这个变量表示电机最大能够运行的步数，在复位或者其他动作时，如果运行超过这个步数还是没有接收到限位传感器信号则立即停止电机。加上中文注释。

GPT给出的程序如下

#ifndef STEPPER_MOTOR_H
#define STEPPER_MOTOR_H

#include "stm32f4xx_hal.h"

// 电机方向枚举
typedef enum {
    DIR_Forward = 0,  // 正向
    DIR_Backward     // 反向
} DIR_E;

// GPIO引脚结构体
typedef struct {
    GPIO_TypeDef* port; // GPIO端口
    uint16_t pin;       // GPIO引脚
} GpioPin_t;

// 电机引脚结构体
typedef struct {
    GpioPin_t en;       // 使能引脚
    GpioPin_t dir;      // 方向引脚
    GpioPin_t pul;      // 脉冲引脚
    GpioPin_t home;     // 零点检测引脚
    GpioPin_t limit_min;// 最小位置检测引脚
    GpioPin_t limit_max;// 最大位置检测引脚
    int32_t PUL_pin_Alter;
} MotorPins_t;

// 步进电机结构体
typedef struct {
    MotorPins_t pins;              // 控制引脚定义
    TIM_HandleTypeDef* htim;       // 定时器句柄
    int32_t total_steps;           // 电机最大步数
    __IO int32_t g_step_position;  // 当前位置脉冲数
    __IO int32_t a_step_position;  // 目标位置脉冲数
    DIR_E dir;                     // 当前方向
    DIR_E p_dir;                   // 正方向
    int32_t home_offset;           // 零点位置偏移
    uint8_t home_ready;            // 是否已复位
    uint8_t motion_sta;            // 是否在运动
} StepperMotor_s;

void Motor_Init(StepperMotor_s* motor);
void Motor_Reset(StepperMotor_s* motor);
void Motor_Move(StepperMotor_s* motor, int32_t steps);

#endif // STEPPER_MOTOR_H

#include "stepper_motor.h"

#define NUM_MOTORS 8 // 电机数量

StepperMotor_s motors[NUM_MOTORS];

// 电机初始化函数
void Motor_Init(StepperMotor_s* motor) {
    // 在此初始化GPIO和定时器
}

// 定时器中断回调函数
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim) {
    for (int i = 0; i < NUM_MOTORS; i++) {
        StepperMotor_s *motor = &motors[i];
        
        if (motor->motion_sta) {
            HAL_GPIO_TogglePin(motor->pins.pul.port, motor->pins.pul.pin);

            if (motor->dir == DIR_Forward) {
                motor->g_step_position++;
            } else {
                motor->g_step_position--;
            }

            // 检查是否达到目标位置或超过最大步数
            if (motor->g_step_position == motor->a_step_position || 
                motor->g_step_position >= motor->total_steps || 
                motor->g_step_position <= -motor->total_steps) {
                motor->motion_sta = 0;
                HAL_GPIO_WritePin(motor->pins.en.port, motor->pins.en.pin, GPIO_PIN_SET);
            }
        }
    }
}

// 电机复位函数
void Motor_Reset(StepperMotor_s* motor) {
    HAL_GPIO_WritePin(motor->pins.en.port, motor->pins.en.pin, GPIO_PIN_RESET);
    HAL_GPIO_WritePin(motor->pins.dir.port, motor->pins.dir.pin, DIR_Backward);

    int32_t step_count = 0;
    while (HAL_GPIO_ReadPin(motor->pins.limit_min.port, motor->pins.limit_min.pin) != GPIO_PIN_RESET) {
        HAL_GPIO_TogglePin(motor->pins.pul.port, motor->pins.pul.pin);
        HAL_Delay(1);
        
        step_count++;
        if (step_count >= motor->total_steps) {
            break;
        }
    }

    // 移动到零点位置
    int32_t steps_to_home = motor->home_offset;
    if (steps_to_home > 0) {
        HAL_GPIO_WritePin(motor->pins.dir.port, motor->pins.dir.pin, DIR_Forward);
    } else {
        HAL_GPIO_WritePin(motor->pins.dir.port, motor->pins.dir.pin, DIR_Backward);
        steps_to_home = -steps_to_home;
    }

    for (int32_t i = 0; i < steps_to_home; i++) {
        HAL_GPIO_TogglePin(motor->pins.pul.port, motor->pins.pul.pin);
        HAL_Delay(1);
    }

    motor->g_step_position = 0;
    motor->home_ready = 1;
}

// 电机移动函数
void Motor_Move(StepperMotor_s* motor, int32_t steps) {
    if (steps == 0) return;

    if (steps > 0) {
        motor->dir = DIR_Forward;
    } else {
        motor->dir = DIR_Backward;
        steps = -steps;
    }

    motor->a_step_position = motor->g_step_position + steps;
    if (motor->a_step_position > motor->total_steps) {
        motor->a_step_position = motor->total_steps;
    } else if (motor->a_step_position < -motor->total_steps) {
        motor->a_step_position = -motor->total_steps;
    }
    motor->motion_sta = 1;

    HAL_GPIO_WritePin(motor->pins.en.port, motor->pins.en.pin, GPIO_PIN_RESET);
    HAL_GPIO_WritePin(motor->pins.dir.port, motor->pins.dir.pin, motor->dir);
}