yuwenhao
/
Modbus-rtu
1
0
Forka 0
Codice Problemi 0 Pull Requests 0 Rilasci 0 Wiki Attività
Non puoi selezionare più di 25 argomenti Gli argomenti devono iniziare con una lettera o un numero, possono includere trattini ('-') e possono essere lunghi fino a 35 caratteri.
37 Commit
3 Rami (Branch)
138 MiB
 
 
 
 
 
 
Albero (Tree): 0b7990bc99
Rami (Branch) Tag
${ item.name }
Crea branch ${ searchTerm }
da '0b7990bc99'
${ noResults }
Modbus-rtu/PLSR/Src/plsr_hal_f407.c

1368 righe
38 KiB
Originale Blame Cronologia 

  1. #include "plsr_hal_f407.h"

  2. #include "plsr_address_map.h"

  3. #include "plsr_core.h"

  4. #include "plsr_job.h"

  5. #include <string.h>

  6. 

  7. #ifndef PLSR_HOST_TEST

  8. #include "stm32f4xx.h"

  9. #include "stm32f4xx_hal.h"

  10. #endif

  11. 

  12. #define PLSR_HW_TIMER_CHANNEL1_BIT    (0x0001U)

  13. #define PLSR_HW_TIMER_UPDATE_BIT      (0x0001U)

  14. #define PLSR_HW_TIMER_CC1_BIT         (0x0002U)

  15. #define PLSR_HW_OUTPUT_POINT_COUNT    (21U)

  16. #define PLSR_HW_DBG_SNAPSHOT_COUNT    (160U)

  17. #define PLSR_HW_AB_QUARTER_COUNT      (4U)

  18. 

  19. typedef struct

  20. {

  21.     uint32_t timerClockHz;

  22.     uint8_t directionPoint;         /* 0xFF = 无 */

  23. #ifndef PLSR_HOST_TEST

  24.     TIM_TypeDef *timer;

  25.     GPIO_TypeDef *gpioPort;

  26.     uint16_t gpioPin;

  27.     uint8_t afMode;

  28.     IRQn_Type irq;

  29. #endif

  30. } PLSR_HW_AXIS_MAP;

  31. 

  32. #ifndef PLSR_HOST_TEST

  33. /* 输出点（Y 点号）→ GPIO 引脚：XDM-60T4-E 原理图。

  34.  * 点号 8/9/18/19 不存在（资源层掩码 0x0013FCFF 已约束）。 */

  35. typedef struct

  36. {

  37.     GPIO_TypeDef *port;

  38.     uint16_t pin;

  39. } PLSR_HW_OUTPUT_PIN;

  40. 

  41. static const PLSR_HW_OUTPUT_PIN PlsrHwOutputPins[PLSR_HW_OUTPUT_POINT_COUNT] =

  42. {

  43.     {GPIOF, GPIO_PIN_6},   /* Y0  */

  44.     {GPIOF, GPIO_PIN_8},   /* Y1  */

  45.     {GPIOF, GPIO_PIN_7},   /* Y2  */

  46.     {GPIOF, GPIO_PIN_9},   /* Y3  */

  47.     {GPIOI, GPIO_PIN_8},   /* Y4  */

  48.     {GPIOE, GPIO_PIN_6},   /* Y5  */

  49.     {GPIOE, GPIO_PIN_5},   /* Y6  */

  50.     {GPIOE, GPIO_PIN_4},   /* Y7  */

  51.     {NULL, 0U},            /* Y8  */

  52.     {NULL, 0U},            /* Y9  */

  53.     {GPIOG, GPIO_PIN_7},   /* Y10 */

  54.     {GPIOG, GPIO_PIN_6},   /* Y11 */

  55.     {GPIOH, GPIO_PIN_9},   /* Y12 */

  56.     {GPIOH, GPIO_PIN_8},   /* Y13 */

  57.     {GPIOH, GPIO_PIN_7},   /* Y14 */

  58.     {GPIOH, GPIO_PIN_6},   /* Y15 */

  59.     {GPIOF, GPIO_PIN_11},  /* Y16 */

  60.     {GPIOB, GPIO_PIN_0},   /* Y17 */

  61.     {NULL, 0U},            /* Y18 */

  62.     {NULL, 0U},            /* Y19 */

  63.     {GPIOH, GPIO_PIN_5}    /* Y20 */

  64. };

  65. #endif

  66. 

  67. /* Q0~Q3 定时器：XDM-60T4-E。

  68.  * PF6=TIM10_CH1(AF3)、PF7=TIM11_CH1(AF3)、PF8=TIM13_CH1(AF9)、PF9=TIM14_CH1(AF9)。

  69.  * 定时器时钟由 RCC 实际配置计算（APB2 分频≠1 时定时器时钟×2）。 */

  70. static const PLSR_HW_AXIS_MAP PlsrHwAxisMap[PLSR_HW_AXIS_COUNT] =

  71. {

  72. #ifndef PLSR_HOST_TEST

  73.     {168000000UL, PLSR_HW_DIR_POINT_NONE, TIM10, GPIOF, GPIO_PIN_6, 3U, TIM1_UP_TIM10_IRQn},

  74.     {84000000UL, PLSR_HW_DIR_POINT_NONE, TIM13, GPIOF, GPIO_PIN_8, 9U, TIM8_UP_TIM13_IRQn},

  75.     {168000000UL, PLSR_HW_DIR_POINT_NONE, TIM11, GPIOF, GPIO_PIN_7, 3U, TIM1_TRG_COM_TIM11_IRQn},

  76.     {84000000UL, PLSR_HW_DIR_POINT_NONE, TIM14, GPIOF, GPIO_PIN_9, 9U, TIM8_TRG_COM_TIM14_IRQn}

  77. #else

  78.     {168000000UL, PLSR_HW_DIR_POINT_NONE},

  79.     {84000000UL, PLSR_HW_DIR_POINT_NONE},

  80.     {168000000UL, PLSR_HW_DIR_POINT_NONE},

  81.     {84000000UL, PLSR_HW_DIR_POINT_NONE}

  82. #endif

  83. };

  84. 

  85. #ifndef PLSR_HOST_TEST

  86. static const uint8_t PlsrHwPulsePinIndex[PLSR_HW_AXIS_COUNT] =

  87. {

  88.     6U, 8U, 7U, 9U

  89. };

  90. 

  91. /* 重定相期间由 GPIO 直接保持物理输出低电平。AFR 配置保持不变，

  92.  * 只切换 MODER，因此恢复定时器复用功能只需一次寄存器写入。 */

  93. static void PlsrHwHoldPulsePinLow(uint8_t axis)

  94. {

  95.     GPIO_TypeDef *port = PlsrHwAxisMap[axis].gpioPort;

  96.     uint32_t shift = (uint32_t)PlsrHwPulsePinIndex[axis] * 2UL;

  97.     uint32_t moder;

  98. 

  99.     port->BSRR = (uint32_t)PlsrHwAxisMap[axis].gpioPin << 16U;

  100.     moder = port->MODER;

  101.     moder &= ~(3UL << shift);

  102.     moder |= 1UL << shift;

  103.     port->MODER = moder;

  104.     __DMB();

  105. }

  106. 

  107. static void PlsrHwReleasePulsePin(uint8_t axis)

  108. {

  109.     GPIO_TypeDef *port = PlsrHwAxisMap[axis].gpioPort;

  110.     uint32_t shift = (uint32_t)PlsrHwPulsePinIndex[axis] * 2UL;

  111.     uint32_t moder = port->MODER;

  112. 

  113.     moder &= ~(3UL << shift);

  114.     moder |= 2UL << shift;

  115.     port->MODER = moder;

  116.     __DMB();

  117. }

  118. #endif

  119. 

  120. /* host 测试：模拟定时器寄存器。 */

  121. #ifdef PLSR_HOST_TEST

  122. typedef struct

  123. {

  124.     uint32_t cr1;

  125.     uint32_t dier;

  126.     uint32_t sr;

  127.     uint32_t psc;

  128.     uint32_t arr;

  129.     uint32_t ccr1;

  130.     uint32_t cnt;

  131.     uint32_t ccmr1;

  132.     uint32_t ccer;

  133.     uint8_t dirLevel;

  134. } PLSR_HW_TIMER_REGS;

  135. 

  136. static PLSR_HW_TIMER_REGS PlsrHwTimers[PLSR_HW_AXIS_COUNT];

  137. #endif

  138. 

  139. typedef struct

  140. {

  141.     PLSR_HW_STATE state;

  142.     PLSR_OUTPUT_MODE outputMode;

  143.     uint32_t currentFrequencyHz;

  144.     int64_t targetPulses;

  145.     int64_t emittedPulses;

  146.     uint16_t directionDelayRemainingMs;

  147.     uint8_t directionPoint;

  148.     uint8_t directionPositive;

  149.     uint8_t abQuarter;

  150.     uint8_t abCountAxis;

  151.     uint16_t abActiveBasePsc;

  152.     uint16_t abActivePairPsc;

  153.     uint16_t abActiveArr;

  154.     uint16_t abPendingBasePsc;

  155.     uint16_t abPendingPairPsc;

  156.     uint16_t abPendingArr;

  157.     uint8_t abFrequencyPending;

  158. } PLSR_HW_AXIS_STATE;

  159. 

  160. static PLSR_HW_AXIS_STATE PlsrHwAxes[PLSR_HW_AXIS_COUNT];

  161. 

  162. /* 调试快照：当前上板自测只记录 Q0 的 160 ms，避免四轴

  163.  * PlsrHwTick 互相混入，同时控制临时 RAM 占用。reason=0 表示段启动，

  164.  * reason=3 表示 1 ms HAL tick，reason=4 表示 AB 在 00 边界换频重定相。 */

  165. #ifndef PLSR_HOST_TEST

  166. typedef struct

  167. {

  168.     uint8_t reason;   /* 0=PwmBegin(UG后) 3=PlsrHwTick(每1ms) */

  169.     uint32_t psc;

  170.     uint32_t arr;

  171.     uint32_t ccr;

  172.     uint32_t cnt;

  173.     uint32_t frequencyHz;

  174.     int64_t emittedPulses;

  175. } PLSR_HW_DBG_SNAP;

  176. 

  177. static PLSR_HW_DBG_SNAP PlsrHwDbgSnap[PLSR_HW_DBG_SNAPSHOT_COUNT];

  178. static volatile uint16_t PlsrHwDbgCount;

  179. 

  180. static void PlsrHwDbgCapture(uint8_t axis, uint8_t reason)

  181. {

  182.     if (axis != 0U)

  183.     {

  184.         return;

  185.     }

  186.     if (reason == 0U)

  187.     {

  188.         PlsrHwDbgCount = 0U;

  189.     }

  190.     if (PlsrHwDbgCount < PLSR_HW_DBG_SNAPSHOT_COUNT)

  191.     {

  192.         PLSR_HW_DBG_SNAP *snap = &PlsrHwDbgSnap[PlsrHwDbgCount++];

  193.         snap->reason = reason;

  194.         snap->psc = PlsrHwAxisMap[axis].timer->PSC;

  195.         snap->arr = PlsrHwAxisMap[axis].timer->ARR;

  196.         snap->ccr = PlsrHwAxisMap[axis].timer->CCR1;

  197.         snap->cnt = PlsrHwAxisMap[axis].timer->CNT;

  198.         snap->frequencyHz = PlsrHwAxes[axis].currentFrequencyHz;

  199.         snap->emittedPulses = PlsrHwAxes[axis].emittedPulses;

  200.     }

  201. }

  202. #else

  203. #define PlsrHwDbgCapture(axis, reason) ((void)0)

  204. #endif

  205. 

  206. /* ---- 定时器寄存器访问抽象（host 模拟 / 生产真实） ---- */

  207. 

  208. static void PlsrHwTimerSetArr(uint8_t axis, uint32_t value)

  209. {

  210. #ifdef PLSR_HOST_TEST

  211.     PlsrHwTimers[axis].arr = value;

  212. #else

  213.     PlsrHwAxisMap[axis].timer->ARR = value;

  214. #endif

  215. }

  216. 

  217. static void PlsrHwTimerSetPsc(uint8_t axis, uint32_t value)

  218. {

  219. #ifdef PLSR_HOST_TEST

  220.     PlsrHwTimers[axis].psc = value;

  221. #else

  222.     PlsrHwAxisMap[axis].timer->PSC = value;

  223. #endif

  224. }

  225. 

  226. static void PlsrHwTimerSetCcr(uint8_t axis, uint32_t value)

  227. {

  228. #ifdef PLSR_HOST_TEST

  229.     PlsrHwTimers[axis].ccr1 = value;

  230. #else

  231.     PlsrHwAxisMap[axis].timer->CCR1 = value;

  232. #endif

  233. }

  234. 

  235. static void PlsrHwTimerSetCnt(uint8_t axis, uint32_t value)

  236. {

  237. #ifdef PLSR_HOST_TEST

  238.     PlsrHwTimers[axis].cnt = value;

  239.     /* F407 实测语义：CNT 写到活动 CCR1 比较值会置 CC1IF。 */

  240.     if (value == PlsrHwTimers[axis].ccr1)

  241.     {

  242.         PlsrHwTimers[axis].sr |= PLSR_HW_TIMER_CC1_BIT;

  243.     }

  244. #else

  245.     PlsrHwAxisMap[axis].timer->CNT = value;

  246. #endif

  247. }

  248. 

  249. static void PlsrHwTimerSetCen(uint8_t axis, uint32_t value)

  250. {

  251. #ifdef PLSR_HOST_TEST

  252.     PlsrHwTimers[axis].cr1 = (PlsrHwTimers[axis].cr1 & ~0x0001UL) | value;

  253. #else

  254.     if (value != 0UL)

  255.     {

  256.         PlsrHwAxisMap[axis].timer->CR1 |= TIM_CR1_CEN;

  257.     }

  258.     else

  259.     {

  260.         PlsrHwAxisMap[axis].timer->CR1 &= ~TIM_CR1_CEN;

  261.     }

  262. #endif

  263. }

  264. 

  265. static void PlsrHwTimerSetCc1e(uint8_t axis, uint32_t value)

  266. {

  267. #ifdef PLSR_HOST_TEST

  268.     PlsrHwTimers[axis].ccer = (PlsrHwTimers[axis].ccer & ~0x0001UL) | value;

  269. #else

  270.     if (value != 0UL)

  271.     {

  272.         PlsrHwAxisMap[axis].timer->CCER |= TIM_CCER_CC1E;

  273.     }

  274.     else

  275.     {

  276.         PlsrHwAxisMap[axis].timer->CCER &= ~TIM_CCER_CC1E;

  277.     }

  278. #endif

  279. }

  280. 

  281. /* 通道 1 输出模式 = PWM 模式 1（OC1M=110）+ CCR 预装载（OC1PE）。

  282.  * 上电复位后 CCMR1=0（冻结），通道输出恒定电平、无方波，必须显式配置。 */

  283. static void PlsrHwTimerSetPwmMode1(uint8_t axis)

  284. {

  285. #ifdef PLSR_HOST_TEST

  286.     PlsrHwTimers[axis].ccmr1 = 0x0068UL;

  287. #else

  288.     PlsrHwAxisMap[axis].timer->CCMR1 = (TIM_CCMR1_OC1M_1 | TIM_CCMR1_OC1M_2)

  289.                                        | TIM_CCMR1_OC1PE;

  290. #endif

  291. }

  292. 

  293. /* AB 启动和重定相时先把 OC1REF 钳到低电平，再切到 frozen 保持 00。

  294.  * 两路 CNT 就位后从 frozen 切到 PWM1，硬件会按当前 CNT/CCR 重新计算输出，

  295.  * 避免 UG 后残留的 OC1REF 高电平经 CC1E 暴露为窄脉冲。 */

  296. static void PlsrHwTimerSetForcedInactive(uint8_t axis)

  297. {

  298. #ifdef PLSR_HOST_TEST

  299.     PlsrHwTimers[axis].ccmr1 = 0x0048UL;

  300. #else

  301.     PlsrHwAxisMap[axis].timer->CCMR1 = TIM_CCMR1_OC1M_2

  302.                                        | TIM_CCMR1_OC1PE;

  303. #endif

  304. }

  305. 

  306. static void PlsrHwTimerSetFrozen(uint8_t axis)

  307. {

  308. #ifdef PLSR_HOST_TEST

  309.     PlsrHwTimers[axis].ccmr1 = 0x0008UL;

  310. #else

  311.     PlsrHwAxisMap[axis].timer->CCMR1 = TIM_CCMR1_OC1PE;

  312. #endif

  313. }

  314. 

  315. static void PlsrHwTimerSetUie(uint8_t axis, uint32_t value)

  316. {

  317. #ifdef PLSR_HOST_TEST

  318.     PlsrHwTimers[axis].dier = (PlsrHwTimers[axis].dier & ~0x0001UL) | value;

  319. #else

  320.     if (value != 0UL)

  321.     {

  322.         PlsrHwAxisMap[axis].timer->DIER |= TIM_DIER_UIE;

  323.     }

  324.     else

  325.     {

  326.         PlsrHwAxisMap[axis].timer->DIER &= ~TIM_DIER_UIE;

  327.     }

  328. #endif

  329. }

  330. 

  331. static void PlsrHwTimerSetCc1ie(uint8_t axis, uint32_t value)

  332. {

  333. #ifdef PLSR_HOST_TEST

  334.     PlsrHwTimers[axis].dier =

  335.         (PlsrHwTimers[axis].dier & ~PLSR_HW_TIMER_CC1_BIT)

  336.         | ((value != 0UL) ? PLSR_HW_TIMER_CC1_BIT : 0UL);

  337.     if ((value != 0UL)

  338.         && ((PlsrHwTimers[axis].sr & PLSR_HW_TIMER_CC1_BIT) != 0UL))

  339.     {

  340.         PlsrHwOnTimerUpdate(axis);

  341.     }

  342. #else

  343.     if (value != 0UL)

  344.     {

  345.         PlsrHwAxisMap[axis].timer->DIER |= TIM_DIER_CC1IE;

  346.     }

  347.     else

  348.     {

  349.         PlsrHwAxisMap[axis].timer->DIER &= ~TIM_DIER_CC1IE;

  350.     }

  351. #endif

  352. }

  353. 

  354. static void PlsrHwTimerClearUif(uint8_t axis)

  355. {

  356. #ifdef PLSR_HOST_TEST

  357.     PlsrHwTimers[axis].sr &= ~PLSR_HW_TIMER_UPDATE_BIT;

  358. #else

  359.     PlsrHwAxisMap[axis].timer->SR &= ~TIM_SR_UIF;

  360. #endif

  361. }

  362. 

  363. static uint8_t PlsrHwTimerHasUif(uint8_t axis)

  364. {

  365. #ifdef PLSR_HOST_TEST

  366.     return ((PlsrHwTimers[axis].sr & PLSR_HW_TIMER_UPDATE_BIT) != 0UL)

  367.                ? 1U

  368.                : 0U;

  369. #else

  370.     return ((PlsrHwAxisMap[axis].timer->SR & TIM_SR_UIF) != 0UL) ? 1U : 0U;

  371. #endif

  372. }

  373. 

  374. static void PlsrHwTimerClearCc1if(uint8_t axis)

  375. {

  376. #ifdef PLSR_HOST_TEST

  377.     PlsrHwTimers[axis].sr &= ~PLSR_HW_TIMER_CC1_BIT;

  378. #else

  379.     PlsrHwAxisMap[axis].timer->SR &= ~TIM_SR_CC1IF;

  380. #endif

  381. }

  382. 

  383. static uint8_t PlsrHwTimerHasCc1if(uint8_t axis)

  384. {

  385. #ifdef PLSR_HOST_TEST

  386.     return ((PlsrHwTimers[axis].sr & PLSR_HW_TIMER_CC1_BIT) != 0UL)

  387.                ? 1U

  388.                : 0U;

  389. #else

  390.     return ((PlsrHwAxisMap[axis].timer->SR & TIM_SR_CC1IF) != 0UL) ? 1U : 0U;

  391. #endif

  392. }

  393. 

  394. /* ---- DIR 输出 ----

  395.  * XDM 为晶体管（NPN 漏型）输出：ON（导通）= 引脚低电平。

  396.  * 信捷正逻辑：正向发脉冲时方向端子置 ON（低）。 */

  397. 

  398. static void PlsrHwSetDirLevel(uint8_t axis, uint8_t positive)

  399. {

  400.     PLSR_HW_AXIS_STATE *state = &PlsrHwAxes[axis];

  401. 

  402.     state->directionPositive = (positive != 0U) ? 1U : 0U;

  403.     if (state->directionPoint == PLSR_HW_DIR_POINT_NONE)

  404.     {

  405.         return;

  406.     }

  407. #ifdef PLSR_HOST_TEST

  408.     PlsrHwTimers[axis].dirLevel = (positive != 0U) ? 1U : 0U;

  409. #else

  410.     if (state->directionPoint < PLSR_HW_OUTPUT_POINT_COUNT)

  411.     {

  412.         const PLSR_HW_OUTPUT_PIN *pin =

  413.             &PlsrHwOutputPins[state->directionPoint];

  414.         GPIO_InitTypeDef gpio;

  415. 

  416.         if (pin->port != NULL)

  417.         {

  418.             /* DIR 点按需配置为推挽输出（上电默认高阻=截止，安全）。 */

  419.             gpio.Pin = pin->pin;

  420.             gpio.Mode = GPIO_MODE_OUTPUT_PP;

  421.             gpio.Pull = GPIO_NOPULL;

  422.             gpio.Speed = GPIO_SPEED_FREQ_VERY_HIGH;

  423.             HAL_GPIO_Init(pin->port, &gpio);

  424.             /* 漏型输出：ON（导通）= 低电平。 */

  425.             HAL_GPIO_WritePin(pin->port,

  426.                               pin->pin,

  427.                               (positive != 0U) ? GPIO_PIN_RESET

  428.                                                : GPIO_PIN_SET);

  429.         }

  430.     }

  431. #endif

  432. }

  433. 

  434. /* ---- PWM 启停 ----

  435.  * ARR/CCR 使用预装载（ARPE/OC1PE）：运行中调频写入延迟到更新事件生效，

  436.  * 避免 ARR 变小瞬间 CNT 超调提前回绕（每段加速会多出 ~ln(f1/f0) 个假脉冲）。

  437.  * 首次启动用 EGR.UG 把预装载值加载到影子寄存器，杜绝首个周期用复位值。 */

  438. 

  439. static void PlsrHwTimerSetArpe(uint8_t axis, uint32_t value)

  440. {

  441. #ifdef PLSR_HOST_TEST

  442.     PlsrHwTimers[axis].cr1 = (PlsrHwTimers[axis].cr1 & ~0x0080UL)

  443.                              | ((value != 0UL) ? 0x0080UL : 0UL);

  444. #else

  445.     if (value != 0UL)

  446.     {

  447.         PlsrHwAxisMap[axis].timer->CR1 |= TIM_CR1_ARPE;

  448.     }

  449.     else

  450.     {

  451.         PlsrHwAxisMap[axis].timer->CR1 &= ~TIM_CR1_ARPE;

  452.     }

  453. #endif

  454. }

  455. 

  456. /* 生成更新事件：立即加载 ARR/CCR/PSC 影子寄存器（启动时用）。 */

  457. static void PlsrHwTimerSetUg(uint8_t axis)

  458. {

  459. #ifdef PLSR_HOST_TEST

  460.     PlsrHwTimers[axis].sr |= PLSR_HW_TIMER_UPDATE_BIT;

  461. #else

  462.     PlsrHwAxisMap[axis].timer->EGR = TIM_EGR_UG;

  463. #endif

  464. }

  465. 

  466. /* 配置 PWM 定时器（预装载写入；启动/调频共用，不触碰使能位）。 */

  467. static void PlsrHwConfigurePwm(uint8_t axis, uint32_t frequencyHz)

  468. {

  469.     uint16_t psc;

  470.     uint16_t arr;

  471. 

  472.     if (PlsrCalculateTimerDivider(PlsrHwAxisMap[axis].timerClockHz,

  473.                                   frequencyHz,

  474.                                   &psc,

  475.                                   &arr) != PLSR_RESULT_OK)

  476.     {

  477.         return;

  478.     }

  479.     PlsrHwTimerSetPsc(axis, psc);

  480.     PlsrHwTimerSetArr(axis, arr);

  481.     PlsrHwTimerSetCcr(axis, (uint32_t)arr / 2UL);   /* 50% 占空比 */

  482.     PlsrHwTimerSetPwmMode1(axis);

  483.     PlsrHwTimerSetArpe(axis, 1UL);

  484. }

  485. 

  486. /* 首次启动输出：加载影子寄存器后使能更新中断、通道与计数。 */

  487. static void PlsrHwPwmBegin(uint8_t axis)

  488. {

  489.     PlsrHwTimerSetUg(axis);

  490.     /* UG 只用于加载影子寄存器，不是物理脉冲，不得计数。 */

  491.     PlsrHwTimerClearUif(axis);

  492.     PlsrHwTimerClearCc1if(axis);

  493.     PlsrHwDbgCapture(axis, 0U);

  494.     PlsrHwTimerSetCc1ie(axis, 0UL);

  495.     PlsrHwTimerSetUie(axis, 1UL);

  496.     PlsrHwTimerSetCc1e(axis, 1UL);

  497.     PlsrHwTimerSetCen(axis, 1UL);

  498. }

  499. 

  500. static void PlsrHwStopPwmTimer(uint8_t axis)

  501. {

  502.     PlsrHwTimerSetCc1e(axis, 0UL);

  503.     PlsrHwTimerSetUie(axis, 0UL);

  504.     PlsrHwTimerSetCc1ie(axis, 0UL);

  505.     PlsrHwTimerSetCen(axis, 0UL);

  506.     PlsrHwTimerClearUif(axis);

  507.     PlsrHwTimerClearCc1if(axis);

  508. }

  509. 

  510. static uint8_t PlsrHwIsAbBaseAxis(uint8_t axis)

  511. {

  512.     return ((axis == 0U) || (axis == 2U)) ? 1U : 0U;

  513. }

  514. 

  515. static uint8_t PlsrHwGetPairedAxis(uint8_t axis)

  516. {

  517.     return (uint8_t)(axis + 1U);

  518. }

  519. 

  520. /* 为 168MHz/84MHz 配对定时器选择相同 ARR，并让前者的 PSC 分频

  521.  * 始终是后者的 2 倍。两路获得完全相同的计数时钟与周期，避免

  522.  * 独立取整造成 AB 相位随运行时间漂移。 */

  523. static uint8_t PlsrHwCalculateAbDividers(uint8_t axis,

  524.                                          uint32_t frequencyHz,

  525.                                          uint16_t *basePsc,

  526.                                          uint16_t *pairPsc,

  527.                                          uint16_t *arr)

  528. {

  529.     uint8_t pairAxis = PlsrHwGetPairedAxis(axis);

  530.     uint64_t baseClock = PlsrHwAxisMap[axis].timerClockHz;

  531.     uint64_t pairClock = PlsrHwAxisMap[pairAxis].timerClockHz;

  532.     uint64_t ratio;

  533.     uint64_t pairDivider;

  534.     uint64_t baseDivider;

  535.     uint64_t periodTicks;

  536. 

  537.     if ((frequencyHz == 0UL) || (basePsc == NULL) || (pairPsc == NULL)

  538.         || (arr == NULL) || (pairClock == 0UL)

  539.         || ((baseClock % pairClock) != 0UL))

  540.     {

  541.         return 0U;

  542.     }

  543.     ratio = baseClock / pairClock;

  544.     if (ratio == 0UL)

  545.     {

  546.         return 0U;

  547.     }

  548.     pairDivider = (pairClock

  549.                    + (uint64_t)frequencyHz * UINT64_C(65536) - 1UL)

  550.                   / ((uint64_t)frequencyHz * UINT64_C(65536));

  551.     if (pairDivider == 0UL)

  552.     {

  553.         pairDivider = 1UL;

  554.     }

  555.     baseDivider = pairDivider * ratio;

  556.     if ((pairDivider > UINT64_C(65536))

  557.         || (baseDivider > UINT64_C(65536)))

  558.     {

  559.         return 0U;

  560.     }

  561.     periodTicks = (pairClock

  562.                    + ((uint64_t)frequencyHz * pairDivider) / 2UL)

  563.                   / ((uint64_t)frequencyHz * pairDivider);

  564.     if ((periodTicks < 4UL) || (periodTicks > UINT64_C(65536)))

  565.     {

  566.         return 0U;

  567.     }

  568.     *basePsc = (uint16_t)(baseDivider - 1UL);

  569.     *pairPsc = (uint16_t)(pairDivider - 1UL);

  570.     *arr = (uint16_t)(periodTicks - 1UL);

  571.     return 1U;

  572. }

  573. 

  574. static void PlsrHwLoadAbPwm(uint8_t axis,

  575.                             uint16_t basePsc,

  576.                             uint16_t pairPsc,

  577.                             uint16_t arr)

  578. {

  579.     uint8_t pairAxis = PlsrHwGetPairedAxis(axis);

  580.     uint32_t compare;

  581. 

  582.     compare = ((uint32_t)arr + 1UL) / 2UL;

  583.     PlsrHwTimerSetPsc(axis, basePsc);

  584.     PlsrHwTimerSetPsc(pairAxis, pairPsc);

  585.     PlsrHwTimerSetArr(axis, arr);

  586.     PlsrHwTimerSetArr(pairAxis, arr);

  587.     PlsrHwTimerSetCcr(axis, compare);

  588.     PlsrHwTimerSetCcr(pairAxis, compare);

  589.     PlsrHwTimerSetPwmMode1(axis);

  590.     PlsrHwTimerSetPwmMode1(pairAxis);

  591.     PlsrHwTimerSetArpe(axis, 1UL);

  592.     PlsrHwTimerSetArpe(pairAxis, 1UL);

  593.     PlsrHwAxes[axis].abActiveBasePsc = basePsc;

  594.     PlsrHwAxes[axis].abActivePairPsc = pairPsc;

  595.     PlsrHwAxes[axis].abActiveArr = arr;

  596. }

  597. 

  598. static uint8_t PlsrHwConfigureAbPwm(uint8_t axis, uint32_t frequencyHz)

  599. {

  600.     uint16_t basePsc;

  601.     uint16_t pairPsc;

  602.     uint16_t arr;

  603. 

  604.     if (PlsrHwCalculateAbDividers(axis,

  605.                                   frequencyHz,

  606.                                   &basePsc,

  607.                                   &pairPsc,

  608.                                   &arr) == 0U)

  609.     {

  610.         return 0U;

  611.     }

  612.     PlsrHwLoadAbPwm(axis, basePsc, pairPsc, arr);

  613.     return 1U;

  614. }

  615. 

  616. /* 运行中的 AB 调频不能直接写两路 ARR 预装载：两路定时器相差 1/4 周期，

  617.  * 各自的 update 时刻也相差 1/4 周期，会短暂使用不同周期并永久积累相位误差。

  618.  * 任务上下文只计算并发布最新参数，真正装载由 00 周期边界中断完成。 */

  619. static uint8_t PlsrHwQueueAbFrequency(uint8_t axis, uint32_t frequencyHz)

  620. {

  621.     PLSR_HW_AXIS_STATE *state = &PlsrHwAxes[axis];

  622.     uint16_t basePsc;

  623.     uint16_t pairPsc;

  624.     uint16_t arr;

  625. #ifndef PLSR_HOST_TEST

  626.     uint32_t interruptState;

  627. #endif

  628. 

  629.     if (PlsrHwCalculateAbDividers(axis,

  630.                                   frequencyHz,

  631.                                   &basePsc,

  632.                                   &pairPsc,

  633.                                   &arr) == 0U)

  634.     {

  635.         return 0U;

  636.     }

  637. #ifndef PLSR_HOST_TEST

  638.     interruptState = __get_PRIMASK();

  639.     __disable_irq();

  640.     __DMB();

  641. #endif

  642.     if ((basePsc == state->abActiveBasePsc)

  643.         && (pairPsc == state->abActivePairPsc)

  644.         && (arr == state->abActiveArr))

  645.     {

  646.         /* 量化后的分频参数未变化时取消旧请求，避免匀速段每 1ms 重定相。 */

  647.         state->abFrequencyPending = 0U;

  648.     }

  649.     else

  650.     {

  651.         state->abPendingBasePsc = basePsc;

  652.         state->abPendingPairPsc = pairPsc;

  653.         state->abPendingArr = arr;

  654.         state->abFrequencyPending = 1U;

  655.     }

  656. #ifndef PLSR_HOST_TEST

  657.     __DMB();

  658.     if (interruptState == 0UL)

  659.     {

  660.         __enable_irq();

  661.     }

  662. #endif

  663.     return 1U;

  664. }

  665. 

  666. static void PlsrHwBeginAbOutput(uint8_t axis, uint8_t debugReason)

  667. {

  668.     PLSR_HW_AXIS_STATE *state = &PlsrHwAxes[axis];

  669.     uint8_t pairAxis = PlsrHwGetPairedAxis(axis);

  670.     uint8_t leadAxis = (state->directionPositive != 0U) ? axis : pairAxis;

  671.     uint8_t lagAxis = (state->directionPositive != 0U) ? pairAxis : axis;

  672.     uint32_t periodTicks;

  673.     uint32_t leadStart;

  674.     uint32_t lagStart;

  675. #ifndef PLSR_HOST_TEST

  676.     uint32_t interruptState;

  677. #else

  678.     (void)debugReason;

  679. #endif

  680. 

  681. #ifdef PLSR_HOST_TEST

  682.     periodTicks = PlsrHwTimers[axis].arr + 1UL;

  683. #else

  684.     periodTicks = PlsrHwAxisMap[axis].timer->ARR + 1UL;

  685. #endif

  686.     leadStart = (periodTicks * 3UL) / 4UL;

  687.     /* 落后相从 CCR 精确起步；切回 PWM 后清 CC1IF，最后才开 CC1IE。 */

  688.     lagStart = periodTicks / 2UL;

  689.     state->abCountAxis = lagAxis;

  690.     state->abQuarter = 0U;

  691. 

  692. #ifndef PLSR_HOST_TEST

  693.     interruptState = __get_PRIMASK();

  694.     __disable_irq();

  695.     __DMB();

  696.     PlsrHwHoldPulsePinLow(axis);

  697.     PlsrHwHoldPulsePinLow(pairAxis);

  698. #endif

  699.     PlsrHwTimerSetCen(axis, 0UL);

  700.     PlsrHwTimerSetCen(pairAxis, 0UL);

  701.     PlsrHwTimerSetCc1e(axis, 0UL);

  702.     PlsrHwTimerSetCc1e(pairAxis, 0UL);

  703.     PlsrHwTimerSetUie(axis, 0UL);

  704.     PlsrHwTimerSetUie(pairAxis, 0UL);

  705.     PlsrHwTimerSetCc1ie(axis, 0UL);

  706.     PlsrHwTimerSetCc1ie(pairAxis, 0UL);

  707.     PlsrHwTimerSetForcedInactive(axis);

  708.     PlsrHwTimerSetForcedInactive(pairAxis);

  709.     PlsrHwTimerSetFrozen(axis);

  710.     PlsrHwTimerSetFrozen(pairAxis);

  711.     PlsrHwTimerSetUg(axis);

  712.     PlsrHwTimerSetUg(pairAxis);

  713.     PlsrHwTimerClearUif(axis);

  714.     PlsrHwTimerClearUif(pairAxis);

  715.     PlsrHwTimerClearCc1if(axis);

  716.     PlsrHwTimerClearCc1if(pairAxis);

  717.     PlsrHwTimerSetCnt(leadAxis, leadStart);

  718.     PlsrHwTimerSetCnt(lagAxis, lagStart);

  719. #ifdef PLSR_HOST_TEST

  720.     PlsrHwTimerSetCc1e(axis, 1UL);

  721.     PlsrHwTimerSetCc1e(pairAxis, 1UL);

  722.     PlsrHwTimerSetPwmMode1(axis);

  723.     PlsrHwTimerSetPwmMode1(pairAxis);

  724.     PlsrHwTimerClearCc1if(axis);

  725.     PlsrHwTimerClearCc1if(pairAxis);

  726.     PlsrHwTimerSetCen(axis, 1UL);

  727.     PlsrHwTimerSetCen(pairAxis, 1UL);

  728.     PlsrHwTimerClearCc1if(axis);

  729.     PlsrHwTimerClearCc1if(pairAxis);

  730.     PlsrHwTimerSetCc1ie(lagAxis, 1UL);

  731. #else

  732.     PlsrHwTimerSetCc1e(axis, 1UL);

  733.     PlsrHwTimerSetCc1e(pairAxis, 1UL);

  734.     PlsrHwTimerSetPwmMode1(axis);

  735.     PlsrHwTimerSetPwmMode1(pairAxis);

  736.     /* OCREF 已在低电平位置稳定后再把物理引脚交还定时器。 */

  737.     PlsrHwTimerClearCc1if(axis);

  738.     PlsrHwTimerClearCc1if(pairAxis);

  739.     PlsrHwReleasePulsePin(axis);

  740.     PlsrHwReleasePulsePin(pairAxis);

  741.     PlsrHwTimerSetCen(axis, 1UL);

  742.     PlsrHwTimerSetCen(pairAxis, 1UL);

  743.     /* 最后才允许落后相计数中断。 */

  744.     PlsrHwTimerClearCc1if(axis);

  745.     PlsrHwTimerClearCc1if(pairAxis);

  746.     PlsrHwTimerSetCc1ie(lagAxis, 1UL);

  747.     __DMB();

  748.     if (interruptState == 0UL)

  749.     {

  750.         __enable_irq();

  751.     }

  752. #endif

  753.     PlsrHwDbgCapture(axis, debugReason);

  754. }

  755. 

  756. static void PlsrHwConfigureActiveOutput(uint8_t axis,

  757.                                         PLSR_OUTPUT_MODE outputMode,

  758.                                         uint32_t frequencyHz)

  759. {

  760.     if (outputMode == PLSR_OUTPUT_AB)

  761.     {

  762.         (void)PlsrHwConfigureAbPwm(axis, frequencyHz);

  763.     }

  764.     else

  765.     {

  766.         PlsrHwConfigurePwm(axis, frequencyHz);

  767.     }

  768. }

  769. 

  770. static void PlsrHwBeginActiveOutput(uint8_t axis,

  771.                                     PLSR_OUTPUT_MODE outputMode)

  772. {

  773.     if (outputMode == PLSR_OUTPUT_AB)

  774.     {

  775.         PlsrHwBeginAbOutput(axis, 0U);

  776.     }

  777.     else

  778.     {

  779.         PlsrHwPwmBegin(axis);

  780.     }

  781. }

  782. 

  783. static void PlsrHwStopActiveOutput(uint8_t axis,

  784.                                    PLSR_OUTPUT_MODE outputMode)

  785. {

  786.     if ((outputMode == PLSR_OUTPUT_AB) && (PlsrHwIsAbBaseAxis(axis) != 0U))

  787.     {

  788.         uint8_t pairAxis = PlsrHwGetPairedAxis(axis);

  789. #ifndef PLSR_HOST_TEST

  790.         uint32_t interruptState = __get_PRIMASK();

  791. 

  792.         __disable_irq();

  793.         __DMB();

  794.         /* DONE/STOP 后继续由 GPIO 保持 00，禁止已关闭 timer 泄漏残余边沿。 */

  795.         PlsrHwHoldPulsePinLow(axis);

  796.         PlsrHwHoldPulsePinLow(pairAxis);

  797. #endif

  798.         PlsrHwStopPwmTimer(axis);

  799.         PlsrHwStopPwmTimer(pairAxis);

  800. #ifndef PLSR_HOST_TEST

  801.         __DMB();

  802.         if (interruptState == 0UL)

  803.         {

  804.             __enable_irq();

  805.         }

  806. #endif

  807.     }

  808.     else

  809.     {

  810.         PlsrHwStopPwmTimer(axis);

  811.     }

  812. }

  813. 

  814. uint8_t PlsrHwResolveDirectionPoint(uint8_t pointNumber)

  815. {

  816.     /* 与资源层一致的合法输出点掩码（Q0~Q7、Q10~Q17、Q20）。 */

  817.     const uint32_t validOutputMask = 0x0013FCFFUL;

  818. 

  819.     if (pointNumber >= PLSR_HW_OUTPUT_POINT_COUNT)

  820.     {

  821.         return 0U;

  822.     }

  823.     if ((validOutputMask & (1UL << pointNumber)) == 0UL)

  824.     {

  825.         return 0U;

  826.     }

  827. #ifndef PLSR_HOST_TEST

  828.     if (PlsrHwOutputPins[pointNumber].port == NULL)

  829.     {

  830.         return 0U;

  831.     }

  832. #endif

  833.     return 1U;

  834. }

  835. 

  836. PLSR_RESULT PlsrHwInit(void)

  837. {

  838.     uint8_t axis;

  839. 

  840.     (void)memset(PlsrHwAxes, 0, sizeof(PlsrHwAxes));

  841.     for (axis = 0U; axis < PLSR_HW_AXIS_COUNT; axis++)

  842.     {

  843.         PlsrHwAxes[axis].state = PLSR_HW_STATE_IDLE;

  844.         PlsrHwAxes[axis].directionPoint = PLSR_HW_DIR_POINT_NONE;

  845. #ifdef PLSR_HOST_TEST

  846.         (void)memset(&PlsrHwTimers[axis], 0, sizeof(PlsrHwTimers[axis]));

  847. #else

  848.         PlsrHwTimerSetCc1e(axis, 0UL);

  849.         PlsrHwTimerSetUie(axis, 0UL);

  850.         PlsrHwTimerSetCc1ie(axis, 0UL);

  851.         PlsrHwTimerSetCen(axis, 0UL);

  852. #endif

  853.     }

  854. 

  855. #ifndef PLSR_HOST_TEST

  856.     {

  857.         GPIO_InitTypeDef gpio;

  858. 

  859.         /* 1. 输出点 GPIO 时钟（DIR 点按需配置时使用）。 */

  860.         __HAL_RCC_GPIOF_CLK_ENABLE();

  861.         __HAL_RCC_GPIOI_CLK_ENABLE();

  862.         __HAL_RCC_GPIOE_CLK_ENABLE();

  863.         __HAL_RCC_GPIOG_CLK_ENABLE();

  864.         __HAL_RCC_GPIOH_CLK_ENABLE();

  865.         __HAL_RCC_GPIOB_CLK_ENABLE();

  866. 

  867.         /* 2. 上电安全：输出点保持复位默认高阻（漏型输出 = 截止 = OFF）。

  868.          *    不驱动任何 Y 点，DIR 点仅在 PlsrHwSetDirLevel 时按需配置。 */

  869. 

  870.         /* 3. 定时器时钟。 */

  871.         __HAL_RCC_TIM10_CLK_ENABLE();

  872.         __HAL_RCC_TIM11_CLK_ENABLE();

  873.         __HAL_RCC_TIM13_CLK_ENABLE();

  874.         __HAL_RCC_TIM14_CLK_ENABLE();

  875. 

  876.         /* 4. 脉冲点切定时器复用（PF6/7=AF3、PF8/9=AF9）。

  877.          * 定时器通道尚未使能（CC1E=0），输出级断开，无毛刺。 */

  878.         gpio.Mode = GPIO_MODE_AF_PP;

  879.         gpio.Pull = GPIO_NOPULL;

  880.         gpio.Speed = GPIO_SPEED_FREQ_VERY_HIGH;

  881.         gpio.Pin = GPIO_PIN_6 | GPIO_PIN_7;

  882.         gpio.Alternate = 3U;

  883.         HAL_GPIO_Init(GPIOF, &gpio);

  884.         gpio.Pin = GPIO_PIN_8 | GPIO_PIN_9;

  885.         gpio.Alternate = 9U;

  886.         HAL_GPIO_Init(GPIOF, &gpio);

  887. 

  888.         /* 5. 更新中断 NVIC：高速计数/尾脉冲层（P3b 统一规划优先级表）。 */

  889.         HAL_NVIC_SetPriority(TIM1_UP_TIM10_IRQn, 1U, 0U);

  890.         HAL_NVIC_EnableIRQ(TIM1_UP_TIM10_IRQn);

  891.         HAL_NVIC_SetPriority(TIM8_UP_TIM13_IRQn, 1U, 0U);

  892.         HAL_NVIC_EnableIRQ(TIM8_UP_TIM13_IRQn);

  893.         HAL_NVIC_SetPriority(TIM1_TRG_COM_TIM11_IRQn, 1U, 0U);

  894.         HAL_NVIC_EnableIRQ(TIM1_TRG_COM_TIM11_IRQn);

  895.         HAL_NVIC_SetPriority(TIM8_TRG_COM_TIM14_IRQn, 1U, 0U);

  896.         HAL_NVIC_EnableIRQ(TIM8_TRG_COM_TIM14_IRQn);

  897.     }

  898. #endif

  899.     return PLSR_RESULT_OK;

  900. }

  901. 

  902. PLSR_RESULT PlsrHwStartPulse(uint8_t axis, const PLSR_HW_START_PARAMS *params)

  903. {

  904.     PLSR_HW_AXIS_STATE *state;

  905.     uint8_t directionChanged = 0U;

  906. 

  907.     if ((axis >= PLSR_HW_AXIS_COUNT) || (params == NULL))

  908.     {

  909.         return PLSR_RESULT_INVALID_ARGUMENT;

  910.     }

  911.     if (params->targetPulses <= 0)

  912.     {

  913.         return PLSR_RESULT_INVALID_ARGUMENT;

  914.     }

  915.     if ((uint32_t)params->outputMode > (uint32_t)PLSR_OUTPUT_CW_CCW)

  916.     {

  917.         return PLSR_RESULT_INVALID_ARGUMENT;

  918.     }

  919.     if ((params->outputMode == PLSR_OUTPUT_AB)

  920.         && (PlsrHwIsAbBaseAxis(axis) == 0U))

  921.     {

  922.         return PLSR_RESULT_INVALID_AXIS;

  923.     }

  924.     if (params->outputMode == PLSR_OUTPUT_CW_CCW)

  925.     {

  926.         return PLSR_RESULT_NOT_SUPPORTED;

  927.     }

  928.     state = &PlsrHwAxes[axis];

  929.     if (state->state == PLSR_HW_STATE_RUNNING)

  930.     {

  931.         return PLSR_RESULT_BUSY;

  932.     }

  933. 

  934.     /* 方向延时只在方向发生变化时生效（首次启动/换向/换方向点）：

  935.      * 段间同向衔接不再等待 10ms，直接进入 PWM 待启动。 */

  936.     if (params->outputMode == PLSR_OUTPUT_PULSE_DIR)

  937.     {

  938.         directionChanged =

  939.             (state->directionPoint == PLSR_HW_DIR_POINT_NONE)

  940.             || (state->directionPoint != params->directionPoint)

  941.             || (state->directionPositive != params->directionPositive);

  942.     }

  943. 

  944.     state->outputMode = params->outputMode;

  945.     state->targetPulses = params->targetPulses;

  946.     state->emittedPulses = 0;

  947.     state->currentFrequencyHz = params->frequencyHz;

  948.     state->directionPoint =

  949.         (params->outputMode == PLSR_OUTPUT_PULSE_DIR)

  950.             ? params->directionPoint

  951.             : PLSR_HW_DIR_POINT_NONE;

  952.     state->directionDelayRemainingMs =

  953.         ((params->outputMode == PLSR_OUTPUT_PULSE_DIR)

  954.          && (directionChanged != 0U))

  955.             ? params->directionDelayMs

  956.             : 0U;

  957.     state->abQuarter = 0U;

  958.     state->abFrequencyPending = 0U;

  959.     if (params->outputMode == PLSR_OUTPUT_PULSE_DIR)

  960.     {

  961.         PlsrHwSetDirLevel(axis, params->directionPositive);

  962.     }

  963.     else

  964.     {

  965.         state->directionPositive =

  966.             (params->directionPositive != 0U) ? 1U : 0U;

  967.     }

  968.     state->state = (state->directionDelayRemainingMs > 0U)

  969.                        ? PLSR_HW_STATE_DIR_SETTLING

  970.                        : PLSR_HW_STATE_PWM_PENDING;

  971.     return PLSR_RESULT_OK;

  972. }

  973. 

  974. PLSR_RESULT PlsrHwSetFrequency(uint8_t axis, uint32_t frequencyHz)

  975. {

  976.     PLSR_HW_AXIS_STATE *state;

  977. 

  978.     if (axis >= PLSR_HW_AXIS_COUNT)

  979.     {

  980.         return PLSR_RESULT_INVALID_ARGUMENT;

  981.     }

  982.     state = &PlsrHwAxes[axis];

  983.     state->currentFrequencyHz = frequencyHz;

  984.     if (state->state == PLSR_HW_STATE_RUNNING)

  985.     {

  986.         if (frequencyHz > 0UL)

  987.         {

  988.             if (state->outputMode == PLSR_OUTPUT_AB)

  989.             {

  990.                 if (PlsrHwQueueAbFrequency(axis, frequencyHz) == 0U)

  991.                 {

  992.                     return PLSR_RESULT_DIVIDER_UNREPRESENTABLE;

  993.                 }

  994.             }

  995.             else

  996.             {

  997.                 /* PULSE/DIR 仍由单定时器在自身 update 边界加载预装值。 */

  998.                 PlsrHwConfigureActiveOutput(axis,

  999.                                             state->outputMode,

  1000.                                             frequencyHz);

  1001.             }

  1002.         }

  1003.         else

  1004.         {

  1005.             PlsrHwStopActiveOutput(axis, state->outputMode);

  1006.         }

  1007.     }

  1008.     else if ((state->state == PLSR_HW_STATE_PWM_PENDING)

  1009.              && (frequencyHz > 0UL))

  1010.     {

  1011.         PlsrHwConfigureActiveOutput(axis, state->outputMode, frequencyHz);

  1012.         /* 必须先发布 RUNNING，避免启用 timer IRQ 后观察到 PWM_PENDING。 */

  1013.         state->state = PLSR_HW_STATE_RUNNING;

  1014.         PlsrHwBeginActiveOutput(axis, state->outputMode);

  1015.     }

  1016.     return PLSR_RESULT_OK;

  1017. }

  1018. 

  1019. PLSR_RESULT PlsrHwStopPulse(uint8_t axis)

  1020. {

  1021.     PLSR_HW_AXIS_STATE *state;

  1022. 

  1023.     if (axis >= PLSR_HW_AXIS_COUNT)

  1024.     {

  1025.         return PLSR_RESULT_INVALID_ARGUMENT;

  1026.     }

  1027.     state = &PlsrHwAxes[axis];

  1028.     if (state->state != PLSR_HW_STATE_IDLE)

  1029.     {

  1030.         PlsrHwStopActiveOutput(axis, state->outputMode);

  1031.         state->abQuarter = 0U;

  1032.         state->abFrequencyPending = 0U;

  1033.         state->state = PLSR_HW_STATE_IDLE;

  1034.     }

  1035.     return PLSR_RESULT_OK;

  1036. }

  1037. 

  1038. uint8_t PlsrHwIsPulseActive(uint8_t axis)

  1039. {

  1040.     if (axis >= PLSR_HW_AXIS_COUNT)

  1041.     {

  1042.         return 0U;

  1043.     }

  1044.     return (PlsrHwAxes[axis].state == PLSR_HW_STATE_RUNNING) ? 1U : 0U;

  1045. }

  1046. 

  1047. PLSR_HW_STATE PlsrHwGetState(uint8_t axis)

  1048. {

  1049.     if (axis >= PLSR_HW_AXIS_COUNT)

  1050.     {

  1051.         return PLSR_HW_STATE_IDLE;

  1052.     }

  1053.     return PlsrHwAxes[axis].state;

  1054. }

  1055. 

  1056. uint32_t PlsrHwGetTimerClockHz(uint8_t axis)

  1057. {

  1058.     if (axis >= PLSR_HW_AXIS_COUNT)

  1059.     {

  1060.         return 0UL;

  1061.     }

  1062.     return PlsrHwAxisMap[axis].timerClockHz;

  1063. }

  1064. 

  1065. /* 硬件已发出的脉冲数（profile 虚拟计数校准用，中断内递增）。 */

  1066. int64_t PlsrHwGetEmittedPulses(uint8_t axis)

  1067. {

  1068.     int64_t emittedPulses;

  1069. 

  1070.     if (axis >= PLSR_HW_AXIS_COUNT)

  1071.     {

  1072.         return 0;

  1073.     }

  1074. #ifdef PLSR_HOST_TEST

  1075.     emittedPulses = PlsrHwAxes[axis].emittedPulses;

  1076. #else

  1077.     {

  1078.         uint32_t interruptState = __get_PRIMASK();

  1079. 

  1080.         __disable_irq();

  1081.         __DMB();

  1082.         emittedPulses = PlsrHwAxes[axis].emittedPulses;

  1083.         __DMB();

  1084.         if (interruptState == 0UL)

  1085.         {

  1086.             __enable_irq();

  1087.         }

  1088.     }

  1089. #endif

  1090.     return emittedPulses;

  1091. }

  1092. 

  1093. void PlsrHwTick(uint8_t axis)

  1094. {

  1095.     PLSR_HW_AXIS_STATE *state;

  1096. 

  1097.     if (axis >= PLSR_HW_AXIS_COUNT)

  1098.     {

  1099.         return;

  1100.     }

  1101.     state = &PlsrHwAxes[axis];

  1102.     /* 调试：每 tick 记录定时器实况（CNT 演化定位第一周期压缩）。 */

  1103.     PlsrHwDbgCapture(axis, 3U);

  1104.     switch (state->state)

  1105.     {

  1106.         case PLSR_HW_STATE_DIR_SETTLING:

  1107.             if (state->directionDelayRemainingMs > 0U)

  1108.             {

  1109.                 state->directionDelayRemainingMs--;

  1110.             }

  1111.             if (state->directionDelayRemainingMs == 0U)

  1112.             {

  1113.                 state->state = PLSR_HW_STATE_PWM_PENDING;

  1114.             }

  1115.             break;

  1116. 

  1117.         case PLSR_HW_STATE_PWM_PENDING:

  1118.             if (state->currentFrequencyHz > 0UL)

  1119.             {

  1120.                 PlsrHwConfigureActiveOutput(axis,

  1121.                                             state->outputMode,

  1122.                                             state->currentFrequencyHz);

  1123.                 state->state = PLSR_HW_STATE_RUNNING;

  1124.                 PlsrHwBeginActiveOutput(axis, state->outputMode);

  1125.             }

  1126.             break;

  1127. 

  1128.         default:

  1129.             break;

  1130.     }

  1131. }

  1132. 

  1133. /* 输出定时器中断入口：PULSE/DIR 在 update 计数；AB 在落后相

  1134.  * CC1 下降沿（四状态回到 00）计一个完整正交周期。 */

  1135. void PlsrHwOnTimerUpdate(uint8_t axis)

  1136. {

  1137.     PLSR_HW_AXIS_STATE *state;

  1138.     uint8_t ownerAxis;

  1139.     uint8_t hasCc1;

  1140. 

  1141.     if (axis >= PLSR_HW_AXIS_COUNT)

  1142.     {

  1143.         return;

  1144.     }

  1145. 

  1146.     /* CC1IF 无论当前状态如何都必须先清除；否则启动窗口中的杂散

  1147.      * compare 标志会让共享 IRQ 持续重入，主线程无法完成 CEN 配置。 */

  1148.     hasCc1 = PlsrHwTimerHasCc1if(axis);

  1149.     if (hasCc1 != 0U)

  1150.     {

  1151.         PlsrHwTimerClearCc1if(axis);

  1152.     }

  1153.     ownerAxis = (uint8_t)(axis & 0xFEU);

  1154.     state = &PlsrHwAxes[ownerAxis];

  1155.     if ((state->state == PLSR_HW_STATE_RUNNING)

  1156.         && (state->outputMode == PLSR_OUTPUT_AB))

  1157.     {

  1158.         if (PlsrHwTimerHasUif(axis) != 0U)

  1159.         {

  1160.             PlsrHwTimerClearUif(axis);

  1161.         }

  1162.         if ((hasCc1 == 0U) || (axis != state->abCountAxis))

  1163.         {

  1164.             return;

  1165.         }

  1166.         state->emittedPulses++;

  1167.         if (state->emittedPulses >= state->targetPulses)

  1168.         {

  1169.             PlsrHwStopActiveOutput(ownerAxis, state->outputMode);

  1170.             state->abQuarter = 0U;

  1171.             state->abFrequencyPending = 0U;

  1172.             state->state = PLSR_HW_STATE_DONE;

  1173.             (void)PlsrPostEvent(ownerAxis, PLSR_EVENT_SEGMENT_COMPLETE);

  1174.         }

  1175.         else if (state->abFrequencyPending != 0U)

  1176.         {

  1177.             uint16_t basePsc = state->abPendingBasePsc;

  1178.             uint16_t pairPsc = state->abPendingPairPsc;

  1179.             uint16_t arr = state->abPendingArr;

  1180. 

  1181.             state->abFrequencyPending = 0U;

  1182.             PlsrHwLoadAbPwm(ownerAxis, basePsc, pairPsc, arr);

  1183.             /* 落后相刚下降，AB=00；两路从同一个完整周期边界重定相。 */

  1184.             PlsrHwBeginAbOutput(ownerAxis, 4U);

  1185.         }

  1186.         return;

  1187.     }

  1188. 

  1189.     if (hasCc1 != 0U)

  1190.     {

  1191.         /* 非运行态/非 AB 模式的 CC1 仅作为杂散标志消费。 */

  1192.         return;

  1193.     }

  1194. 

  1195.     state = &PlsrHwAxes[axis];

  1196.     if (PlsrHwTimerHasUif(axis) == 0U)

  1197.     {

  1198.         return;

  1199.     }

  1200.     PlsrHwTimerClearUif(axis);

  1201.     if (state->state != PLSR_HW_STATE_RUNNING)

  1202.     {

  1203.         return;

  1204.     }

  1205.     if (state->outputMode != PLSR_OUTPUT_PULSE_DIR)

  1206.     {

  1207.         return;

  1208.     }

  1209. 

  1210.     state->emittedPulses++;

  1211.     if (state->emittedPulses >= state->targetPulses)

  1212.     {

  1213.         /* 更新时刻 = 周期结束：关通道即完整下降沿后停止，无额外脉冲。 */

  1214.         PlsrHwStopActiveOutput(axis, state->outputMode);

  1215.         state->state = PLSR_HW_STATE_DONE;

  1216.         (void)PlsrPostEvent(axis, PLSR_EVENT_SEGMENT_COMPLETE);

  1217.     }

  1218. }

  1219. 

  1220. #ifdef PLSR_HOST_TEST

  1221. uint32_t PlsrHwTestGetArr(uint8_t axis)

  1222. {

  1223.     return PlsrHwTimers[axis].arr;

  1224. }

  1225. 

  1226. uint32_t PlsrHwTestGetCcr(uint8_t axis)

  1227. {

  1228.     return PlsrHwTimers[axis].ccr1;

  1229. }

  1230. 

  1231. uint32_t PlsrHwTestGetCnt(uint8_t axis)

  1232. {

  1233.     return PlsrHwTimers[axis].cnt;

  1234. }

  1235. 

  1236. uint32_t PlsrHwTestGetCcmr1(uint8_t axis)

  1237. {

  1238.     return PlsrHwTimers[axis].ccmr1;

  1239. }

  1240. 

  1241. uint32_t PlsrHwTestGetCr1(uint8_t axis)

  1242. {

  1243.     return PlsrHwTimers[axis].cr1;

  1244. }

  1245. 

  1246. uint32_t PlsrHwTestGetPsc(uint8_t axis)

  1247. {

  1248.     return PlsrHwTimers[axis].psc;

  1249. }

  1250. 

  1251. uint8_t PlsrHwTestGetPwmEnabled(uint8_t axis)

  1252. {

  1253.     return ((PlsrHwTimers[axis].ccer & PLSR_HW_TIMER_CHANNEL1_BIT) != 0UL)

  1254.                ? 1U

  1255.                : 0U;

  1256. }

  1257. 

  1258. uint8_t PlsrHwTestGetDirLevel(uint8_t axis)

  1259. {

  1260.     return PlsrHwTimers[axis].dirLevel;

  1261. }

  1262. 

  1263. uint8_t PlsrHwTestGetAbPhaseA(uint8_t axis)

  1264. {

  1265.     const PLSR_HW_AXIS_STATE *state;

  1266. 

  1267.     if ((axis >= PLSR_HW_AXIS_COUNT) || (PlsrHwIsAbBaseAxis(axis) == 0U))

  1268.     {

  1269.         return 0U;

  1270.     }

  1271.     state = &PlsrHwAxes[axis];

  1272.     if (state->directionPositive != 0U)

  1273.     {

  1274.         return ((state->abQuarter == 1U) || (state->abQuarter == 2U))

  1275.                    ? 1U

  1276.                    : 0U;

  1277.     }

  1278.     return ((state->abQuarter == 2U) || (state->abQuarter == 3U))

  1279.                ? 1U

  1280.                : 0U;

  1281. }

  1282. 

  1283. uint8_t PlsrHwTestGetAbPhaseB(uint8_t axis)

  1284. {

  1285.     const PLSR_HW_AXIS_STATE *state;

  1286. 

  1287.     if ((axis >= PLSR_HW_AXIS_COUNT) || (PlsrHwIsAbBaseAxis(axis) == 0U))

  1288.     {

  1289.         return 0U;

  1290.     }

  1291.     state = &PlsrHwAxes[axis];

  1292.     if (state->directionPositive != 0U)

  1293.     {

  1294.         return ((state->abQuarter == 2U) || (state->abQuarter == 3U))

  1295.                    ? 1U

  1296.                    : 0U;

  1297.     }

  1298.     return ((state->abQuarter == 1U) || (state->abQuarter == 2U))

  1299.                ? 1U

  1300.                : 0U;

  1301. }

  1302. 

  1303. uint8_t PlsrHwTestGetAbQuarter(uint8_t axis)

  1304. {

  1305.     if ((axis >= PLSR_HW_AXIS_COUNT) || (PlsrHwIsAbBaseAxis(axis) == 0U))

  1306.     {

  1307.         return 0U;

  1308.     }

  1309.     return PlsrHwAxes[axis].abQuarter;

  1310. }

  1311. 

  1312. void PlsrHwTestAdvanceAbQuarter(uint8_t axis)

  1313. {

  1314.     PLSR_HW_AXIS_STATE *state;

  1315. 

  1316.     if ((axis >= PLSR_HW_AXIS_COUNT) || (PlsrHwIsAbBaseAxis(axis) == 0U))

  1317.     {

  1318.         return;

  1319.     }

  1320.     state = &PlsrHwAxes[axis];

  1321.     if ((state->state != PLSR_HW_STATE_RUNNING)

  1322.         || (state->outputMode != PLSR_OUTPUT_AB))

  1323.     {

  1324.         return;

  1325.     }

  1326. 

  1327.     state->abQuarter = (uint8_t)((state->abQuarter + 1U)

  1328.                                  % PLSR_HW_AB_QUARTER_COUNT);

  1329.     if (state->abQuarter == 0U)

  1330.     {

  1331.         /* 模拟目标板落后相 CC1 下降沿中断，复用生产计数路径。 */

  1332.         PlsrHwTimers[state->abCountAxis].sr |= PLSR_HW_TIMER_CC1_BIT;

  1333.         PlsrHwOnTimerUpdate(state->abCountAxis);

  1334.     }

  1335. }

  1336. 

  1337. void PlsrHwTestTriggerUpdate(uint8_t axis)

  1338. {

  1339.     if (axis < PLSR_HW_AXIS_COUNT)

  1340.     {

  1341.         PlsrHwTimers[axis].sr |= PLSR_HW_TIMER_UPDATE_BIT;

  1342.     }

  1343.     PlsrHwOnTimerUpdate(axis);

  1344. }

  1345. #endif

  1346. 

  1347. #ifndef PLSR_HOST_TEST

  1348. void TIM1_UP_TIM10_IRQHandler(void)

  1349. {

  1350.     PlsrHwOnTimerUpdate(0U);

  1351. }

  1352. 

  1353. void TIM8_UP_TIM13_IRQHandler(void)

  1354. {

  1355.     PlsrHwOnTimerUpdate(1U);

  1356. }

  1357. 

  1358. void TIM1_TRG_COM_TIM11_IRQHandler(void)

  1359. {

  1360.     PlsrHwOnTimerUpdate(2U);

  1361. }

  1362. 

  1363. void TIM8_TRG_COM_TIM14_IRQHandler(void)

  1364. {

  1365.     PlsrHwOnTimerUpdate(3U);

  1366. }

  1367. #endif