- admin16小时前管理员1
#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); } } }主楼 - admin16小时前管理员1
#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); } } }添加了软启动。
- admin11小时前管理员1
#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); } } } }可以平稳转动
- admin10小时前管理员1
#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(); } }可转 可以显示 电流