• admin
    #include "driverlib.h"
    #include "device.h"
    
    // ========== 全局变量 ==========
    volatile struct SCI_REGS *dbg_uart;
    volatile uint8_t motor_run = 0;
    volatile uint32_t delay_cnt;
    volatile uint32_t deadtime_cnt; // 死区计数
    
    // ========== 串口收发 ==========
    void uart_send_byte(uint16_t byte)
    {
        while (!dbg_uart->SCICTL2.bit.TXEMPTY);
        dbg_uart->SCITXBUF.all = byte;
    }
    
    int uart_receive_byte_nonblocking(void)
    {
        if (dbg_uart->SCIFFRX.bit.RXFFST > 0) {
            return dbg_uart->SCIRXBUF.all & 0x00FF;
        }
        return -1;
    }
    
    static void gpio_output_init(uint32_t pin)
    {
        GPIO_setPadConfig(pin, GPIO_PIN_TYPE_STD);
        GPIO_setDirectionMode(pin, GPIO_DIR_MODE_OUT);
    }
    
    // ========== 主函数 ==========
    int main(void)
    {
        Device_init();
        Interrupt_initVectorTable();
    
        gpio_output_init(1);
        gpio_output_init(16); // SD 1
        gpio_output_init(11); // SD 2
        gpio_output_init(24); // IN 1
        gpio_output_init(32); // IN 2
    
        // 上电安全状态
        GPIO_writePin(16, 0); GPIO_writePin(11, 0);
        GPIO_writePin(24, 0); GPIO_writePin(32, 0);
    
        for(delay_cnt = 0; delay_cnt < 1000000; delay_cnt++) {}
    
        // 串口配置
        EALLOW;
        GpioCtrlRegs.GPAMUX2.bit.GPIO28 = 1; GpioCtrlRegs.GPAGMUX2.bit.GPIO28 = 0;
        GpioCtrlRegs.GPAMUX2.bit.GPIO29 = 1; GpioCtrlRegs.GPAGMUX2.bit.GPIO29 = 0;
        EDIS;
    
        SysCtl_enablePeripheral(SYSCTL_PERIPH_CLK_SCIA);
        SCI_setConfig(SCIA_BASE, DEVICE_LSPCLK_FREQ, 115200, (SCI_CONFIG_WLEN_8 | SCI_CONFIG_STOP_ONE | SCI_CONFIG_PAR_NONE));
        SCI_enableModule(SCIA_BASE); SCI_resetChannels(SCIA_BASE); SCI_enableFIFO(SCIA_BASE);
        dbg_uart = &SciaRegs;
    
        Interrupt_enableMaster();
    
        int rx_data;
        uint16_t pwm_cnt = 0;
        uint32_t blink_cnt = 0;
        uint16_t duty_cycle = 95;
        uint8_t last_pwm_state = 0; // 记录上一次的状态,用于死区检测
    
        for(;;) {
            // 串口控制
            while ((rx_data = uart_receive_byte_nonblocking()) != -1) {
                uart_send_byte((uint16_t)rx_data);
                if (rx_data == '1' || rx_data == 'F' || rx_data == 'f') motor_run = 1;
                else if (rx_data == '0' || rx_data == 'S' || rx_data == 's') motor_run = 0;
            }
    
            pwm_cnt++;
            if (pwm_cnt >= 100) {
                pwm_cnt = 0;
                blink_cnt++;
            }
    
            if (motor_run == 1) {
                GPIO_writePin(16, 1); // SD 1 恒为 1
    
                if (pwm_cnt < duty_cycle) {
                    // 需要变为 [IN1高, IN2低]
                    if (last_pwm_state == 0) {
                        // 加入极短的死区(先全关)
                        GPIO_writePin(24, 0); GPIO_writePin(32, 0); GPIO_writePin(11, 0);
                        for(deadtime_cnt = 0; deadtime_cnt < 10; deadtime_cnt++) {} // 微秒级死区
                    }
                    GPIO_writePin(24, 1); // IN 1
                    GPIO_writePin(32, 0); // IN 2
                    GPIO_writePin(11, 1); // SD 2
                    last_pwm_state = 1;
                } else {
                    // 需要变为 [IN1低, IN2高]
                    if (last_pwm_state == 1) {
                        // 加入极短的死区(先全关)
                        GPIO_writePin(24, 0); GPIO_writePin(32, 0); GPIO_writePin(11, 0);
                        for(deadtime_cnt = 0; deadtime_cnt < 10; deadtime_cnt++) {} // 微秒级死区
                    }
                    GPIO_writePin(24, 0); // IN 1
                    GPIO_writePin(32, 1); // IN 2
                    GPIO_writePin(11, 0); // SD 2
                    last_pwm_state = 0;
                }
            } else {
                GPIO_writePin(16, 0); GPIO_writePin(11, 0); GPIO_writePin(24, 0); GPIO_writePin(32, 0);
                last_pwm_state = 0;
            }
    
            // 35kHz 主循环延时
            for (delay_cnt = 0; delay_cnt < 5; delay_cnt++) {}
    
            if (blink_cnt >= 15000) {
                blink_cnt = 0;
                GPIO_togglePin(1);
            }
        }
    }
    主楼
  • admin
    #include "driverlib.h"
    #include "device.h"
    
    // ========== 全局变量 ==========
    volatile struct SCI_REGS *dbg_uart;
    volatile uint8_t motor_run = 0;
    volatile uint32_t delay_cnt;
    volatile uint32_t deadtime_cnt; 
    
    // 软启动相关变量
    volatile uint16_t target_duty = 95;   // 目标最终占空比
    volatile uint16_t current_duty = 0;   // 当前实时占空比(从0开始)
    
    // ========== 串口收发 ==========
    void uart_send_byte(uint16_t byte)
    {
        while (!dbg_uart->SCICTL2.bit.TXEMPTY);
        dbg_uart->SCITXBUF.all = byte;
    }
    
    int uart_receive_byte_nonblocking(void)
    {
        if (dbg_uart->SCIFFRX.bit.RXFFST > 0) {
            return dbg_uart->SCIRXBUF.all & 0x00FF;
        }
        return -1;
    }
    
    static void gpio_output_init(uint32_t pin)
    {
        GPIO_setPadConfig(pin, GPIO_PIN_TYPE_STD);
        GPIO_setDirectionMode(pin, GPIO_DIR_MODE_OUT);
    }
    
    // ========== 主函数 ==========
    int main(void)
    {
        Device_init();
        Interrupt_initVectorTable();
    
        gpio_output_init(1);
        gpio_output_init(16); // SD 1
        gpio_output_init(11); // SD 2
        gpio_output_init(24); // IN 1
        gpio_output_init(32); // IN 2
    
        // 上电安全状态
        GPIO_writePin(16, 0); GPIO_writePin(11, 0);
        GPIO_writePin(24, 0); GPIO_writePin(32, 0);
    
        for(delay_cnt = 0; delay_cnt < 1000000; delay_cnt++) {}
    
        // 串口配置
        EALLOW;
        GpioCtrlRegs.GPAMUX2.bit.GPIO28 = 1; GpioCtrlRegs.GPAGMUX2.bit.GPIO28 = 0;
        GpioCtrlRegs.GPAMUX2.bit.GPIO29 = 1; GpioCtrlRegs.GPAGMUX2.bit.GPIO29 = 0;
        EDIS;
    
        SysCtl_enablePeripheral(SYSCTL_PERIPH_CLK_SCIA);
        SCI_setConfig(SCIA_BASE, DEVICE_LSPCLK_FREQ, 115200, (SCI_CONFIG_WLEN_8 | SCI_CONFIG_STOP_ONE | SCI_CONFIG_PAR_NONE));
        SCI_enableModule(SCIA_BASE); SCI_resetChannels(SCIA_BASE); SCI_enableFIFO(SCIA_BASE);
        dbg_uart = &SciaRegs;
    
        Interrupt_enableMaster();
    
        int rx_data;
        uint16_t pwm_cnt = 0;
        uint32_t blink_cnt = 0;
        uint32_t soft_start_cnt = 0; // 软启动节拍计数器
        uint8_t last_pwm_state = 0; 
    
        for(;;) {
            // 串口控制
            while ((rx_data = uart_receive_byte_nonblocking()) != -1) {
                uart_send_byte((uint16_t)rx_data);
                if (rx_data == '1' || rx_data == 'F' || rx_data == 'f') motor_run = 1;
                else if (rx_data == '0' || rx_data == 'S' || rx_data == 's') motor_run = 0;
            }
    
            pwm_cnt++;
            if (pwm_cnt >= 100) {
                pwm_cnt = 0;
                blink_cnt++;
                
                // ======== 软启动逻辑 ========
                if (motor_run == 1) {
                    soft_start_cnt++;
                    // 每跑完 50 个 PWM 周期(约 1.5 毫秒),占空比增加 1%
                    // 从 0% 爬到 95% 大约需要 50 * 95 = 4750 个周期,折合时间约 0.15 秒
                    if (soft_start_cnt >= 50) {
                        soft_start_cnt = 0;
                        if (current_duty < target_duty) {
                            current_duty++; // 增加占空比
                        }
                    }
                }
            }
    
            if (motor_run == 1) {
                GPIO_writePin(16, 1); // SD 1 恒为 1
    
                // 使用实时变化的 current_duty 代替固定的 duty_cycle
                if (pwm_cnt < current_duty) {
                    // 需要变为 [IN1高, IN2低]
                    if (last_pwm_state == 0) {
                        GPIO_writePin(24, 0); GPIO_writePin(32, 0); GPIO_writePin(11, 0);
                        for(deadtime_cnt = 0; deadtime_cnt < 10; deadtime_cnt++) {} 
                    }
                    GPIO_writePin(24, 1); // IN 1
                    GPIO_writePin(32, 0); // IN 2
                    GPIO_writePin(11, 1); // SD 2
                    last_pwm_state = 1;
                } else {
                    // 需要变为 [IN1低, IN2高]
                    if (last_pwm_state == 1) {
                        GPIO_writePin(24, 0); GPIO_writePin(32, 0); GPIO_writePin(11, 0);
                        for(deadtime_cnt = 0; deadtime_cnt < 10; deadtime_cnt++) {} 
                    }
                    GPIO_writePin(24, 0); // IN 1
                    GPIO_writePin(32, 1); // IN 2
                    GPIO_writePin(11, 0); // SD 2
                    last_pwm_state = 0;
                }
            } else {
                GPIO_writePin(16, 0); GPIO_writePin(11, 0); GPIO_writePin(24, 0); GPIO_writePin(32, 0);
                last_pwm_state = 0;
                current_duty = 0; // ★ 停止时,将实时占空比清零,确保下次启动重新软启动
                soft_start_cnt = 0;
            }
    
            // 35kHz 主循环延时
            for (delay_cnt = 0; delay_cnt < 5; delay_cnt++) {}
    
            if (blink_cnt >= 15000) {
                blink_cnt = 0;
                GPIO_togglePin(1);
            }
        }
    }

    添加了软启动。

    #1
  • admin
    #include "driverlib.h"
    #include "device.h"
    
    /* ==================== GPIO ==================== */
    
    #define MOTOR_SD1_PIN             16U
    #define MOTOR_SD2_PIN             11U
    
    #define MOTOR_IN1_PIN             24U
    #define MOTOR_IN2_PIN             32U
    
    #define LED_PIN                   1U
    
    /* ==================== PWM ==================== */
    
    #define MOTOR_PWM_BASE            EPWM8_BASE
    #define MOTOR_PWM_FREQ_HZ         35000UL
    
    /*
     * 适用于 F280049 标准时钟配置:
     * ePWM 时钟为 SYSCLK,ePWM 两级分频都设置为 1。
     */
    #define MOTOR_PWM_TBCLK_HZ         DEVICE_SYSCLK_FREQ
    
    #define MOTOR_PWM_PERIOD_COUNTS   \
        ((MOTOR_PWM_TBCLK_HZ + MOTOR_PWM_FREQ_HZ / 2UL) / \
          MOTOR_PWM_FREQ_HZ)
    
    #define MOTOR_PWM_TBPRD           \
        ((uint16_t)(MOTOR_PWM_PERIOD_COUNTS - 1UL))
    
    /* ==================== 软启动 ==================== */
    
    /*
     * 万分比单位:
     * 10000 = 100%
     *   200 = 2%
     *  2000 = 20%
     */
    #define DUTY_FULL_SCALE           10000UL
    
    #define START_DUTY_BP             500U
    #define TARGET_DUTY_BP            9500U
    
    /*
     * 保留原来的目标占空比 20%。
     * 此上限只是软件限制,不是过流保护。
     */
    #define MAX_DUTY_BP               9500U
    
    #define CONTROL_FREQ_HZ           1000UL
    
    /* 原来10秒,现在5秒 */
    #define SOFT_START_TIME_MS        5000UL
    
    /* 自举预充电时间,需结合实际硬件验证 */
    #define PRECHARGE_TIME_MS         5U
    
    /*
     * 停机后最小禁止启动时间。
     * 这不是停转检测,必须确认电机实际停止后再反转。
     */
    #define RESTART_LOCKOUT_MS        1000U
    
    #define LED_TOGGLE_MS             500U
    
    #if TARGET_DUTY_BP < START_DUTY_BP
    #error TARGET_DUTY_BP_must_not_be_less_than_START_DUTY_BP
    #endif
    
    #if TARGET_DUTY_BP > MAX_DUTY_BP
    #error TARGET_DUTY_BP_exceeds_MAX_DUTY_BP
    #endif
    
    /* ==================== 命令 ==================== */
    
    #define CMD_STOP                  0U
    #define CMD_FORWARD               1U
    #define CMD_REVERSE               2U
    
    /* ==================== 状态 ==================== */
    
    #define STATE_STOPPED             0U
    #define STATE_PRECHARGE           1U
    #define STATE_ARMED               2U
    #define STATE_RUNNING             3U
    
    /*
     * 主循环发布命令,中断处理命令。
     *
     * 命令序号使每个新字符只执行一次:
     * 被换向保护拒绝的命令,不会在稍后自动启动电机。
     */
    static volatile uint16_t command_value = CMD_STOP;
    static volatile uint16_t command_sequence = 0U;
    
    /* 以下变量可在调试器中观察 */
    volatile uint16_t motor_state = STATE_STOPPED;
    volatile uint16_t motor_direction = CMD_STOP;
    volatile uint16_t current_duty_bp = 0U;
    
    volatile uint16_t restart_lockout_ms = 0U;
    
    /*
     * 置1表示:
     * - 运行中收到相反方向命令,已停机;或
     * - 锁定时间内收到启动命令,未执行。
     *
     * 成功接受启动命令时清零。
     */
    volatile uint16_t command_rejected = 0U;
    
    /* 仅由控制中断维护 */
    static uint16_t precharge_ms = 0U;
    static uint16_t led_ms = 0U;
    static uint32_t ramp_accumulator = 0UL;
    
    /* ==================== 函数声明 ==================== */
    
    __interrupt void cpuTimer0ISR(void);
    
    static void board_gpio_init(void);
    static void uart_init(void);
    static void motor_pwm_init(void);
    static void control_timer_init(void);
    
    static inline void pwm_force_both_low(void);
    static inline void motor_set_duty_bp(uint16_t duty_bp);
    
    static void motor_stop(void);
    static void motor_start_precharge(uint16_t direction);
    static void motor_process_command(uint16_t command);
    
    /* ==================== GPIO 初始化 ==================== */
    
    static void gpio_output_low(uint32_t pin)
    {
        GPIO_writePin(pin, 0U);
        GPIO_setPadConfig(pin, GPIO_PIN_TYPE_STD);
        GPIO_setDirectionMode(pin, GPIO_DIR_MODE_OUT);
    }
    
    static void board_gpio_init(void)
    {
        /*
         * 先配置 SD,保持两颗驱动器关闭。
         * 上电初始化之前的关断状态应由外部下拉保证。
         */
        GPIO_setPinConfig(GPIO_16_GPIO16);
        GPIO_setPinConfig(GPIO_11_GPIO11);
    
        gpio_output_low(MOTOR_SD1_PIN);
        gpio_output_low(MOTOR_SD2_PIN);
    
        GPIO_setPinConfig(GPIO_24_GPIO24);
        GPIO_setPinConfig(GPIO_32_GPIO32);
    
        gpio_output_low(MOTOR_IN1_PIN);
        gpio_output_low(MOTOR_IN2_PIN);
    
        GPIO_setPinConfig(GPIO_1_GPIO1);
        gpio_output_low(LED_PIN);
    }
    
    /* ==================== SCI 初始化 ==================== */
    
    static void uart_init(void)
    {
        SysCtl_enablePeripheral(SYSCTL_PERIPH_CLK_SCIA);
    
        GPIO_setPinConfig(GPIO_28_SCIA_RX);
        GPIO_setPinConfig(GPIO_29_SCIA_TX);
    
        GPIO_setPadConfig(28U, GPIO_PIN_TYPE_STD);
        GPIO_setPadConfig(29U, GPIO_PIN_TYPE_STD);
    
        GPIO_setQualificationMode(28U, GPIO_QUAL_ASYNC);
    
        SCI_disableModule(SCIA_BASE);
    
        SCI_setConfig(
            SCIA_BASE,
            DEVICE_LSPCLK_FREQ,
            115200UL,
            SCI_CONFIG_WLEN_8 |
            SCI_CONFIG_STOP_ONE |
            SCI_CONFIG_PAR_NONE
        );
    
        SCI_enableFIFO(SCIA_BASE);
    
        SCI_resetTxFIFO(SCIA_BASE);
        SCI_resetRxFIFO(SCIA_BASE);
    
        SCI_resetChannels(SCIA_BASE);
        SCI_enableModule(SCIA_BASE);
        SCI_performSoftwareReset(SCIA_BASE);
    }
    
    /* ==================== PWM 控制 ==================== */
    
    static inline void pwm_force_both_low(void)
    {
        /*
         * 这里强制的是两颗 IR2302 的 IN,
         * 并非直接强制四颗 MOS 的栅极。
         *
         * SD=1 时,IN=0 对应下管导通。
         * SD=0 时,上下管均关闭。
         */
        EPWM_setActionQualifierContSWForceAction(
            MOTOR_PWM_BASE,
            EPWM_AQ_OUTPUT_A,
            EPWM_AQ_SW_OUTPUT_LOW
        );
    
        EPWM_setActionQualifierContSWForceAction(
            MOTOR_PWM_BASE,
            EPWM_AQ_OUTPUT_B,
            EPWM_AQ_SW_OUTPUT_LOW
        );
    }
    
    static void motor_pwm_init(void)
    {
        SysCtl_enablePeripheral(SYSCTL_PERIPH_CLK_EPWM8);
    
        /*
         * 本示例假定没有其他正在使用的 ePWM。
         * TBCLKSYNC 是全局控制,整合工程时需统一处理。
         */
        SysCtl_disablePeripheral(SYSCTL_PERIPH_CLK_TBCLKSYNC);
    
        EPWM_setTimeBaseCounterMode(
            MOTOR_PWM_BASE,
            EPWM_COUNTER_MODE_STOP_FREEZE
        );
    
        EPWM_setClockPrescaler(
            MOTOR_PWM_BASE,
            EPWM_CLOCK_DIVIDER_1,
            EPWM_HSCLOCK_DIVIDER_1
        );
    
        EPWM_disablePhaseShiftLoad(MOTOR_PWM_BASE);
        EPWM_setPhaseShift(MOTOR_PWM_BASE, 0U);
    
        EPWM_setPeriodLoadMode(
            MOTOR_PWM_BASE,
            EPWM_PERIOD_DIRECT_LOAD
        );
    
        EPWM_setTimeBasePeriod(
            MOTOR_PWM_BASE,
            MOTOR_PWM_TBPRD
        );
    
        EPWM_setTimeBaseCounter(MOTOR_PWM_BASE, 0U);
    
        /*
         * A、B 使用同一个 CMPA:
         * 两路具有相同的基础 PWM 波形。
         *
         * 实际运行时只释放其中一路,
         * 另一路始终强制为低。
         */
        EPWM_setCounterCompareShadowLoadMode(
            MOTOR_PWM_BASE,
            EPWM_COUNTER_COMPARE_A,
            EPWM_COMP_LOAD_ON_CNTR_ZERO
        );
    
        EPWM_setCounterCompareValue(
            MOTOR_PWM_BASE,
            EPWM_COUNTER_COMPARE_A,
            1U
        );
    
        /* A:ZERO置高,向上到CMPA置低 */
        EPWM_setActionQualifierAction(
            MOTOR_PWM_BASE,
            EPWM_AQ_OUTPUT_A,
            EPWM_AQ_OUTPUT_HIGH,
            EPWM_AQ_OUTPUT_ON_TIMEBASE_ZERO
        );
    
        EPWM_setActionQualifierAction(
            MOTOR_PWM_BASE,
            EPWM_AQ_OUTPUT_A,
            EPWM_AQ_OUTPUT_LOW,
            EPWM_AQ_OUTPUT_ON_TIMEBASE_UP_CMPA
        );
    
        /* B:ZERO置高,向上到CMPA置低 */
        EPWM_setActionQualifierAction(
            MOTOR_PWM_BASE,
            EPWM_AQ_OUTPUT_B,
            EPWM_AQ_OUTPUT_HIGH,
            EPWM_AQ_OUTPUT_ON_TIMEBASE_ZERO
        );
    
        EPWM_setActionQualifierAction(
            MOTOR_PWM_BASE,
            EPWM_AQ_OUTPUT_B,
            EPWM_AQ_OUTPUT_LOW,
            EPWM_AQ_OUTPUT_ON_TIMEBASE_UP_CMPA
        );
    
        /*
         * 不使用 MCU 死区模块。
         * 每颗 IR2302 通过一个 IN 控制本桥臂上下管,
         * 使用驱动芯片内部的死区。
         *
         * A、B 分别控制两个不同桥臂,
         * 不能把它们当成同一个桥臂的栅极互补信号。
         */
        EPWM_setDeadBandDelayMode(
            MOTOR_PWM_BASE,
            EPWM_DB_RED,
            false
        );
    
        EPWM_setDeadBandDelayMode(
            MOTOR_PWM_BASE,
            EPWM_DB_FED,
            false
        );
    
        EPWM_setActionQualifierContSWForceShadowMode(
            MOTOR_PWM_BASE,
            EPWM_AQ_SW_IMMEDIATE_LOAD
        );
    
        pwm_force_both_low();
    
        /*
         * SD 仍为低,且两路已强制低,
         * 现在再切换引脚复用。
         */
        GPIO_setPinConfig(GPIO_24_EPWM8_A);
        GPIO_setPinConfig(GPIO_32_EPWM8_B);
    
        EPWM_setTimeBaseCounterMode(
            MOTOR_PWM_BASE,
            EPWM_COUNTER_MODE_UP
        );
    
        SysCtl_enablePeripheral(SYSCTL_PERIPH_CLK_TBCLKSYNC);
    }
    
    static inline void motor_set_duty_bp(uint16_t duty_bp)
    {
        uint32_t compare;
    
        if (duty_bp > MAX_DUTY_BP) {
            duty_bp = MAX_DUTY_BP;
        }
    
        compare =
            ((uint32_t)MOTOR_PWM_PERIOD_COUNTS *
             (uint32_t)duty_bp +
             DUTY_FULL_SCALE / 2UL) /
            DUTY_FULL_SCALE;
    
        if (compare < 1UL) {
            compare = 1UL;
        }
    
        if (compare >= MOTOR_PWM_PERIOD_COUNTS) {
            compare = MOTOR_PWM_PERIOD_COUNTS - 1UL;
        }
    
        EPWM_setCounterCompareValue(
            MOTOR_PWM_BASE,
            EPWM_COUNTER_COMPARE_A,
            (uint16_t)compare
        );
    }
    
    /* ==================== 电机状态控制 ==================== */
    
    static void motor_stop(void)
    {
        /* 先关闭两颗驱动器 */
        GPIO_writePin(MOTOR_SD1_PIN, 0U);
        GPIO_writePin(MOTOR_SD2_PIN, 0U);
    
        pwm_force_both_low();
    
        motor_state = STATE_STOPPED;
        motor_direction = CMD_STOP;
    
        current_duty_bp = 0U;
        precharge_ms = 0U;
        ramp_accumulator = 0UL;
    
        restart_lockout_ms = RESTART_LOCKOUT_MS;
    }
    
    static void motor_start_precharge(uint16_t direction)
    {
        /* 只允许从停止状态进入 */
        GPIO_writePin(MOTOR_SD1_PIN, 0U);
        GPIO_writePin(MOTOR_SD2_PIN, 0U);
    
        pwm_force_both_low();
    
        motor_direction = direction;
        current_duty_bp = 0U;
    
        precharge_ms = 0U;
        ramp_accumulator = 0UL;
    
        /*
         * 两个 IN 都为低,再开启 SD。
         * 两只下管导通,为自举电容预充电。
         *
         * 注意:此时会短接电机两端,
         * 启动前必须确认电机已经停止。
         */
        GPIO_writePin(MOTOR_SD1_PIN, 1U);
        GPIO_writePin(MOTOR_SD2_PIN, 1U);
    
        motor_state = STATE_PRECHARGE;
    }
    
    static void motor_process_command(uint16_t command)
    {
        if (command == CMD_STOP) {
    
            if (motor_state != STATE_STOPPED) {
                motor_stop();
            }
    
            return;
        }
    
        if ((command != CMD_FORWARD) &&
            (command != CMD_REVERSE)) {
            return;
        }
    
        if (motor_state != STATE_STOPPED) {
    
            if (command != motor_direction) {
    
                /*
                 * 相反方向命令:
                 * 只停机,不自动反向启动。
                 */
                motor_stop();
                command_rejected = 1U;
            }
    
            /* 同方向命令不重复触发软启动 */
            return;
        }
    
        if (restart_lockout_ms != 0U) {
    
            /*
             * 冷却间隔内不接受启动。
             * 该命令被丢弃,之后必须重新发送。
             */
            command_rejected = 1U;
            return;
        }
    
        command_rejected = 0U;
        motor_start_precharge(command);
    }
    
    /* ==================== 1ms 控制中断 ==================== */
    
    __interrupt void cpuTimer0ISR(void)
    {
        static uint16_t handled_sequence = 0U;
    
        uint16_t sequence;
        uint16_t command;
    
        if (restart_lockout_ms > 0U) {
            restart_lockout_ms--;
        }
    
        /*
         * 主循环不会在 ISR 执行期间运行。
         * 主循环先写命令,再更新序号。
         */
        sequence = command_sequence;
    
        if (sequence != handled_sequence) {
    
            command = command_value;
            handled_sequence = sequence;
    
            motor_process_command(command);
        }
    
        switch (motor_state) {
    
            case STATE_STOPPED:
                break;
    
            case STATE_PRECHARGE:
    
                precharge_ms++;
    
                if (precharge_ms >= PRECHARGE_TIME_MS) {
    
                    current_duty_bp = START_DUTY_BP;
                    ramp_accumulator = 0UL;
    
                    motor_set_duty_bp(current_duty_bp);
    
                    /*
                     * 再等到下一次1ms中断释放PWM,
                     * 确保CMPA影子值已经装载。
                     */
                    motor_state = STATE_ARMED;
                }
                break;
    
            case STATE_ARMED:
    
                if (motor_direction == CMD_FORWARD) {
    
                    /* 正转:A输出PWM,B保持低 */
                    EPWM_setActionQualifierContSWForceAction(
                        MOTOR_PWM_BASE,
                        EPWM_AQ_OUTPUT_B,
                        EPWM_AQ_SW_OUTPUT_LOW
                    );
    
                    EPWM_setActionQualifierContSWForceAction(
                        MOTOR_PWM_BASE,
                        EPWM_AQ_OUTPUT_A,
                        EPWM_AQ_SW_DISABLED
                    );
    
                } else if (motor_direction == CMD_REVERSE) {
    
                    /* 反转:B输出PWM,A保持低 */
                    EPWM_setActionQualifierContSWForceAction(
                        MOTOR_PWM_BASE,
                        EPWM_AQ_OUTPUT_A,
                        EPWM_AQ_SW_OUTPUT_LOW
                    );
    
                    EPWM_setActionQualifierContSWForceAction(
                        MOTOR_PWM_BASE,
                        EPWM_AQ_OUTPUT_B,
                        EPWM_AQ_SW_DISABLED
                    );
    
                } else {
    
                    motor_stop();
                    break;
                }
    
                motor_state = STATE_RUNNING;
                break;
    
            case STATE_RUNNING:
    
                if (current_duty_bp < TARGET_DUTY_BP) {
    
                    /*
                     * 默认每1ms累加1800,
                     * 每累计5000,占空比增加一个万分比单位。
                     *
                     * 5000ms完成:
                     * 200 -> 2000,即2% -> 20%。
                     */
                    ramp_accumulator +=
                        (uint32_t)TARGET_DUTY_BP -
                        (uint32_t)START_DUTY_BP;
    
                    while (
                        ramp_accumulator >= SOFT_START_TIME_MS
                    ) {
                        ramp_accumulator -= SOFT_START_TIME_MS;
    
                        if (current_duty_bp < TARGET_DUTY_BP) {
                            current_duty_bp++;
                        }
                    }
    
                    motor_set_duty_bp(current_duty_bp);
                }
                break;
    
            default:
    
                motor_stop();
                break;
        }
    
        led_ms++;
    
        if (led_ms >= LED_TOGGLE_MS) {
            led_ms = 0U;
            GPIO_togglePin(LED_PIN);
        }
    
        CPUTimer_clearOverflowFlag(CPUTIMER0_BASE);
    
        Interrupt_clearACKGroup(INTERRUPT_ACK_GROUP1);
    }
    
    /* ==================== Timer0 初始化 ==================== */
    
    static void control_timer_init(void)
    {
        CPUTimer_stopTimer(CPUTIMER0_BASE);
    
        CPUTimer_setPreScaler(CPUTIMER0_BASE, 0U);
    
        CPUTimer_setPeriod(
            CPUTIMER0_BASE,
            (DEVICE_SYSCLK_FREQ / CONTROL_FREQ_HZ) - 1UL
        );
    
        CPUTimer_reloadTimerCounter(CPUTIMER0_BASE);
        CPUTimer_clearOverflowFlag(CPUTIMER0_BASE);
    
        Interrupt_register(INT_TIMER0, &cpuTimer0ISR);
    
        CPUTimer_enableInterrupt(CPUTIMER0_BASE);
        Interrupt_enable(INT_TIMER0);
    
        CPUTimer_startTimer(CPUTIMER0_BASE);
    }
    
    /* ==================== 主函数 ==================== */
    
    int main(void)
    {
        uint16_t rx_data;
        uint16_t next_command;
        uint16_t valid_command;
    
        Device_init();
    
        DINT;
    
        Device_initGPIO();
    
        Interrupt_initModule();
        Interrupt_initVectorTable();
    
        board_gpio_init();
        motor_pwm_init();
    
        /*
         * 初始化为关闭状态。
         * 首次上电不额外等待1秒。
         */
        motor_stop();
        restart_lockout_ms = 0U;
    
        uart_init();
        control_timer_init();
    
        Interrupt_enableMaster();
    
        for (;;) {
    
            if (SCI_getRxFIFOStatus(SCIA_BASE) != SCI_FIFO_RX0) {
    
                rx_data =
                    SCI_readCharNonBlocking(SCIA_BASE) & 0x00FFU;
    
                valid_command = 1U;
                next_command = CMD_STOP;
    
                switch (rx_data) {
    
                    case '1':
                    case 'F':
                    case 'f':
                        next_command = CMD_FORWARD;
                        break;
    
                    case '2':
                    case 'B':
                    case 'b':
                        next_command = CMD_REVERSE;
                        break;
    
                    case '0':
                    case 'S':
                    case 's':
                        next_command = CMD_STOP;
                        break;
    
                    default:
                        valid_command = 0U;
                        break;
                }
    
                if (valid_command != 0U) {
    
                    /*
                     * 极短临界区:
                     * 保证命令值与命令序号一致地发布。
                     */
                    DINT;
    
                    command_value = next_command;
                    command_sequence++;
    
                    EINT;
                }
    
                /*
                 * 仅回显收到的字符,不表示命令一定已执行。
                 * FIFO满时跳过回显,避免阻塞。
                 */
                if (
                    SCI_getTxFIFOStatus(SCIA_BASE) != SCI_FIFO_TX16
                ) {
                    SCI_writeCharNonBlocking(SCIA_BASE, rx_data);
                }
            }
        }
    }

    可以平稳转动

    #2
  • admin
    #include "driverlib.h"
    #include "device.h"
    
    /*
     * F280049 + 2 x IR2302 + four-MOSFET H bridge
     *
     * GPIO24 -> IR2302 #1 IN (EPWM8A)
     * GPIO16 -> IR2302 #1 SD (high enables, low shuts down)
     * GPIO32 -> IR2302 #2 IN (EPWM8B)
     * GPIO11 -> IR2302 #2 SD
     * GPIO28 -> SCIA RX, GPIO29 -> SCIA TX
     * ADCINC0 -> conditioned analog input, nominal range 0...3.3 V
     * GPIO1 -> LED
     *
     * UART: 115200, 8N1
     * F/f/1: forward; B/b/2: reverse; S/s/0: stop
     * Opposite command while active only stops the motor. Send another
     * direction command after >=1 s AND after verifying the rotor is stopped.
     * No automatic restart after a rejected command.
     *
     * PWM approximately 35 kHz; ramp 2% -> 95% in 2 seconds.
     * ADCINC0 measures a conditioned COMMON LOW-SIDE SHUNT voltage.
     * ADC is triggered once per valid PWM cycle, near the middle of the
     * DIGITAL IN HIGH interval. Actual aperture occurs after ADC latency.
     * It measures on-state shunt voltage, not full-cycle motor-current mean.
     * 30 consecutive cycles form one non-overlapping average.
     * UART prints latest complete average every 200 ms, without scaling.
     * Stop/reversal discard partial averages. No sampling while stopped.
     * No current protection or speed feedback is implemented.
     */
    
    #define MOTOR_SD1_PIN             16U
    #define MOTOR_SD2_PIN             11U
    #define LED_PIN                   1U
    
    #define MOTOR_PWM_BASE            EPWM8_BASE
    #define MOTOR_PWM_FREQ_HZ         35000UL
    #define MOTOR_PWM_TBCLK_HZ        DEVICE_SYSCLK_FREQ
    #define MOTOR_PWM_PERIOD_COUNTS   \
        ((MOTOR_PWM_TBCLK_HZ + MOTOR_PWM_FREQ_HZ / 2UL) / \
          MOTOR_PWM_FREQ_HZ)
    #define MOTOR_PWM_TBPRD           \
        ((uint16_t)(MOTOR_PWM_PERIOD_COUNTS - 1UL))
    
    #define DUTY_FULL_SCALE           10000UL
    #define START_DUTY_BP             200U
    #define TARGET_DUTY_BP            9500U
    #define MAX_DUTY_BP               9500U
    #define CONTROL_FREQ_HZ           1000UL
    #define SOFT_START_TIME_MS        2000UL
    #define PRECHARGE_TIME_MS         5U
    #define RESTART_LOCKOUT_MS        1000U
    #define LED_TOGGLE_MS             500U
    
    #define VOLTAGE_REPORT_MS         200U
    #define ADC_AVERAGE_SAMPLES       30U
    /* Minimum digital IN-high elapsed time before the ADC trigger.
     * Initial tuning value only: verify IR2302 propagation/deadtime,
     * MOSFET switching and amplifier settling with an oscilloscope. */
    #define ADC_ON_BLANK_NS           2000UL
    #define ADC_SAMPLE_SYSCLK_CYCLES  64U
    #define ADC_ON_BLANK_TICKS        \
        ((MOTOR_PWM_TBCLK_HZ / 1000000UL * ADC_ON_BLANK_NS + 999UL) / 1000UL)
    
    /* Right-edge margin includes nominal ADC trigger latency allowance.
     * TBCLK must equal SYSCLK here; verify against the ACTUAL QX target.
     * 50 ticks is an initial allowance, not a validated hardware guarantee. */
    #define ADC_WINDOW_MARGIN_TICKS   50UL
    #define ADC_FULL_SCALE_MV         3300UL
    #define ADC_MAX_CODE              4095UL
    #define VOLTAGE_ADC_BASE          ADCC_BASE
    #define VOLTAGE_ADC_RESULT_BASE   ADCCRESULT_BASE
    
    #define CMD_STOP                  0U
    #define CMD_FORWARD               1U
    #define CMD_REVERSE               2U
    
    #define STATE_STOPPED             0U
    #define STATE_PRECHARGE           1U
    #define STATE_ARMED               2U
    #define STATE_RUNNING             3U
    
    #if TARGET_DUTY_BP < START_DUTY_BP
    #error Invalid_start_and_target_duty
    #endif
    #if TARGET_DUTY_BP > MAX_DUTY_BP
    #error Target_duty_exceeds_limit
    #endif
    
    static volatile uint16_t command_value = CMD_STOP;
    static volatile uint16_t command_sequence = 0U;
    static volatile uint16_t voltage_report_request = 0U;
    volatile uint16_t adc_average_valid = 0U;
    volatile uint16_t adc_window_ok = 0U;
    volatile uint16_t adc_average_raw = 0U;
    volatile uint16_t adc_overflow_count = 0U;
    volatile uint32_t adc_average_group_count = 0UL;
    static volatile uint32_t adc_sum = 0UL;
    static volatile uint16_t adc_sample_count = 0U;
    static volatile uint16_t adc_skip_samples = 0U;
    
    volatile uint16_t motor_state = STATE_STOPPED;
    volatile uint16_t motor_direction = CMD_STOP;
    volatile uint16_t current_duty_bp = 0U;
    volatile uint16_t restart_lockout_ms = 0U;
    volatile uint16_t command_rejected = 0U;
    volatile uint16_t voltage_adc_raw = 0U;
    volatile uint32_t voltage_c0_mv = 0UL;
    
    static uint16_t precharge_ms = 0U;
    static uint32_t ramp_accumulator = 0UL;
    /* Shared forward/reverse two-point empirical calibration.
     * 2968 mV -> 90.0 mA; 2744 mV -> 145.0 mA.
     * These are interval midpoints, not traceable reference measurements.
     * Units: voltage=mV, current=0.1mA. */
    #define CURRENT_CAL_V1_MV             2968L
    #define CURRENT_CAL_I1_TENTH_MA        900L
    #define CURRENT_CAL_V2_MV             2744L
    #define CURRENT_CAL_I2_TENTH_MA        1450L
    volatile int32_t current_est_tenth_ma = 0L;
    volatile uint16_t current_est_valid = 0U;
    
    static char voltage_tx_buffer[80];
    static uint16_t voltage_tx_length = 0U;
    static uint16_t voltage_tx_index = 0U;
    
    __interrupt void cpuTimer0ISR(void);
    __interrupt void adcc1ISR(void);
    
    static void adc_average_reset(void)
    {
        adc_sum = 0UL;
        adc_sample_count = 0U;
        adc_average_valid = 0U;
        adc_average_raw = 0U;
        adc_skip_samples = 2U;
    }
    
    
    static void gpio_output_low(uint32_t pin)
    {
        GPIO_writePin(pin, 0U);
        GPIO_setPadConfig(pin, GPIO_PIN_TYPE_STD);
        GPIO_setDirectionMode(pin, GPIO_DIR_MODE_OUT);
    }
    
    static void board_gpio_init(void)
    {
        /* Configure shutdown signals before bridge inputs. External SD
         * pulldowns must maintain shutdown before software initialization. */
        GPIO_setPinConfig(GPIO_16_GPIO16);
        GPIO_setPinConfig(GPIO_11_GPIO11);
        gpio_output_low(MOTOR_SD1_PIN);
        gpio_output_low(MOTOR_SD2_PIN);
    
        GPIO_setPinConfig(GPIO_24_GPIO24);
        GPIO_setPinConfig(GPIO_32_GPIO32);
        gpio_output_low(24U);
        gpio_output_low(32U);
    
        GPIO_setPinConfig(GPIO_1_GPIO1);
        gpio_output_low(LED_PIN);
    }
    
    static void uart_init(void)
    {
        SysCtl_enablePeripheral(SYSCTL_PERIPH_CLK_SCIA);
        GPIO_setPinConfig(GPIO_28_SCIA_RX);
        GPIO_setPinConfig(GPIO_29_SCIA_TX);
        GPIO_setPadConfig(28U, GPIO_PIN_TYPE_STD);
        GPIO_setPadConfig(29U, GPIO_PIN_TYPE_STD);
        GPIO_setQualificationMode(28U, GPIO_QUAL_ASYNC);
    
        SCI_disableModule(SCIA_BASE);
        SCI_setConfig(SCIA_BASE, DEVICE_LSPCLK_FREQ, 115200UL,
                      SCI_CONFIG_WLEN_8 | SCI_CONFIG_STOP_ONE |
                      SCI_CONFIG_PAR_NONE);
        SCI_enableFIFO(SCIA_BASE);
        SCI_resetTxFIFO(SCIA_BASE);
        SCI_resetRxFIFO(SCIA_BASE);
        SCI_resetChannels(SCIA_BASE);
        SCI_enableModule(SCIA_BASE);
        SCI_performSoftwareReset(SCIA_BASE);
    }
    
    static inline void pwm_force_both_low(void)
    {
        EPWM_setActionQualifierContSWForceAction(
            MOTOR_PWM_BASE, EPWM_AQ_OUTPUT_A, EPWM_AQ_SW_OUTPUT_LOW);
        EPWM_setActionQualifierContSWForceAction(
            MOTOR_PWM_BASE, EPWM_AQ_OUTPUT_B, EPWM_AQ_SW_OUTPUT_LOW);
    }
    
    static void motor_pwm_init(void)
    {
        SysCtl_enablePeripheral(SYSCTL_PERIPH_CLK_EPWM8);
        /* TBCLKSYNC affects all ePWM modules. This is a standalone example. */
        SysCtl_disablePeripheral(SYSCTL_PERIPH_CLK_TBCLKSYNC);
    
        EPWM_setTimeBaseCounterMode(MOTOR_PWM_BASE,
                                   EPWM_COUNTER_MODE_STOP_FREEZE);
        EPWM_setClockPrescaler(MOTOR_PWM_BASE, EPWM_CLOCK_DIVIDER_1,
                               EPWM_HSCLOCK_DIVIDER_1);
        EPWM_disablePhaseShiftLoad(MOTOR_PWM_BASE);
        EPWM_setPhaseShift(MOTOR_PWM_BASE, 0U);
        EPWM_setPeriodLoadMode(MOTOR_PWM_BASE, EPWM_PERIOD_DIRECT_LOAD);
        EPWM_setTimeBasePeriod(MOTOR_PWM_BASE, MOTOR_PWM_TBPRD);
        EPWM_setTimeBaseCounter(MOTOR_PWM_BASE, 0U);
    
        EPWM_setCounterCompareShadowLoadMode(
            MOTOR_PWM_BASE, EPWM_COUNTER_COMPARE_A,
            EPWM_COMP_LOAD_ON_CNTR_ZERO);
        EPWM_setCounterCompareValue(MOTOR_PWM_BASE,
                                   EPWM_COUNTER_COMPARE_A, 1U);
    
        EPWM_setCounterCompareShadowLoadMode(
            MOTOR_PWM_BASE, EPWM_COUNTER_COMPARE_B,
            EPWM_COMP_LOAD_ON_CNTR_ZERO);
        EPWM_setCounterCompareValue(MOTOR_PWM_BASE,
                                   EPWM_COUNTER_COMPARE_B,
                                   1U);
    
        /* Commit CMPA and CMPB together at ZERO. Without this, a ZERO
         * between two CPU writes could mix old duty and new ADC timing. */
        EPWM_enableGlobalLoadRegisters(
            MOTOR_PWM_BASE,
            EPWM_GL_REGISTER_CMPA_CMPAHR | EPWM_GL_REGISTER_CMPB_CMPBHR);
        EPWM_setGlobalLoadTrigger(MOTOR_PWM_BASE,
                                 EPWM_GL_LOAD_PULSE_CNTR_ZERO);
        EPWM_setGlobalLoadEventPrescale(MOTOR_PWM_BASE, 1U);
        EPWM_enableGlobalLoadOneShotMode(MOTOR_PWM_BASE);
        EPWM_enableGlobalLoad(MOTOR_PWM_BASE);
        EPWM_setGlobalLoadOneShotLatch(MOTOR_PWM_BASE);
    
        EPWM_disableADCTrigger(MOTOR_PWM_BASE, EPWM_SOC_A);
        EPWM_setADCTriggerSource(MOTOR_PWM_BASE, EPWM_SOC_A,
                                 EPWM_SOC_TBCTR_U_CMPB);
        EPWM_setADCTriggerEventPrescale(MOTOR_PWM_BASE, EPWM_SOC_A, 1U);
        EPWM_clearADCTriggerFlag(MOTOR_PWM_BASE, EPWM_SOC_A);
    
        /* Same base waveform on A and B. Only the selected direction's
         * output is released; the other remains forced low. */
        EPWM_setActionQualifierAction(
            MOTOR_PWM_BASE, EPWM_AQ_OUTPUT_A, EPWM_AQ_OUTPUT_HIGH,
            EPWM_AQ_OUTPUT_ON_TIMEBASE_ZERO);
        EPWM_setActionQualifierAction(
            MOTOR_PWM_BASE, EPWM_AQ_OUTPUT_A, EPWM_AQ_OUTPUT_LOW,
            EPWM_AQ_OUTPUT_ON_TIMEBASE_UP_CMPA);
        EPWM_setActionQualifierAction(
            MOTOR_PWM_BASE, EPWM_AQ_OUTPUT_B, EPWM_AQ_OUTPUT_HIGH,
            EPWM_AQ_OUTPUT_ON_TIMEBASE_ZERO);
        EPWM_setActionQualifierAction(
            MOTOR_PWM_BASE, EPWM_AQ_OUTPUT_B, EPWM_AQ_OUTPUT_LOW,
            EPWM_AQ_OUTPUT_ON_TIMEBASE_UP_CMPA);
    
        /* Each IR2302 internally drives one half bridge with its own
         * deadtime. EPWM8A/B are inputs to DIFFERENT half bridges. */
        EPWM_setDeadBandDelayMode(MOTOR_PWM_BASE, EPWM_DB_RED, false);
        EPWM_setDeadBandDelayMode(MOTOR_PWM_BASE, EPWM_DB_FED, false);
        EPWM_setActionQualifierContSWForceShadowMode(
            MOTOR_PWM_BASE, EPWM_AQ_SW_IMMEDIATE_LOAD);
        pwm_force_both_low();
    
        GPIO_setPinConfig(GPIO_24_EPWM8_A);
        GPIO_setPinConfig(GPIO_32_EPWM8_B);
        EPWM_setTimeBaseCounterMode(MOTOR_PWM_BASE, EPWM_COUNTER_MODE_UP);
        SysCtl_enablePeripheral(SYSCTL_PERIPH_CLK_TBCLKSYNC);
    }
    
    static inline void motor_set_duty_bp(uint16_t duty_bp)
    {
        uint32_t compare;
        uint32_t sample_compare;
    
        if (duty_bp > MAX_DUTY_BP) {
            duty_bp = MAX_DUTY_BP;
        }
        compare = ((uint32_t)MOTOR_PWM_PERIOD_COUNTS * duty_bp +
                   DUTY_FULL_SCALE / 2UL) / DUTY_FULL_SCALE;
        if (compare < 1UL) {
            compare = 1UL;
        }
        if (compare >= MOTOR_PWM_PERIOD_COUNTS) {
            compare = MOTOR_PWM_PERIOD_COUNTS - 1UL;
        }
        /* Trigger at the midpoint of the DIGITAL IN HIGH interval.
         * This is a trigger midpoint, not a compensated aperture midpoint.
         * Reserve acquisition time and right-edge guard before IN falls. */
        sample_compare = compare / 2UL;
    
        if ((sample_compare >= ADC_ON_BLANK_TICKS) &&
            ((sample_compare + ADC_SAMPLE_SYSCLK_CYCLES +
              ADC_WINDOW_MARGIN_TICKS) < compare)) {
            if (adc_window_ok == 0U) {
                adc_average_reset();
            }
            adc_window_ok = 1U;
        } else {
            EPWM_disableADCTrigger(MOTOR_PWM_BASE, EPWM_SOC_A);
            adc_window_ok = 0U;
            adc_average_reset();
        }
    
        EPWM_setCounterCompareValue(MOTOR_PWM_BASE,
                                   EPWM_COUNTER_COMPARE_A,
                                   (uint16_t)compare);
        EPWM_setCounterCompareValue(MOTOR_PWM_BASE,
                                   EPWM_COUNTER_COMPARE_B,
                                   adc_window_ok ?
                                   (uint16_t)sample_compare : 1U);
        EPWM_setGlobalLoadOneShotLatch(MOTOR_PWM_BASE);
    
        if ((adc_window_ok != 0U) && (motor_state == STATE_RUNNING)) {
            EPWM_enableADCTrigger(MOTOR_PWM_BASE, EPWM_SOC_A);
        }
    }
    
    static void motor_stop(void)
    {
        EPWM_disableADCTrigger(MOTOR_PWM_BASE, EPWM_SOC_A);
        adc_average_reset();
        adc_window_ok = 0U;
        GPIO_writePin(MOTOR_SD1_PIN, 0U);
        GPIO_writePin(MOTOR_SD2_PIN, 0U);
        pwm_force_both_low();
    
        motor_state = STATE_STOPPED;
        motor_direction = CMD_STOP;
        current_duty_bp = 0U;
        precharge_ms = 0U;
        ramp_accumulator = 0UL;
        restart_lockout_ms = RESTART_LOCKOUT_MS;
    }
    
    static void motor_start_precharge(uint16_t direction)
    {
        EPWM_disableADCTrigger(MOTOR_PWM_BASE, EPWM_SOC_A);
        adc_average_reset();
        adc_window_ok = 0U;
        GPIO_writePin(MOTOR_SD1_PIN, 0U);
        GPIO_writePin(MOTOR_SD2_PIN, 0U);
        pwm_force_both_low();
    
        motor_direction = direction;
        current_duty_bp = 0U;
        precharge_ms = 0U;
        ramp_accumulator = 0UL;
    
        /* Both low-side MOSFETs conduct during precharge.
         * The rotor MUST be stopped before starting. */
        GPIO_writePin(MOTOR_SD1_PIN, 1U);
        GPIO_writePin(MOTOR_SD2_PIN, 1U);
        motor_state = STATE_PRECHARGE;
    }
    
    static void motor_process_command(uint16_t command)
    {
        if (command == CMD_STOP) {
            if (motor_state != STATE_STOPPED) {
                motor_stop();
            }
            return;
        }
        if ((command != CMD_FORWARD) && (command != CMD_REVERSE)) {
            return;
        }
        if (motor_state != STATE_STOPPED) {
            if (command != motor_direction) {
                motor_stop();
                command_rejected = 1U;
            }
            return;
        }
        if (restart_lockout_ms != 0U) {
            command_rejected = 1U;
            return;
        }
        command_rejected = 0U;
        motor_start_precharge(command);
    }
    
    /* ==================== ADCINC0 ==================== */
    
    static void voltage_adc_init(void)
    {
        SysCtl_enablePeripheral(SYSCTL_PERIPH_CLK_ADCC);
    
        /* Assumes the board permits INTERNAL reference operation.
         * Do not use this setting if an external reference is connected
         * without first checking the board schematic/reference design. */
        ADC_setVREF(VOLTAGE_ADC_BASE, ADC_REFERENCE_INTERNAL,
                    ADC_REFERENCE_3_3V);
        ADC_setPrescaler(VOLTAGE_ADC_BASE, ADC_CLK_DIV_4_0);
        ADC_setInterruptPulseMode(VOLTAGE_ADC_BASE,
                                 ADC_PULSE_END_OF_CONV);
        ADC_enableConverter(VOLTAGE_ADC_BASE);
        DEVICE_DELAY_US(1000U);
    
        /* ADCC channel 0 = ADCINC0, not GPIO0.
         * Hardware trigger: ePWM8 SOCA at CMPB = CMPA / 2.
         * Valid only when on-state blanking and acquisition guards fit. */
        ADC_setupSOC(VOLTAGE_ADC_BASE, ADC_SOC_NUMBER0,
                     ADC_TRIGGER_EPWM8_SOCA, ADC_CH_ADCIN0,
                     ADC_SAMPLE_SYSCLK_CYCLES);
        ADC_setInterruptSource(VOLTAGE_ADC_BASE, ADC_INT_NUMBER1,
                               ADC_SOC_NUMBER0);
        ADC_disableContinuousMode(VOLTAGE_ADC_BASE, ADC_INT_NUMBER1);
        ADC_enableInterrupt(VOLTAGE_ADC_BASE, ADC_INT_NUMBER1);
        ADC_clearInterruptStatus(VOLTAGE_ADC_BASE, ADC_INT_NUMBER1);
        ADC_clearInterruptOverflowStatus(VOLTAGE_ADC_BASE,
                                         ADC_INT_NUMBER1);
        Interrupt_register(INT_ADCC1, &adcc1ISR);
        Interrupt_enable(INT_ADCC1);
    }
    
    /* ADC ISR: one sample per PWM cycle, approximately 35k ISR/s.
     * Keep it short. No UART, formatting or mV conversion here.
     * ISR nesting is not enabled; Timer0 cannot interrupt this ISR. */
    __interrupt void adcc1ISR(void)
    {
        uint16_t raw = ADC_readResult(VOLTAGE_ADC_RESULT_BASE,
                                      ADC_SOC_NUMBER0);
        uint16_t overflow = ADC_getInterruptOverflowStatus(
                                VOLTAGE_ADC_BASE, ADC_INT_NUMBER1);
    
        ADC_clearInterruptStatus(VOLTAGE_ADC_BASE, ADC_INT_NUMBER1);
    
        if (overflow != 0U) {
            adc_overflow_count++;
            adc_average_reset();
            ADC_clearInterruptOverflowStatus(VOLTAGE_ADC_BASE,
                                             ADC_INT_NUMBER1);
            ADC_clearInterruptStatus(VOLTAGE_ADC_BASE, ADC_INT_NUMBER1);
        } else if ((motor_state == STATE_RUNNING) &&
                   (adc_window_ok != 0U)) {
            voltage_adc_raw = raw;
            if (adc_skip_samples > 0U) {
                /* Discard startup partial cycles after PWM force release. */
                adc_skip_samples--;
            } else {
                adc_sum += (uint32_t)raw;
                adc_sample_count++;
                if (adc_sample_count >= ADC_AVERAGE_SAMPLES) {
                    adc_average_raw = (uint16_t)(
                        (adc_sum + ADC_AVERAGE_SAMPLES / 2U) /
                        ADC_AVERAGE_SAMPLES);
                    adc_average_valid = 1U;
                    adc_average_group_count++;
                    adc_sum = 0UL;
                    adc_sample_count = 0U;
                }
            }
        }
    
        Interrupt_clearACKGroup(INTERRUPT_ACK_GROUP1);
    }
    
    static void voltage_queue_text(const char *text)
    {
        uint16_t n = 0U;
        if (voltage_tx_index < voltage_tx_length) {
            return;
        }
        while ((text[n] != '\0') &&
               (n < (uint16_t)(sizeof(voltage_tx_buffer) - 1U))) {
            voltage_tx_buffer[n] = text[n];
            n++;
        }
        voltage_tx_index = 0U;
        voltage_tx_length = n;
    }
    
    /* Integer-only signed decimal formatting into the main-loop TX buffer. */
    static void voltage_append_text(uint16_t *n, const char *text)
    {
        while (*text != '\0') {
            voltage_tx_buffer[(*n)++] = *text++;
        }
    }
    
    static void voltage_append_uint(uint16_t *n, uint32_t value)
    {
        char digits[10];
        uint16_t count = 0U;
        do {
            digits[count++] = (char)('0' + value % 10UL);
            value /= 10UL;
        } while (value != 0UL);
        while (count != 0U) {
            voltage_tx_buffer[(*n)++] = digits[--count];
        }
    }
    
    static int32_t current_from_mv(uint32_t mv)
    {
        int32_t numerator;
        int32_t denominator = CURRENT_CAL_V1_MV - CURRENT_CAL_V2_MV;
        numerator = (CURRENT_CAL_V1_MV - (int32_t)mv) *
                    (CURRENT_CAL_I2_TENTH_MA - CURRENT_CAL_I1_TENTH_MA);
        /* Round the signed correction to nearest 0.1mA. */
        if (numerator >= 0L) {
            numerator += denominator / 2L;
        } else {
            numerator -= denominator / 2L;
        }
        return CURRENT_CAL_I1_TENTH_MA + numerator / denominator;
    }
    
    static void voltage_task(void)
    {
        uint16_t report;
        uint16_t valid;
        uint16_t raw;
        uint16_t state;
        uint16_t window_ok;
        uint16_t direction;
        uint16_t n;
        uint32_t mv;
        int32_t current;
        uint32_t magnitude;
    
        /* Snapshot shared data; keep this critical section very short. */
        DINT;
        report = voltage_report_request;
        voltage_report_request = 0U;
        valid = adc_average_valid;
        raw = adc_average_raw;
        state = motor_state;
        window_ok = adc_window_ok;
        direction = motor_direction;
        EINT;
    
        if (report == 0U) {
            return;
        }
        current_est_valid = 0U;
        if (state != STATE_RUNNING) {
            voltage_queue_text("C0: STOPPED / PRECHARGE\r\n");
            return;
        }
        if (window_ok == 0U) {
            voltage_queue_text("C0: ON WINDOW TOO SHORT\r\n");
            return;
        }
        if (valid == 0U) {
            voltage_queue_text("C0: WAIT ADC AVG\r\n");
            return;
        }
        if (voltage_tx_index < voltage_tx_length) {
            return;
        }
    
        mv = ((uint32_t)raw * ADC_FULL_SCALE_MV + ADC_MAX_CODE / 2UL) /
             ADC_MAX_CODE;
        voltage_c0_mv = mv;
    
        /* No printf runtime is required.
         * Output: C0_AVG30=1.650 V ADC=2048 */
        n = 0U;
        voltage_tx_buffer[n++] = 'C';
        voltage_tx_buffer[n++] = '0';
        voltage_tx_buffer[n++] = '_';
        voltage_tx_buffer[n++] = 'A';
        voltage_tx_buffer[n++] = 'V';
        voltage_tx_buffer[n++] = 'G';
        voltage_tx_buffer[n++] = '3';
        voltage_tx_buffer[n++] = '0';
        voltage_tx_buffer[n++] = '=';
        voltage_tx_buffer[n++] = (char)('0' + mv / 1000UL);
        voltage_tx_buffer[n++] = '.';
        voltage_tx_buffer[n++] = (char)('0' + (mv / 100UL) % 10UL);
        voltage_tx_buffer[n++] = (char)('0' + (mv / 10UL) % 10UL);
        voltage_tx_buffer[n++] = (char)('0' + mv % 10UL);
        voltage_tx_buffer[n++] = ' ';
        voltage_tx_buffer[n++] = 'V';
    
        /* Same empirical current-magnitude calibration for both directions. */
        current = current_from_mv(mv);
        current_est_tenth_ma = current;
        current_est_valid = 1U;
        voltage_append_text(&n, " I_est=");
        if (current < 0L) {
            voltage_tx_buffer[n++] = '-';
            magnitude = (uint32_t)(-current);
        } else {
            magnitude = (uint32_t)current;
        }
        voltage_append_uint(&n, magnitude / 10UL);
        voltage_tx_buffer[n++] = '.';
        voltage_tx_buffer[n++] = (char)('0' + magnitude % 10UL);
        voltage_append_text(&n, "mA DIR=");
        voltage_tx_buffer[n++] = (direction == CMD_FORWARD) ? 'F' : 'B';
    
        voltage_tx_buffer[n++] = ' ';
        voltage_tx_buffer[n++] = 'A';
        voltage_tx_buffer[n++] = 'D';
        voltage_tx_buffer[n++] = 'C';
        voltage_tx_buffer[n++] = '=';
        voltage_tx_buffer[n++] = (char)('0' + raw / 1000U);
        voltage_tx_buffer[n++] = (char)('0' + (raw / 100U) % 10U);
        voltage_tx_buffer[n++] = (char)('0' + (raw / 10U) % 10U);
        voltage_tx_buffer[n++] = (char)('0' + raw % 10U);
        voltage_tx_buffer[n++] = '\r';
        voltage_tx_buffer[n++] = '\n';
        voltage_tx_index = 0U;
        voltage_tx_length = n;
    }
    
    static void voltage_uart_task(void)
    {
        while (voltage_tx_index < voltage_tx_length) {
            if (SCI_getTxFIFOStatus(SCIA_BASE) == SCI_FIFO_TX16) {
                break;
            }
            SCI_writeCharNonBlocking(
                SCIA_BASE,
                (uint16_t)voltage_tx_buffer[voltage_tx_index]);
            voltage_tx_index++;
        }
    }
    
    /* ==================== 1 ms motor/control tick ==================== */
    
    __interrupt void cpuTimer0ISR(void)
    {
        static uint16_t handled_sequence = 0U;
        static uint16_t led_ms = 0U;
        static uint16_t voltage_report_tick = 0U;
        uint16_t sequence;
    
        if (restart_lockout_ms > 0U) {
            restart_lockout_ms--;
        }
    
        sequence = command_sequence;
        if (sequence != handled_sequence) {
            handled_sequence = sequence;
            motor_process_command(command_value);
        }
    
        switch (motor_state) {
        case STATE_STOPPED:
            break;
    
        case STATE_PRECHARGE:
            precharge_ms++;
            if (precharge_ms >= PRECHARGE_TIME_MS) {
                current_duty_bp = START_DUTY_BP;
                ramp_accumulator = 0UL;
                motor_set_duty_bp(current_duty_bp);
                motor_state = STATE_ARMED;
            }
            break;
    
        case STATE_ARMED:
            /* One extra control tick permits CMPA shadow loading.
             * Releasing software force may create a shortened first pulse. */
            if (motor_direction == CMD_FORWARD) {
                EPWM_setActionQualifierContSWForceAction(
                    MOTOR_PWM_BASE, EPWM_AQ_OUTPUT_B,
                    EPWM_AQ_SW_OUTPUT_LOW);
                EPWM_setActionQualifierContSWForceAction(
                    MOTOR_PWM_BASE, EPWM_AQ_OUTPUT_A,
                    EPWM_AQ_SW_DISABLED);
            } else if (motor_direction == CMD_REVERSE) {
                EPWM_setActionQualifierContSWForceAction(
                    MOTOR_PWM_BASE, EPWM_AQ_OUTPUT_A,
                    EPWM_AQ_SW_OUTPUT_LOW);
                EPWM_setActionQualifierContSWForceAction(
                    MOTOR_PWM_BASE, EPWM_AQ_OUTPUT_B,
                    EPWM_AQ_SW_DISABLED);
            } else {
                motor_stop();
                break;
            }
            motor_state = STATE_RUNNING;
            adc_average_reset();
            ADC_clearInterruptStatus(VOLTAGE_ADC_BASE, ADC_INT_NUMBER1);
            ADC_clearInterruptOverflowStatus(VOLTAGE_ADC_BASE,
                                             ADC_INT_NUMBER1);
            EPWM_clearADCTriggerFlag(MOTOR_PWM_BASE, EPWM_SOC_A);
            if (adc_window_ok != 0U) {
                EPWM_enableADCTrigger(MOTOR_PWM_BASE, EPWM_SOC_A);
            }
            break;
    
        case STATE_RUNNING:
            if (current_duty_bp < TARGET_DUTY_BP) {
                ramp_accumulator +=
                    (uint32_t)TARGET_DUTY_BP - (uint32_t)START_DUTY_BP;
                while (ramp_accumulator >= SOFT_START_TIME_MS) {
                    ramp_accumulator -= SOFT_START_TIME_MS;
                    if (current_duty_bp < TARGET_DUTY_BP) {
                        current_duty_bp++;
                    }
                }
                motor_set_duty_bp(current_duty_bp);
            }
            break;
    
        default:
            motor_stop();
            break;
        }
    
        led_ms++;
        if (led_ms >= LED_TOGGLE_MS) {
            led_ms = 0U;
            GPIO_togglePin(LED_PIN);
        }
    
        /* Only set a request here. Never format or print in this ISR. */
        voltage_report_tick++;
        if (voltage_report_tick >= VOLTAGE_REPORT_MS) {
            voltage_report_tick = 0U;
            voltage_report_request = 1U;
        }
    
        CPUTimer_clearOverflowFlag(CPUTIMER0_BASE);
        Interrupt_clearACKGroup(INTERRUPT_ACK_GROUP1);
    }
    
    static void control_timer_init(void)
    {
        CPUTimer_stopTimer(CPUTIMER0_BASE);
        CPUTimer_setPreScaler(CPUTIMER0_BASE, 0U);
        CPUTimer_setPeriod(CPUTIMER0_BASE,
                          (DEVICE_SYSCLK_FREQ / CONTROL_FREQ_HZ) - 1UL);
        CPUTimer_reloadTimerCounter(CPUTIMER0_BASE);
        CPUTimer_clearOverflowFlag(CPUTIMER0_BASE);
        Interrupt_register(INT_TIMER0, &cpuTimer0ISR);
        CPUTimer_enableInterrupt(CPUTIMER0_BASE);
        Interrupt_enable(INT_TIMER0);
        CPUTimer_startTimer(CPUTIMER0_BASE);
    }
    
    /* ==================== Main ==================== */
    
    int main(void)
    {
        uint16_t rx_data;
        uint16_t next_command;
        uint16_t valid_command;
    
        Device_init();
        DINT;
        Device_initGPIO();
        Interrupt_initModule();
        Interrupt_initVectorTable();
    
        board_gpio_init();
        motor_pwm_init();
        motor_stop();
        restart_lockout_ms = 0U;
    
        uart_init();
        {
            const char *boot = "\r\nPWM SHUNT ADC AVG30 READY\r\n";
            while (*boot != '\0') {
                SCI_writeCharBlockingFIFO(SCIA_BASE, (uint16_t)*boot);
                boot++;
            }
        }
        voltage_adc_init();
        control_timer_init();
        Interrupt_enableMaster();
    
        for (;;) {
            if (SCI_getRxFIFOStatus(SCIA_BASE) != SCI_FIFO_RX0) {
                rx_data = SCI_readCharNonBlocking(SCIA_BASE) & 0x00FFU;
                valid_command = 1U;
                next_command = CMD_STOP;
    
                switch (rx_data) {
                case '1':
                case 'F':
                case 'f':
                    next_command = CMD_FORWARD;
                    break;
                case '2':
                case 'B':
                case 'b':
                    next_command = CMD_REVERSE;
                    break;
                case '0':
                case 'S':
                case 's':
                    next_command = CMD_STOP;
                    break;
                default:
                    valid_command = 0U;
                    break;
                }
    
                if (valid_command != 0U) {
                    DINT;
                    command_value = next_command;
                    command_sequence++;
                    EINT;
                }
                /* No character echo: keep voltage lines intact. */
            }
    
            voltage_task();
            voltage_uart_task();
        }
    }

    可转 可以显示 电流

    #3

发表回复

登录后回复