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.
41 Commit
3 Rami (Branch)
138 MiB
 
 
 
 
 
 
Albero (Tree): fdbbe71aea
Rami (Branch) Tag
${ item.name }
Crea branch ${ searchTerm }
da 'fdbbe71aea'
${ noResults }
Modbus-rtu/PLSR/Src/plsr_hal_f407.c

1725 righe
48 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 configuredDirectionPoint;

  149.     uint8_t directionPositive;

  150.     uint8_t directionNegativeLogic;

  151.     uint8_t directionTerminalOn;

  152.     uint8_t directionOutputPending;

  153.     uint8_t abQuarter;

  154.     uint8_t abCountAxis;

  155.     uint8_t abStartupPriming;

  156.     uint8_t abOutputPrimed;

  157.     uint16_t abActiveBasePsc;

  158.     uint16_t abActivePairPsc;

  159.     uint16_t abActiveArr;

  160.     uint16_t abPendingBasePsc;

  161.     uint16_t abPendingPairPsc;

  162.     uint16_t abPendingArr;

  163.     uint8_t abFrequencyPending;

  164.     uint8_t cwActiveAxis;

  165.     uint8_t cwStopPending;

  166. } PLSR_HW_AXIS_STATE;

  167. 

  168. static PLSR_HW_AXIS_STATE PlsrHwAxes[PLSR_HW_AXIS_COUNT];

  169. static uint8_t PlsrHwDirectionBatchActive;

  170. 

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

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

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

  174. #ifndef PLSR_HOST_TEST

  175. typedef struct

  176. {

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

  178.     uint32_t psc;

  179.     uint32_t arr;

  180.     uint32_t ccr;

  181.     uint32_t cnt;

  182.     uint32_t frequencyHz;

  183.     int64_t emittedPulses;

  184. } PLSR_HW_DBG_SNAP;

  185. 

  186. static PLSR_HW_DBG_SNAP PlsrHwDbgSnap[PLSR_HW_DBG_SNAPSHOT_COUNT];

  187. static volatile uint16_t PlsrHwDbgCount;

  188. 

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

  190. {

  191.     if (axis != 0U)

  192.     {

  193.         return;

  194.     }

  195.     if (reason == 0U)

  196.     {

  197.         PlsrHwDbgCount = 0U;

  198.     }

  199.     if (PlsrHwDbgCount < PLSR_HW_DBG_SNAPSHOT_COUNT)

  200.     {

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

  202.         snap->reason = reason;

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

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

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

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

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

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

  209.     }

  210. }

  211. #else

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

  213. #endif

  214. 

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

  216. 

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

  218. {

  219. #ifdef PLSR_HOST_TEST

  220.     PlsrHwTimers[axis].arr = value;

  221. #else

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

  223. #endif

  224. }

  225. 

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

  227. {

  228. #ifdef PLSR_HOST_TEST

  229.     PlsrHwTimers[axis].psc = value;

  230. #else

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

  232. #endif

  233. }

  234. 

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

  236. {

  237. #ifdef PLSR_HOST_TEST

  238.     PlsrHwTimers[axis].ccr1 = value;

  239. #else

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

  241. #endif

  242. }

  243. 

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

  245. {

  246. #ifdef PLSR_HOST_TEST

  247.     PlsrHwTimers[axis].cnt = value;

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

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

  250.     {

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

  252.     }

  253. #else

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

  255. #endif

  256. }

  257. 

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

  259. {

  260. #ifdef PLSR_HOST_TEST

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

  262. #else

  263.     if (value != 0UL)

  264.     {

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

  266.     }

  267.     else

  268.     {

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

  270.     }

  271. #endif

  272. }

  273. 

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

  275. {

  276. #ifdef PLSR_HOST_TEST

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

  278. #else

  279.     if (value != 0UL)

  280.     {

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

  282.     }

  283.     else

  284.     {

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

  286.     }

  287. #endif

  288. }

  289. 

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

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

  292. static void PlsrHwTimerSetPwmMode1(uint8_t axis)

  293. {

  294. #ifdef PLSR_HOST_TEST

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

  296. #else

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

  298.                                        | TIM_CCMR1_OC1PE;

  299. #endif

  300. }

  301. 

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

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

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

  305. static void PlsrHwTimerSetForcedInactive(uint8_t axis)

  306. {

  307. #ifdef PLSR_HOST_TEST

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

  309. #else

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

  311.                                        | TIM_CCMR1_OC1PE;

  312. #endif

  313. }

  314. 

  315. static void PlsrHwTimerSetFrozen(uint8_t axis)

  316. {

  317. #ifdef PLSR_HOST_TEST

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

  319. #else

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

  321. #endif

  322. }

  323. 

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

  325. {

  326. #ifdef PLSR_HOST_TEST

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

  328. #else

  329.     if (value != 0UL)

  330.     {

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

  332.     }

  333.     else

  334.     {

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

  336.     }

  337. #endif

  338. }

  339. 

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

  341. {

  342. #ifdef PLSR_HOST_TEST

  343.     PlsrHwTimers[axis].dier =

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

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

  346.     if ((value != 0UL)

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

  348.     {

  349.         PlsrHwOnTimerUpdate(axis);

  350.     }

  351. #else

  352.     if (value != 0UL)

  353.     {

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

  355.     }

  356.     else

  357.     {

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

  359.     }

  360. #endif

  361. }

  362. 

  363. static void PlsrHwTimerClearUif(uint8_t axis)

  364. {

  365. #ifdef PLSR_HOST_TEST

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

  367. #else

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

  369. #endif

  370. }

  371. 

  372. static uint8_t PlsrHwTimerHasUif(uint8_t axis)

  373. {

  374. #ifdef PLSR_HOST_TEST

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

  376.                ? 1U

  377.                : 0U;

  378. #else

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

  380. #endif

  381. }

  382. 

  383. static void PlsrHwTimerClearCc1if(uint8_t axis)

  384. {

  385. #ifdef PLSR_HOST_TEST

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

  387. #else

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

  389. #endif

  390. }

  391. 

  392. static uint8_t PlsrHwTimerHasCc1if(uint8_t axis)

  393. {

  394. #ifdef PLSR_HOST_TEST

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

  396.                ? 1U

  397.                : 0U;

  398. #else

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

  400. #endif

  401. }

  402. 

  403. /* ---- DIR 输出 ----

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

  405.  * 正逻辑：正向=ON；负逻辑：正向=OFF。逻辑运动方向始终单独保存，

  406.  * 不能因电气极性反转而改变位置符号、AB相序或SM方向标志。 */

  407. 

  408. static void PlsrHwApplyDirLevel(uint8_t axis)

  409. {

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

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

  412.     {

  413.         return;

  414.     }

  415. #ifdef PLSR_HOST_TEST

  416.     PlsrHwTimers[axis].dirLevel = state->directionTerminalOn;

  417.     state->configuredDirectionPoint = state->directionPoint;

  418. #else

  419.     if (state->directionPoint < PLSR_HW_OUTPUT_POINT_COUNT)

  420.     {

  421.         const PLSR_HW_OUTPUT_PIN *pin =

  422.             &PlsrHwOutputPins[state->directionPoint];

  423.         GPIO_InitTypeDef gpio;

  424. 

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

  426.         {

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

  428.             pin->port->BSRR = (state->directionTerminalOn != 0U)

  429.                                   ? ((uint32_t)pin->pin << 16U)

  430.                                   : (uint32_t)pin->pin;

  431.             if (state->configuredDirectionPoint != state->directionPoint)

  432.             {

  433.                 gpio.Pin = pin->pin;

  434.                 gpio.Mode = GPIO_MODE_OUTPUT_PP;

  435.                 gpio.Pull = GPIO_NOPULL;

  436.                 gpio.Speed = GPIO_SPEED_FREQ_VERY_HIGH;

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

  438.                 state->configuredDirectionPoint = state->directionPoint;

  439.             }

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

  441.         }

  442.     }

  443. #endif

  444. }

  445. 

  446. /* ---- PWM 启停 ----

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

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

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

  450. 

  451. static void PlsrHwSetDirLevel(uint8_t axis,

  452.                               uint8_t positive,

  453.                               uint8_t negativeLogic)

  454. {

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

  456. 

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

  458.     state->directionNegativeLogic =

  459.         (negativeLogic != 0U) ? 1U : 0U;

  460.     state->directionTerminalOn =

  461.         (uint8_t)(state->directionPositive

  462.                   ^ state->directionNegativeLogic);

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

  464.     {

  465.         return;

  466.     }

  467.     if ((PlsrHwDirectionBatchActive != 0U)

  468.         && (state->configuredDirectionPoint == state->directionPoint))

  469.     {

  470.         state->directionOutputPending = 1U;

  471.         return;

  472.     }

  473.     PlsrHwApplyDirLevel(axis);

  474. }

  475. 

  476. void PlsrHwBeginDirectionBatch(void)

  477. {

  478.     PlsrHwDirectionBatchActive = 1U;

  479. }

  480. 

  481. void PlsrHwEndDirectionBatch(void)

  482. {

  483.     uint8_t axis;

  484. #ifndef PLSR_HOST_TEST

  485.     uint32_t interruptState = __get_PRIMASK();

  486. 

  487.     __disable_irq();

  488.     __DMB();

  489. #endif

  490.     PlsrHwDirectionBatchActive = 0U;

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

  492.     {

  493.         if (PlsrHwAxes[axis].directionOutputPending != 0U)

  494.         {

  495.             PlsrHwAxes[axis].directionOutputPending = 0U;

  496.             PlsrHwApplyDirLevel(axis);

  497.         }

  498.     }

  499. #ifndef PLSR_HOST_TEST

  500.     __DMB();

  501.     if (interruptState == 0UL)

  502.     {

  503.         __enable_irq();

  504.     }

  505. #endif

  506. }

  507. 

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

  509. {

  510. #ifdef PLSR_HOST_TEST

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

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

  513. #else

  514.     if (value != 0UL)

  515.     {

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

  517.     }

  518.     else

  519.     {

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

  521.     }

  522. #endif

  523. }

  524. 

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

  526. static void PlsrHwTimerSetUg(uint8_t axis)

  527. {

  528. #ifdef PLSR_HOST_TEST

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

  530. #else

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

  532. #endif

  533. }

  534. 

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

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

  537. {

  538.     uint16_t psc;

  539.     uint16_t arr;

  540. #ifndef PLSR_HOST_TEST

  541.     uint32_t interruptState;

  542. #endif

  543. 

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

  545.                                   frequencyHz,

  546.                                   &psc,

  547.                                   &arr) != PLSR_RESULT_OK)

  548.     {

  549.         return;

  550.     }

  551. #ifndef PLSR_HOST_TEST

  552.     interruptState = __get_PRIMASK();

  553.     __disable_irq();

  554.     __DMB();

  555. #endif

  556.     PlsrHwTimerSetPsc(axis, psc);

  557.     PlsrHwTimerSetArr(axis, arr);

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

  559.     PlsrHwTimerSetPwmMode1(axis);

  560.     PlsrHwTimerSetArpe(axis, 1UL);

  561. #ifndef PLSR_HOST_TEST

  562.     __DMB();

  563.     if (interruptState == 0UL)

  564.     {

  565.         __enable_irq();

  566.     }

  567. #endif

  568. }

  569. 

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

  571. static void PlsrHwPwmBegin(uint8_t axis)

  572. {

  573.     PlsrHwTimerSetUg(axis);

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

  575.     PlsrHwTimerClearUif(axis);

  576.     PlsrHwTimerClearCc1if(axis);

  577.     PlsrHwDbgCapture(axis, 0U);

  578.     PlsrHwTimerSetCc1ie(axis, 0UL);

  579.     PlsrHwTimerSetUie(axis, 1UL);

  580.     PlsrHwTimerSetCc1e(axis, 1UL);

  581.     PlsrHwTimerSetCen(axis, 1UL);

  582. }

  583. 

  584. static void PlsrHwStopPwmTimer(uint8_t axis)

  585. {

  586.     PlsrHwTimerSetCc1e(axis, 0UL);

  587.     PlsrHwTimerSetUie(axis, 0UL);

  588.     PlsrHwTimerSetCc1ie(axis, 0UL);

  589.     PlsrHwTimerSetCen(axis, 0UL);

  590.     PlsrHwTimerClearUif(axis);

  591.     PlsrHwTimerClearCc1if(axis);

  592. }

  593. 

  594. static uint8_t PlsrHwIsAbBaseAxis(uint8_t axis)

  595. {

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

  597. }

  598. 

  599. static uint8_t PlsrHwGetPairedAxis(uint8_t axis)

  600. {

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

  602. }

  603. 

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

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

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

  607. static uint8_t PlsrHwCalculateAbDividers(uint8_t axis,

  608.                                          uint32_t frequencyHz,

  609.                                          uint16_t *basePsc,

  610.                                          uint16_t *pairPsc,

  611.                                          uint16_t *arr)

  612. {

  613.     uint8_t pairAxis = PlsrHwGetPairedAxis(axis);

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

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

  616.     uint64_t ratio;

  617.     uint64_t pairDivider;

  618.     uint64_t baseDivider;

  619.     uint64_t periodTicks;

  620. 

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

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

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

  624.     {

  625.         return 0U;

  626.     }

  627.     ratio = baseClock / pairClock;

  628.     if (ratio == 0UL)

  629.     {

  630.         return 0U;

  631.     }

  632.     pairDivider = (pairClock

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

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

  635.     if (pairDivider == 0UL)

  636.     {

  637.         pairDivider = 1UL;

  638.     }

  639.     baseDivider = pairDivider * ratio;

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

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

  642.     {

  643.         return 0U;

  644.     }

  645.     periodTicks = (pairClock

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

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

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

  649.     {

  650.         return 0U;

  651.     }

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

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

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

  655.     return 1U;

  656. }

  657. 

  658. static void PlsrHwLoadAbPwm(uint8_t axis,

  659.                             uint16_t basePsc,

  660.                             uint16_t pairPsc,

  661.                             uint16_t arr)

  662. {

  663.     uint8_t pairAxis = PlsrHwGetPairedAxis(axis);

  664.     uint32_t compare;

  665. 

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

  667.     PlsrHwTimerSetPsc(axis, basePsc);

  668.     PlsrHwTimerSetPsc(pairAxis, pairPsc);

  669.     PlsrHwTimerSetArr(axis, arr);

  670.     PlsrHwTimerSetArr(pairAxis, arr);

  671.     PlsrHwTimerSetCcr(axis, compare);

  672.     PlsrHwTimerSetCcr(pairAxis, compare);

  673.     PlsrHwTimerSetPwmMode1(axis);

  674.     PlsrHwTimerSetPwmMode1(pairAxis);

  675.     PlsrHwTimerSetArpe(axis, 1UL);

  676.     PlsrHwTimerSetArpe(pairAxis, 1UL);

  677.     PlsrHwAxes[axis].abActiveBasePsc = basePsc;

  678.     PlsrHwAxes[axis].abActivePairPsc = pairPsc;

  679.     PlsrHwAxes[axis].abActiveArr = arr;

  680. }

  681. 

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

  683. {

  684.     uint16_t basePsc;

  685.     uint16_t pairPsc;

  686.     uint16_t arr;

  687. 

  688.     if (PlsrHwCalculateAbDividers(axis,

  689.                                   frequencyHz,

  690.                                   &basePsc,

  691.                                   &pairPsc,

  692.                                   &arr) == 0U)

  693.     {

  694.         return 0U;

  695.     }

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

  697.     return 1U;

  698. }

  699. 

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

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

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

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

  704. {

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

  706.     uint16_t basePsc;

  707.     uint16_t pairPsc;

  708.     uint16_t arr;

  709. #ifndef PLSR_HOST_TEST

  710.     uint32_t interruptState;

  711. #endif

  712. 

  713.     if (PlsrHwCalculateAbDividers(axis,

  714.                                   frequencyHz,

  715.                                   &basePsc,

  716.                                   &pairPsc,

  717.                                   &arr) == 0U)

  718.     {

  719.         return 0U;

  720.     }

  721. #ifndef PLSR_HOST_TEST

  722.     interruptState = __get_PRIMASK();

  723.     __disable_irq();

  724.     __DMB();

  725. #endif

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

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

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

  729.     {

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

  731.         state->abFrequencyPending = 0U;

  732.     }

  733.     else

  734.     {

  735.         state->abPendingBasePsc = basePsc;

  736.         state->abPendingPairPsc = pairPsc;

  737.         state->abPendingArr = arr;

  738.         state->abFrequencyPending = 1U;

  739.     }

  740. #ifndef PLSR_HOST_TEST

  741.     __DMB();

  742.     if (interruptState == 0UL)

  743.     {

  744.         __enable_irq();

  745.     }

  746. #endif

  747.     return 1U;

  748. }

  749. 

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

  751. {

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

  753.     uint8_t pairAxis = PlsrHwGetPairedAxis(axis);

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

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

  756.     uint32_t periodTicks;

  757.     uint32_t leadStart;

  758.     uint32_t lagStart;

  759. #ifndef PLSR_HOST_TEST

  760.     uint32_t interruptState;

  761. #else

  762.     (void)debugReason;

  763. #endif

  764. 

  765. #ifdef PLSR_HOST_TEST

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

  767. #else

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

  769. #endif

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

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

  772.     lagStart = periodTicks / 2UL;

  773.     state->abCountAxis = lagAxis;

  774.     state->abQuarter = 0U;

  775.     state->abStartupPriming = (state->abOutputPrimed == 0U) ? 1U : 0U;

  776. 

  777. #ifndef PLSR_HOST_TEST

  778.     interruptState = __get_PRIMASK();

  779.     __disable_irq();

  780.     __DMB();

  781.     PlsrHwHoldPulsePinLow(axis);

  782.     PlsrHwHoldPulsePinLow(pairAxis);

  783. #endif

  784.     PlsrHwTimerSetCen(axis, 0UL);

  785.     PlsrHwTimerSetCen(pairAxis, 0UL);

  786.     PlsrHwTimerSetCc1e(axis, 0UL);

  787.     PlsrHwTimerSetCc1e(pairAxis, 0UL);

  788.     PlsrHwTimerSetUie(axis, 0UL);

  789.     PlsrHwTimerSetUie(pairAxis, 0UL);

  790.     PlsrHwTimerSetCc1ie(axis, 0UL);

  791.     PlsrHwTimerSetCc1ie(pairAxis, 0UL);

  792.     PlsrHwTimerSetForcedInactive(axis);

  793.     PlsrHwTimerSetForcedInactive(pairAxis);

  794.     PlsrHwTimerSetFrozen(axis);

  795.     PlsrHwTimerSetFrozen(pairAxis);

  796.     PlsrHwTimerSetUg(axis);

  797.     PlsrHwTimerSetUg(pairAxis);

  798.     PlsrHwTimerClearUif(axis);

  799.     PlsrHwTimerClearUif(pairAxis);

  800.     PlsrHwTimerClearCc1if(axis);

  801.     PlsrHwTimerClearCc1if(pairAxis);

  802.     PlsrHwTimerSetCnt(leadAxis, leadStart);

  803.     PlsrHwTimerSetCnt(lagAxis, lagStart);

  804. #ifdef PLSR_HOST_TEST

  805.     PlsrHwTimerSetCc1e(axis, 1UL);

  806.     PlsrHwTimerSetCc1e(pairAxis, 1UL);

  807.     PlsrHwTimerSetPwmMode1(axis);

  808.     PlsrHwTimerSetPwmMode1(pairAxis);

  809.     PlsrHwTimerClearCc1if(axis);

  810.     PlsrHwTimerClearCc1if(pairAxis);

  811.     PlsrHwTimerSetCen(axis, 1UL);

  812.     PlsrHwTimerSetCen(pairAxis, 1UL);

  813.     PlsrHwTimerClearCc1if(axis);

  814.     PlsrHwTimerClearCc1if(pairAxis);

  815.     PlsrHwTimerSetCc1ie(lagAxis, 1UL);

  816. #else

  817.     PlsrHwTimerSetCc1e(axis, 1UL);

  818.     PlsrHwTimerSetCc1e(pairAxis, 1UL);

  819.     PlsrHwTimerSetPwmMode1(axis);

  820.     PlsrHwTimerSetPwmMode1(pairAxis);

  821.     PlsrHwTimerClearCc1if(axis);

  822.     PlsrHwTimerClearCc1if(pairAxis);

  823.     if (state->abStartupPriming == 0U)

  824.     {

  825.         /* 完成过首次预热后，段间/调频重定相均从已验证的 00 边界

  826.          * 直接交还 AF，不额外吞掉用户周期。 */

  827.         PlsrHwReleasePulsePin(axis);

  828.         PlsrHwReleasePulsePin(pairAxis);

  829.     }

  830.     PlsrHwTimerSetCen(axis, 1UL);

  831.     PlsrHwTimerSetCen(pairAxis, 1UL);

  832.     PlsrHwTimerClearCc1if(axis);

  833.     PlsrHwTimerClearCc1if(pairAxis);

  834.     PlsrHwTimerSetCc1ie(lagAxis, 1UL);

  835.     __DMB();

  836.     if (interruptState == 0UL)

  837.     {

  838.         __enable_irq();

  839.     }

  840. #endif

  841.     PlsrHwDbgCapture(axis, debugReason);

  842. }

  843. 

  844. static void PlsrHwConfigureCwCcwPwm(uint8_t axis, uint32_t frequencyHz)

  845. {

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

  847.     uint8_t activeAxis = state->cwActiveAxis;

  848.     uint16_t psc;

  849.     uint16_t arr;

  850. #ifndef PLSR_HOST_TEST

  851.     uint32_t interruptState;

  852. #endif

  853. 

  854.     if (PlsrCalculateTimerDivider(PlsrHwAxisMap[activeAxis].timerClockHz,

  855.                                   frequencyHz,

  856.                                   &psc,

  857.                                   &arr) != PLSR_RESULT_OK)

  858.     {

  859.         return;

  860.     }

  861. #ifndef PLSR_HOST_TEST

  862.     interruptState = __get_PRIMASK();

  863.     __disable_irq();

  864.     __DMB();

  865. #endif

  866.     /* The compare ISR may arm final-pulse shutdown while TIM6 is calculating

  867.      * a new divider.  Recheck under the same short critical section as the

  868.      * preload writes so the tail period can no longer be changed afterwards. */

  869.     if (state->cwStopPending == 0U)

  870.     {

  871.         PlsrHwTimerSetPsc(activeAxis, psc);

  872.         PlsrHwTimerSetArr(activeAxis, arr);

  873.         PlsrHwTimerSetCcr(activeAxis, (uint32_t)arr / 2UL);

  874.         PlsrHwTimerSetPwmMode1(activeAxis);

  875.         PlsrHwTimerSetArpe(activeAxis, 1UL);

  876.     }

  877. #ifndef PLSR_HOST_TEST

  878.     __DMB();

  879.     if (interruptState == 0UL)

  880.     {

  881.         __enable_irq();

  882.     }

  883. #endif

  884. }

  885. 

  886. static void PlsrHwBeginCwCcwOutput(uint8_t axis)

  887. {

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

  889.     uint8_t pairAxis = PlsrHwGetPairedAxis(axis);

  890.     uint8_t activeAxis = state->cwActiveAxis;

  891. #ifndef PLSR_HOST_TEST

  892.     uint32_t interruptState = __get_PRIMASK();

  893. 

  894.     __disable_irq();

  895.     __DMB();

  896. #endif

  897.     /* Keep both pins in timer AF. On this output chain, switching a channel

  898.      * to GPIO-low is observable as an asserted Q edge. CC1E=0 is the tested

  899.      * inactive level and avoids the extra start/end edge. */

  900.     PlsrHwStopPwmTimer(axis);

  901.     PlsrHwStopPwmTimer(pairAxis);

  902.     state->cwStopPending = 0U;

  903.     PlsrHwTimerSetUg(activeAxis);

  904.     PlsrHwTimerClearUif(activeAxis);

  905.     PlsrHwTimerClearCc1if(activeAxis);

  906.     PlsrHwTimerSetCnt(activeAxis, 0UL);

  907.     PlsrHwTimerSetUie(activeAxis, 0UL);

  908.     PlsrHwTimerSetCc1ie(activeAxis, 1UL);

  909.     PlsrHwTimerSetCc1e(activeAxis, 1UL);

  910.     PlsrHwTimerSetCen(activeAxis, 1UL);

  911. #ifndef PLSR_HOST_TEST

  912.     __DMB();

  913.     if (interruptState == 0UL)

  914.     {

  915.         __enable_irq();

  916.     }

  917. #endif

  918. }

  919. 

  920. static void PlsrHwStopCwCcwOutput(uint8_t axis)

  921. {

  922.     uint8_t pairAxis = PlsrHwGetPairedAxis(axis);

  923. #ifndef PLSR_HOST_TEST

  924.     uint32_t interruptState = __get_PRIMASK();

  925. 

  926.     __disable_irq();

  927.     __DMB();

  928. #endif

  929.     /* Disable both compare outputs while retaining AF mode; do not force

  930.      * either pin through GPIO during the direction handover. */

  931.     PlsrHwStopPwmTimer(axis);

  932.     PlsrHwStopPwmTimer(pairAxis);

  933.     PlsrHwAxes[axis].cwStopPending = 0U;

  934. #ifndef PLSR_HOST_TEST

  935.     __DMB();

  936.     if (interruptState == 0UL)

  937.     {

  938.         __enable_irq();

  939.     }

  940. #endif

  941. }

  942. 

  943. static void PlsrHwConfigureActiveOutput(uint8_t axis,

  944.                                         PLSR_OUTPUT_MODE outputMode,

  945.                                         uint32_t frequencyHz)

  946. {

  947.     if (outputMode == PLSR_OUTPUT_AB)

  948.     {

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

  950.     }

  951.     else if (outputMode == PLSR_OUTPUT_CW_CCW)

  952.     {

  953.         PlsrHwConfigureCwCcwPwm(axis, frequencyHz);

  954.     }

  955.     else

  956.     {

  957.         PlsrHwConfigurePwm(axis, frequencyHz);

  958.     }

  959. }

  960. 

  961. static void PlsrHwBeginActiveOutput(uint8_t axis,

  962.                                     PLSR_OUTPUT_MODE outputMode)

  963. {

  964.     if (outputMode == PLSR_OUTPUT_AB)

  965.     {

  966.         PlsrHwBeginAbOutput(axis, 0U);

  967.     }

  968.     else if (outputMode == PLSR_OUTPUT_CW_CCW)

  969.     {

  970.         PlsrHwBeginCwCcwOutput(axis);

  971.     }

  972.     else

  973.     {

  974.         PlsrHwPwmBegin(axis);

  975.     }

  976. }

  977. 

  978. static void PlsrHwStopActiveOutput(uint8_t axis,

  979.                                    PLSR_OUTPUT_MODE outputMode)

  980. {

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

  982.     {

  983.         uint8_t pairAxis = PlsrHwGetPairedAxis(axis);

  984. #ifndef PLSR_HOST_TEST

  985.         uint32_t interruptState = __get_PRIMASK();

  986. 

  987.         __disable_irq();

  988.         __DMB();

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

  990.         PlsrHwHoldPulsePinLow(axis);

  991.         PlsrHwHoldPulsePinLow(pairAxis);

  992. #endif

  993.         PlsrHwStopPwmTimer(axis);

  994.         PlsrHwStopPwmTimer(pairAxis);

  995.         PlsrHwAxes[axis].abStartupPriming = 0U;

  996. #ifndef PLSR_HOST_TEST

  997.         __DMB();

  998.         if (interruptState == 0UL)

  999.         {

  1000.             __enable_irq();

  1001.         }

  1002. #endif

  1003.     }

  1004.     else if ((outputMode == PLSR_OUTPUT_CW_CCW)

  1005.              && (PlsrHwIsAbBaseAxis(axis) != 0U))

  1006.     {

  1007.         PlsrHwStopCwCcwOutput(axis);

  1008.     }

  1009.     else

  1010.     {

  1011.         PlsrHwStopPwmTimer(axis);

  1012.     }

  1013. }

  1014. 

  1015. uint8_t PlsrHwResolveDirectionPoint(uint8_t pointNumber)

  1016. {

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

  1018.     const uint32_t validOutputMask = 0x0013FCFFUL;

  1019. 

  1020.     if (pointNumber >= PLSR_HW_OUTPUT_POINT_COUNT)

  1021.     {

  1022.         return 0U;

  1023.     }

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

  1025.     {

  1026.         return 0U;

  1027.     }

  1028. #ifndef PLSR_HOST_TEST

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

  1030.     {

  1031.         return 0U;

  1032.     }

  1033. #endif

  1034.     return 1U;

  1035. }

  1036. 

  1037. PLSR_RESULT PlsrHwInit(void)

  1038. {

  1039.     uint8_t axis;

  1040. 

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

  1042.     PlsrHwDirectionBatchActive = 0U;

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

  1044.     {

  1045.         PlsrHwAxes[axis].state = PLSR_HW_STATE_IDLE;

  1046.         PlsrHwAxes[axis].directionPoint = PLSR_HW_DIR_POINT_NONE;

  1047.         PlsrHwAxes[axis].configuredDirectionPoint =

  1048.             PLSR_HW_DIR_POINT_NONE;

  1049. #ifdef PLSR_HOST_TEST

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

  1051. #else

  1052.         PlsrHwTimerSetCc1e(axis, 0UL);

  1053.         PlsrHwTimerSetUie(axis, 0UL);

  1054.         PlsrHwTimerSetCc1ie(axis, 0UL);

  1055.         PlsrHwTimerSetCen(axis, 0UL);

  1056. #endif

  1057.     }

  1058. 

  1059. #ifndef PLSR_HOST_TEST

  1060.     {

  1061.         GPIO_InitTypeDef gpio;

  1062.         uint32_t tim6ClockHz;

  1063.         uint16_t tim6Psc;

  1064.         uint16_t tim6Arr;

  1065. 

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

  1067.         __HAL_RCC_GPIOF_CLK_ENABLE();

  1068.         __HAL_RCC_GPIOI_CLK_ENABLE();

  1069.         __HAL_RCC_GPIOE_CLK_ENABLE();

  1070.         __HAL_RCC_GPIOG_CLK_ENABLE();

  1071.         __HAL_RCC_GPIOH_CLK_ENABLE();

  1072.         __HAL_RCC_GPIOB_CLK_ENABLE();

  1073. 

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

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

  1076. 

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

  1078.         __HAL_RCC_TIM10_CLK_ENABLE();

  1079.         __HAL_RCC_TIM11_CLK_ENABLE();

  1080.         __HAL_RCC_TIM13_CLK_ENABLE();

  1081.         __HAL_RCC_TIM14_CLK_ENABLE();

  1082.         __HAL_RCC_TIM6_CLK_ENABLE();

  1083. 

  1084.         /* Independent 10kHz control clock for S2 refreshCode=2. */

  1085.         tim6ClockHz = HAL_RCC_GetPCLK1Freq();

  1086.         if ((RCC->CFGR & RCC_CFGR_PPRE1) != RCC_CFGR_PPRE1_DIV1)

  1087.         {

  1088.             tim6ClockHz *= 2UL;

  1089.         }

  1090.         if (PlsrCalculateTimerDivider(tim6ClockHz,

  1091.                                       10000UL,

  1092.                                       &tim6Psc,

  1093.                                       &tim6Arr) != PLSR_RESULT_OK)

  1094.         {

  1095.             return PLSR_RESULT_DIVIDER_UNREPRESENTABLE;

  1096.         }

  1097.         TIM6->CR1 = 0UL;

  1098.         TIM6->DIER = 0UL;

  1099.         TIM6->PSC = tim6Psc;

  1100.         TIM6->ARR = tim6Arr;

  1101.         TIM6->EGR = TIM_EGR_UG;

  1102.         TIM6->SR = 0UL;

  1103.         TIM6->DIER = TIM_DIER_UIE;

  1104.         HAL_NVIC_SetPriority(TIM6_DAC_IRQn, 2U, 0U);

  1105.         HAL_NVIC_EnableIRQ(TIM6_DAC_IRQn);

  1106.         TIM6->CR1 = TIM_CR1_ARPE | TIM_CR1_CEN;

  1107. 

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

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

  1110.         gpio.Mode = GPIO_MODE_AF_PP;

  1111.         gpio.Pull = GPIO_NOPULL;

  1112.         gpio.Speed = GPIO_SPEED_FREQ_VERY_HIGH;

  1113.         gpio.Pin = GPIO_PIN_6 | GPIO_PIN_7;

  1114.         gpio.Alternate = 3U;

  1115.         HAL_GPIO_Init(GPIOF, &gpio);

  1116.         gpio.Pin = GPIO_PIN_8 | GPIO_PIN_9;

  1117.         gpio.Alternate = 9U;

  1118.         HAL_GPIO_Init(GPIOF, &gpio);

  1119. 

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

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

  1122.         HAL_NVIC_EnableIRQ(TIM1_UP_TIM10_IRQn);

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

  1124.         HAL_NVIC_EnableIRQ(TIM8_UP_TIM13_IRQn);

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

  1126.         HAL_NVIC_EnableIRQ(TIM1_TRG_COM_TIM11_IRQn);

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

  1128.         HAL_NVIC_EnableIRQ(TIM8_TRG_COM_TIM14_IRQn);

  1129.     }

  1130. #endif

  1131.     return PLSR_RESULT_OK;

  1132. }

  1133. 

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

  1135. {

  1136.     PLSR_HW_AXIS_STATE *state;

  1137.     uint8_t directionChanged = 0U;

  1138. 

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

  1140.     {

  1141.         return PLSR_RESULT_INVALID_ARGUMENT;

  1142.     }

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

  1144.     {

  1145.         return PLSR_RESULT_INVALID_ARGUMENT;

  1146.     }

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

  1148.     {

  1149.         return PLSR_RESULT_INVALID_ARGUMENT;

  1150.     }

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

  1152.          || (params->outputMode == PLSR_OUTPUT_CW_CCW))

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

  1154.     {

  1155.         return PLSR_RESULT_INVALID_AXIS;

  1156.     }

  1157.     state = &PlsrHwAxes[axis];

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

  1159.     {

  1160.         return PLSR_RESULT_BUSY;

  1161.     }

  1162. 

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

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

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

  1166.     {

  1167.         directionChanged =

  1168.             (state->directionPoint == PLSR_HW_DIR_POINT_NONE)

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

  1170.             || (state->directionPositive != params->directionPositive)

  1171.             || (state->directionNegativeLogic

  1172.                 != params->directionNegativeLogic);

  1173.     }

  1174. 

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

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

  1177.     state->emittedPulses = 0;

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

  1179.     state->directionPoint =

  1180.         (params->outputMode == PLSR_OUTPUT_PULSE_DIR)

  1181.             ? params->directionPoint

  1182.             : PLSR_HW_DIR_POINT_NONE;

  1183.     state->directionDelayRemainingMs =

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

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

  1186.             ? params->directionDelayMs

  1187.             : 0U;

  1188.     state->abQuarter = 0U;

  1189.     state->abFrequencyPending = 0U;

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

  1191.     {

  1192.         PlsrHwSetDirLevel(axis,

  1193.                           params->directionPositive,

  1194.                           params->directionNegativeLogic);

  1195.     }

  1196.     else

  1197.     {

  1198.         state->directionPositive =

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

  1200.         state->directionNegativeLogic = 0U;

  1201.     }

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

  1203.     {

  1204.         state->cwActiveAxis = (state->directionPositive != 0U)

  1205.                                   ? axis

  1206.                                   : PlsrHwGetPairedAxis(axis);

  1207.     }

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

  1209.                        ? PLSR_HW_STATE_DIR_SETTLING

  1210.                        : PLSR_HW_STATE_PWM_PENDING;

  1211.     return PLSR_RESULT_OK;

  1212. }

  1213. 

  1214. PLSR_RESULT PlsrHwSetFrequency(uint8_t axis, uint32_t frequencyHz)

  1215. {

  1216.     PLSR_HW_AXIS_STATE *state;

  1217. 

  1218.     if (axis >= PLSR_HW_AXIS_COUNT)

  1219.     {

  1220.         return PLSR_RESULT_INVALID_ARGUMENT;

  1221.     }

  1222.     state = &PlsrHwAxes[axis];

  1223.     if ((state->outputMode == PLSR_OUTPUT_CW_CCW)

  1224.         && (state->cwStopPending != 0U))

  1225.     {

  1226.         /* Preserve the final physical high width until its natural update

  1227.          * boundary; no later profile write may move that boundary. */

  1228.         return PLSR_RESULT_OK;

  1229.     }

  1230.     state->currentFrequencyHz = frequencyHz;

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

  1232.     {

  1233.         if (frequencyHz > 0UL)

  1234.         {

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

  1236.             {

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

  1238.                 {

  1239.                     return PLSR_RESULT_DIVIDER_UNREPRESENTABLE;

  1240.                 }

  1241.             }

  1242.             else

  1243.             {

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

  1245.                 PlsrHwConfigureActiveOutput(axis,

  1246.                                             state->outputMode,

  1247.                                             frequencyHz);

  1248.             }

  1249.         }

  1250.         else

  1251.         {

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

  1253.         }

  1254.     }

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

  1256.              && (frequencyHz > 0UL))

  1257.     {

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

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

  1260.         state->state = PLSR_HW_STATE_RUNNING;

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

  1262.     }

  1263.     return PLSR_RESULT_OK;

  1264. }

  1265. 

  1266. PLSR_RESULT PlsrHwResumePulse(uint8_t axis)

  1267. {

  1268.     PLSR_HW_AXIS_STATE *state;

  1269. 

  1270.     if (axis >= PLSR_HW_AXIS_COUNT)

  1271.     {

  1272.         return PLSR_RESULT_INVALID_ARGUMENT;

  1273.     }

  1274.     state = &PlsrHwAxes[axis];

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

  1276.         || (state->currentFrequencyHz != 0UL)

  1277.         || (state->emittedPulses >= state->targetPulses))

  1278.     {

  1279.         return PLSR_RESULT_INVALID_STATE;

  1280.     }

  1281. 

  1282.     /* PlsrHwSetFrequency(0) stopped the physical timer but deliberately kept

  1283.      * the segment counters.  PWM_PENDING makes the next non-zero control-tick

  1284.      * update take the normal clean-start path without resetting those counts. */

  1285.     state->state = PLSR_HW_STATE_PWM_PENDING;

  1286.     return PLSR_RESULT_OK;

  1287. }

  1288. 

  1289. PLSR_RESULT PlsrHwStopPulse(uint8_t axis)

  1290. {

  1291.     PLSR_HW_AXIS_STATE *state;

  1292. 

  1293.     if (axis >= PLSR_HW_AXIS_COUNT)

  1294.     {

  1295.         return PLSR_RESULT_INVALID_ARGUMENT;

  1296.     }

  1297.     state = &PlsrHwAxes[axis];

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

  1299.     {

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

  1301.         state->abQuarter = 0U;

  1302.         state->abFrequencyPending = 0U;

  1303.         state->state = PLSR_HW_STATE_IDLE;

  1304.     }

  1305.     return PLSR_RESULT_OK;

  1306. }

  1307. 

  1308. uint8_t PlsrHwIsPulseActive(uint8_t axis)

  1309. {

  1310.     if (axis >= PLSR_HW_AXIS_COUNT)

  1311.     {

  1312.         return 0U;

  1313.     }

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

  1315. }

  1316. 

  1317. PLSR_HW_STATE PlsrHwGetState(uint8_t axis)

  1318. {

  1319.     if (axis >= PLSR_HW_AXIS_COUNT)

  1320.     {

  1321.         return PLSR_HW_STATE_IDLE;

  1322.     }

  1323.     return PlsrHwAxes[axis].state;

  1324. }

  1325. 

  1326. uint32_t PlsrHwGetTimerClockHz(uint8_t axis)

  1327. {

  1328.     if (axis >= PLSR_HW_AXIS_COUNT)

  1329.     {

  1330.         return 0UL;

  1331.     }

  1332.     return PlsrHwAxisMap[axis].timerClockHz;

  1333. }

  1334. 

  1335. uint32_t PlsrHwGetCurrentFrequencyHz(uint8_t axis)

  1336. {

  1337.     if ((axis >= PLSR_HW_AXIS_COUNT)

  1338.         || (PlsrHwAxes[axis].state != PLSR_HW_STATE_RUNNING))

  1339.     {

  1340.         return 0UL;

  1341.     }

  1342.     return PlsrHwAxes[axis].currentFrequencyHz;

  1343. }

  1344. 

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

  1346. int64_t PlsrHwGetEmittedPulses(uint8_t axis)

  1347. {

  1348.     int64_t emittedPulses;

  1349. 

  1350.     if (axis >= PLSR_HW_AXIS_COUNT)

  1351.     {

  1352.         return 0;

  1353.     }

  1354. #ifdef PLSR_HOST_TEST

  1355.     emittedPulses = PlsrHwAxes[axis].emittedPulses;

  1356. #else

  1357.     {

  1358.         uint32_t interruptState = __get_PRIMASK();

  1359. 

  1360.         __disable_irq();

  1361.         __DMB();

  1362.         emittedPulses = PlsrHwAxes[axis].emittedPulses;

  1363.         __DMB();

  1364.         if (interruptState == 0UL)

  1365.         {

  1366.             __enable_irq();

  1367.         }

  1368.     }

  1369. #endif

  1370.     return emittedPulses;

  1371. }

  1372. 

  1373. uint8_t PlsrHwIsAbStartupPriming(uint8_t axis)

  1374. {

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

  1376.     {

  1377.         return 0U;

  1378.     }

  1379.     return PlsrHwAxes[axis].abStartupPriming;

  1380. }

  1381. 

  1382. void PlsrHwTick(uint8_t axis)

  1383. {

  1384.     PLSR_HW_AXIS_STATE *state;

  1385. 

  1386.     if (axis >= PLSR_HW_AXIS_COUNT)

  1387.     {

  1388.         return;

  1389.     }

  1390.     state = &PlsrHwAxes[axis];

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

  1392.     PlsrHwDbgCapture(axis, 3U);

  1393.     switch (state->state)

  1394.     {

  1395.         case PLSR_HW_STATE_DIR_SETTLING:

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

  1397.             {

  1398.                 state->directionDelayRemainingMs--;

  1399.             }

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

  1401.             {

  1402.                 state->state = PLSR_HW_STATE_PWM_PENDING;

  1403.             }

  1404.             break;

  1405. 

  1406.         case PLSR_HW_STATE_PWM_PENDING:

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

  1408.             {

  1409.                 PlsrHwConfigureActiveOutput(axis,

  1410.                                             state->outputMode,

  1411.                                             state->currentFrequencyHz);

  1412.                 state->state = PLSR_HW_STATE_RUNNING;

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

  1414.             }

  1415.             break;

  1416. 

  1417.         default:

  1418.             break;

  1419.     }

  1420. }

  1421. 

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

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

  1424. void PlsrHwOnTimerUpdate(uint8_t axis)

  1425. {

  1426.     PLSR_HW_AXIS_STATE *state;

  1427.     uint8_t ownerAxis;

  1428.     uint8_t hasCc1;

  1429. 

  1430.     if (axis >= PLSR_HW_AXIS_COUNT)

  1431.     {

  1432.         return;

  1433.     }

  1434. 

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

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

  1437.     hasCc1 = PlsrHwTimerHasCc1if(axis);

  1438.     if (hasCc1 != 0U)

  1439.     {

  1440.         PlsrHwTimerClearCc1if(axis);

  1441.     }

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

  1443.     state = &PlsrHwAxes[ownerAxis];

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

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

  1446.     {

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

  1448.         {

  1449.             PlsrHwTimerClearUif(axis);

  1450.         }

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

  1452.         {

  1453.             return;

  1454.         }

  1455.         if (state->abStartupPriming != 0U)

  1456.         {

  1457.             /* F407 首次切换 OC 模式时 OC1REF 初态不可直接作为物理AB相。

  1458.              * GPIO 保持 00 隐藏首个内部周期；落后相下降沿是真实 00

  1459.              * 边界，此时再交还 AF，且该隐藏周期绝不能计入 emitted。 */

  1460.             state->abStartupPriming = 0U;

  1461.             state->abOutputPrimed = 1U;

  1462. #ifndef PLSR_HOST_TEST

  1463.             PlsrHwReleasePulsePin(ownerAxis);

  1464.             PlsrHwReleasePulsePin(PlsrHwGetPairedAxis(ownerAxis));

  1465. #endif

  1466.             return;

  1467.         }

  1468.         state->emittedPulses++;

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

  1470.         {

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

  1472.             state->abQuarter = 0U;

  1473.             state->abFrequencyPending = 0U;

  1474.             state->state = PLSR_HW_STATE_DONE;

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

  1476.         }

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

  1478.         {

  1479.             uint16_t basePsc = state->abPendingBasePsc;

  1480.             uint16_t pairPsc = state->abPendingPairPsc;

  1481.             uint16_t arr = state->abPendingArr;

  1482. 

  1483.             state->abFrequencyPending = 0U;

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

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

  1486.             PlsrHwBeginAbOutput(ownerAxis, 4U);

  1487.         }

  1488.         return;

  1489.     }

  1490. 

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

  1492.         && (state->outputMode == PLSR_OUTPUT_CW_CCW))

  1493.     {

  1494.         uint8_t hasUif = PlsrHwTimerHasUif(axis);

  1495. 

  1496.         if (hasUif != 0U)

  1497.         {

  1498.             PlsrHwTimerClearUif(axis);

  1499.         }

  1500.         if (axis != state->cwActiveAxis)

  1501.         {

  1502.             return;

  1503.         }

  1504.         if (hasCc1 != 0U)

  1505.         {

  1506.             state->emittedPulses++;

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

  1508.             {

  1509.                 /* The board output is inverted relative to OC1REF: CC1 is

  1510.                  * the physical rising edge. Arm the tail here, then stop on

  1511.                  * the following update (physical falling edge). */

  1512.                 state->cwStopPending = 1U;

  1513.                 PlsrHwTimerSetCc1ie(axis, 0UL);

  1514.                 PlsrHwTimerClearUif(axis);

  1515.                 PlsrHwTimerSetUie(axis, 1UL);

  1516.             }

  1517.             return;

  1518.         }

  1519.         if ((hasUif != 0U) && (state->cwStopPending != 0U))

  1520.         {

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

  1522.             state->state = PLSR_HW_STATE_DONE;

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

  1524.         }

  1525.         return;

  1526.     }

  1527. 

  1528.     if (hasCc1 != 0U)

  1529.     {

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

  1531.         return;

  1532.     }

  1533. 

  1534.     state = &PlsrHwAxes[axis];

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

  1536.     {

  1537.         return;

  1538.     }

  1539.     PlsrHwTimerClearUif(axis);

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

  1541.     {

  1542.         return;

  1543.     }

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

  1545.     {

  1546.         return;

  1547.     }

  1548. 

  1549.     state->emittedPulses++;

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

  1551.     {

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

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

  1554.         state->state = PLSR_HW_STATE_DONE;

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

  1556.     }

  1557. }

  1558. 

  1559. #ifdef PLSR_HOST_TEST

  1560. uint32_t PlsrHwTestGetArr(uint8_t axis)

  1561. {

  1562.     return PlsrHwTimers[axis].arr;

  1563. }

  1564. 

  1565. uint32_t PlsrHwTestGetCcr(uint8_t axis)

  1566. {

  1567.     return PlsrHwTimers[axis].ccr1;

  1568. }

  1569. 

  1570. uint32_t PlsrHwTestGetCnt(uint8_t axis)

  1571. {

  1572.     return PlsrHwTimers[axis].cnt;

  1573. }

  1574. 

  1575. uint32_t PlsrHwTestGetCcmr1(uint8_t axis)

  1576. {

  1577.     return PlsrHwTimers[axis].ccmr1;

  1578. }

  1579. 

  1580. uint32_t PlsrHwTestGetCr1(uint8_t axis)

  1581. {

  1582.     return PlsrHwTimers[axis].cr1;

  1583. }

  1584. 

  1585. uint32_t PlsrHwTestGetPsc(uint8_t axis)

  1586. {

  1587.     return PlsrHwTimers[axis].psc;

  1588. }

  1589. 

  1590. uint8_t PlsrHwTestGetPwmEnabled(uint8_t axis)

  1591. {

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

  1593.                ? 1U

  1594.                : 0U;

  1595. }

  1596. 

  1597. uint8_t PlsrHwTestGetDirLevel(uint8_t axis)

  1598. {

  1599.     return PlsrHwTimers[axis].dirLevel;

  1600. }

  1601. 

  1602. uint8_t PlsrHwTestGetAbPhaseA(uint8_t axis)

  1603. {

  1604.     const PLSR_HW_AXIS_STATE *state;

  1605. 

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

  1607.     {

  1608.         return 0U;

  1609.     }

  1610.     state = &PlsrHwAxes[axis];

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

  1612.     {

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

  1614.                    ? 1U

  1615.                    : 0U;

  1616.     }

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

  1618.                ? 1U

  1619.                : 0U;

  1620. }

  1621. 

  1622. uint8_t PlsrHwTestGetAbPhaseB(uint8_t axis)

  1623. {

  1624.     const PLSR_HW_AXIS_STATE *state;

  1625. 

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

  1627.     {

  1628.         return 0U;

  1629.     }

  1630.     state = &PlsrHwAxes[axis];

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

  1632.     {

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

  1634.                    ? 1U

  1635.                    : 0U;

  1636.     }

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

  1638.                ? 1U

  1639.                : 0U;

  1640. }

  1641. 

  1642. uint8_t PlsrHwTestGetAbQuarter(uint8_t axis)

  1643. {

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

  1645.     {

  1646.         return 0U;

  1647.     }

  1648.     return PlsrHwAxes[axis].abQuarter;

  1649. }

  1650. 

  1651. void PlsrHwTestAdvanceAbQuarter(uint8_t axis)

  1652. {

  1653.     PLSR_HW_AXIS_STATE *state;

  1654. 

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

  1656.     {

  1657.         return;

  1658.     }

  1659.     state = &PlsrHwAxes[axis];

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

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

  1662.     {

  1663.         return;

  1664.     }

  1665. 

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

  1667.                                  % PLSR_HW_AB_QUARTER_COUNT);

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

  1669.     {

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

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

  1672.         PlsrHwOnTimerUpdate(state->abCountAxis);

  1673.     }

  1674. }

  1675. 

  1676. void PlsrHwTestTriggerUpdate(uint8_t axis)

  1677. {

  1678.     if (axis < PLSR_HW_AXIS_COUNT)

  1679.     {

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

  1681.     }

  1682.     PlsrHwOnTimerUpdate(axis);

  1683. }

  1684. 

  1685. void PlsrHwTestTriggerCompare(uint8_t axis)

  1686. {

  1687.     if (axis < PLSR_HW_AXIS_COUNT)

  1688.     {

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

  1690.     }

  1691.     PlsrHwOnTimerUpdate(axis);

  1692. }

  1693. #endif

  1694. 

  1695. #ifndef PLSR_HOST_TEST

  1696. void TIM1_UP_TIM10_IRQHandler(void)

  1697. {

  1698.     PlsrHwOnTimerUpdate(0U);

  1699. }

  1700. 

  1701. void TIM8_UP_TIM13_IRQHandler(void)

  1702. {

  1703.     PlsrHwOnTimerUpdate(1U);

  1704. }

  1705. 

  1706. void TIM1_TRG_COM_TIM11_IRQHandler(void)

  1707. {

  1708.     PlsrHwOnTimerUpdate(2U);

  1709. }

  1710. 

  1711. void TIM8_TRG_COM_TIM14_IRQHandler(void)

  1712. {

  1713.     PlsrHwOnTimerUpdate(3U);

  1714. }

  1715. 

  1716. void TIM6_DAC_IRQHandler(void)

  1717. {

  1718.     if ((TIM6->SR & TIM_SR_UIF) != 0UL)

  1719.     {

  1720.         TIM6->SR &= ~TIM_SR_UIF;

  1721.         PlsrControlTick100us();

  1722.     }

  1723. }

  1724. #endif