yuwenhao
/
Modbus-rtu
1
0
フォーク 0
コード 課題 0 プルリクエスト 0 リリース 0 Wiki アクティビティ
選択できるのは25トピックまでです。 トピックは、先頭が英数字で、英数字とダッシュ('-')を使用した35文字以内のものにしてください。
38 コミット
3 ブランチ
138 MiB
 
 
 
 
 
 
ツリー: 6c61682617
ブランチ タグ
${ item.name }
ブランチ ${ searchTerm } を作成
'6c61682617' から
${ noResults }
Modbus-rtu/PLSR/Src/plsr_hal_f407.c

1407 行
39 KiB
Raw Blame 履歴 

  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.     uint8_t abStartupPriming;

  152.     uint8_t abOutputPrimed;

  153.     uint16_t abActiveBasePsc;

  154.     uint16_t abActivePairPsc;

  155.     uint16_t abActiveArr;

  156.     uint16_t abPendingBasePsc;

  157.     uint16_t abPendingPairPsc;

  158.     uint16_t abPendingArr;

  159.     uint8_t abFrequencyPending;

  160. } PLSR_HW_AXIS_STATE;

  161. 

  162. static PLSR_HW_AXIS_STATE PlsrHwAxes[PLSR_HW_AXIS_COUNT];

  163. 

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

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

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

  167. #ifndef PLSR_HOST_TEST

  168. typedef struct

  169. {

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

  171.     uint32_t psc;

  172.     uint32_t arr;

  173.     uint32_t ccr;

  174.     uint32_t cnt;

  175.     uint32_t frequencyHz;

  176.     int64_t emittedPulses;

  177. } PLSR_HW_DBG_SNAP;

  178. 

  179. static PLSR_HW_DBG_SNAP PlsrHwDbgSnap[PLSR_HW_DBG_SNAPSHOT_COUNT];

  180. static volatile uint16_t PlsrHwDbgCount;

  181. 

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

  183. {

  184.     if (axis != 0U)

  185.     {

  186.         return;

  187.     }

  188.     if (reason == 0U)

  189.     {

  190.         PlsrHwDbgCount = 0U;

  191.     }

  192.     if (PlsrHwDbgCount < PLSR_HW_DBG_SNAPSHOT_COUNT)

  193.     {

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

  195.         snap->reason = reason;

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

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

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

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

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

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

  202.     }

  203. }

  204. #else

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

  206. #endif

  207. 

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

  209. 

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

  211. {

  212. #ifdef PLSR_HOST_TEST

  213.     PlsrHwTimers[axis].arr = value;

  214. #else

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

  216. #endif

  217. }

  218. 

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

  220. {

  221. #ifdef PLSR_HOST_TEST

  222.     PlsrHwTimers[axis].psc = value;

  223. #else

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

  225. #endif

  226. }

  227. 

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

  229. {

  230. #ifdef PLSR_HOST_TEST

  231.     PlsrHwTimers[axis].ccr1 = value;

  232. #else

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

  234. #endif

  235. }

  236. 

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

  238. {

  239. #ifdef PLSR_HOST_TEST

  240.     PlsrHwTimers[axis].cnt = value;

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

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

  243.     {

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

  245.     }

  246. #else

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

  248. #endif

  249. }

  250. 

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

  252. {

  253. #ifdef PLSR_HOST_TEST

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

  255. #else

  256.     if (value != 0UL)

  257.     {

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

  259.     }

  260.     else

  261.     {

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

  263.     }

  264. #endif

  265. }

  266. 

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

  268. {

  269. #ifdef PLSR_HOST_TEST

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

  271. #else

  272.     if (value != 0UL)

  273.     {

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

  275.     }

  276.     else

  277.     {

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

  279.     }

  280. #endif

  281. }

  282. 

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

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

  285. static void PlsrHwTimerSetPwmMode1(uint8_t axis)

  286. {

  287. #ifdef PLSR_HOST_TEST

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

  289. #else

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

  291.                                        | TIM_CCMR1_OC1PE;

  292. #endif

  293. }

  294. 

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

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

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

  298. static void PlsrHwTimerSetForcedInactive(uint8_t axis)

  299. {

  300. #ifdef PLSR_HOST_TEST

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

  302. #else

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

  304.                                        | TIM_CCMR1_OC1PE;

  305. #endif

  306. }

  307. 

  308. static void PlsrHwTimerSetFrozen(uint8_t axis)

  309. {

  310. #ifdef PLSR_HOST_TEST

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

  312. #else

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

  314. #endif

  315. }

  316. 

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

  318. {

  319. #ifdef PLSR_HOST_TEST

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

  321. #else

  322.     if (value != 0UL)

  323.     {

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

  325.     }

  326.     else

  327.     {

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

  329.     }

  330. #endif

  331. }

  332. 

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

  334. {

  335. #ifdef PLSR_HOST_TEST

  336.     PlsrHwTimers[axis].dier =

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

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

  339.     if ((value != 0UL)

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

  341.     {

  342.         PlsrHwOnTimerUpdate(axis);

  343.     }

  344. #else

  345.     if (value != 0UL)

  346.     {

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

  348.     }

  349.     else

  350.     {

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

  352.     }

  353. #endif

  354. }

  355. 

  356. static void PlsrHwTimerClearUif(uint8_t axis)

  357. {

  358. #ifdef PLSR_HOST_TEST

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

  360. #else

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

  362. #endif

  363. }

  364. 

  365. static uint8_t PlsrHwTimerHasUif(uint8_t axis)

  366. {

  367. #ifdef PLSR_HOST_TEST

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

  369.                ? 1U

  370.                : 0U;

  371. #else

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

  373. #endif

  374. }

  375. 

  376. static void PlsrHwTimerClearCc1if(uint8_t axis)

  377. {

  378. #ifdef PLSR_HOST_TEST

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

  380. #else

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

  382. #endif

  383. }

  384. 

  385. static uint8_t PlsrHwTimerHasCc1if(uint8_t axis)

  386. {

  387. #ifdef PLSR_HOST_TEST

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

  389.                ? 1U

  390.                : 0U;

  391. #else

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

  393. #endif

  394. }

  395. 

  396. /* ---- DIR 输出 ----

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

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

  399. 

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

  401. {

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

  403. 

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

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

  406.     {

  407.         return;

  408.     }

  409. #ifdef PLSR_HOST_TEST

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

  411. #else

  412.     if (state->directionPoint < PLSR_HW_OUTPUT_POINT_COUNT)

  413.     {

  414.         const PLSR_HW_OUTPUT_PIN *pin =

  415.             &PlsrHwOutputPins[state->directionPoint];

  416.         GPIO_InitTypeDef gpio;

  417. 

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

  419.         {

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

  421.             gpio.Pin = pin->pin;

  422.             gpio.Mode = GPIO_MODE_OUTPUT_PP;

  423.             gpio.Pull = GPIO_NOPULL;

  424.             gpio.Speed = GPIO_SPEED_FREQ_VERY_HIGH;

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

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

  427.             HAL_GPIO_WritePin(pin->port,

  428.                               pin->pin,

  429.                               (positive != 0U) ? GPIO_PIN_RESET

  430.                                                : GPIO_PIN_SET);

  431.         }

  432.     }

  433. #endif

  434. }

  435. 

  436. /* ---- PWM 启停 ----

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

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

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

  440. 

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

  442. {

  443. #ifdef PLSR_HOST_TEST

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

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

  446. #else

  447.     if (value != 0UL)

  448.     {

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

  450.     }

  451.     else

  452.     {

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

  454.     }

  455. #endif

  456. }

  457. 

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

  459. static void PlsrHwTimerSetUg(uint8_t axis)

  460. {

  461. #ifdef PLSR_HOST_TEST

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

  463. #else

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

  465. #endif

  466. }

  467. 

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

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

  470. {

  471.     uint16_t psc;

  472.     uint16_t arr;

  473. 

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

  475.                                   frequencyHz,

  476.                                   &psc,

  477.                                   &arr) != PLSR_RESULT_OK)

  478.     {

  479.         return;

  480.     }

  481.     PlsrHwTimerSetPsc(axis, psc);

  482.     PlsrHwTimerSetArr(axis, arr);

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

  484.     PlsrHwTimerSetPwmMode1(axis);

  485.     PlsrHwTimerSetArpe(axis, 1UL);

  486. }

  487. 

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

  489. static void PlsrHwPwmBegin(uint8_t axis)

  490. {

  491.     PlsrHwTimerSetUg(axis);

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

  493.     PlsrHwTimerClearUif(axis);

  494.     PlsrHwTimerClearCc1if(axis);

  495.     PlsrHwDbgCapture(axis, 0U);

  496.     PlsrHwTimerSetCc1ie(axis, 0UL);

  497.     PlsrHwTimerSetUie(axis, 1UL);

  498.     PlsrHwTimerSetCc1e(axis, 1UL);

  499.     PlsrHwTimerSetCen(axis, 1UL);

  500. }

  501. 

  502. static void PlsrHwStopPwmTimer(uint8_t axis)

  503. {

  504.     PlsrHwTimerSetCc1e(axis, 0UL);

  505.     PlsrHwTimerSetUie(axis, 0UL);

  506.     PlsrHwTimerSetCc1ie(axis, 0UL);

  507.     PlsrHwTimerSetCen(axis, 0UL);

  508.     PlsrHwTimerClearUif(axis);

  509.     PlsrHwTimerClearCc1if(axis);

  510. }

  511. 

  512. static uint8_t PlsrHwIsAbBaseAxis(uint8_t axis)

  513. {

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

  515. }

  516. 

  517. static uint8_t PlsrHwGetPairedAxis(uint8_t axis)

  518. {

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

  520. }

  521. 

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

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

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

  525. static uint8_t PlsrHwCalculateAbDividers(uint8_t axis,

  526.                                          uint32_t frequencyHz,

  527.                                          uint16_t *basePsc,

  528.                                          uint16_t *pairPsc,

  529.                                          uint16_t *arr)

  530. {

  531.     uint8_t pairAxis = PlsrHwGetPairedAxis(axis);

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

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

  534.     uint64_t ratio;

  535.     uint64_t pairDivider;

  536.     uint64_t baseDivider;

  537.     uint64_t periodTicks;

  538. 

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

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

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

  542.     {

  543.         return 0U;

  544.     }

  545.     ratio = baseClock / pairClock;

  546.     if (ratio == 0UL)

  547.     {

  548.         return 0U;

  549.     }

  550.     pairDivider = (pairClock

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

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

  553.     if (pairDivider == 0UL)

  554.     {

  555.         pairDivider = 1UL;

  556.     }

  557.     baseDivider = pairDivider * ratio;

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

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

  560.     {

  561.         return 0U;

  562.     }

  563.     periodTicks = (pairClock

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

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

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

  567.     {

  568.         return 0U;

  569.     }

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

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

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

  573.     return 1U;

  574. }

  575. 

  576. static void PlsrHwLoadAbPwm(uint8_t axis,

  577.                             uint16_t basePsc,

  578.                             uint16_t pairPsc,

  579.                             uint16_t arr)

  580. {

  581.     uint8_t pairAxis = PlsrHwGetPairedAxis(axis);

  582.     uint32_t compare;

  583. 

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

  585.     PlsrHwTimerSetPsc(axis, basePsc);

  586.     PlsrHwTimerSetPsc(pairAxis, pairPsc);

  587.     PlsrHwTimerSetArr(axis, arr);

  588.     PlsrHwTimerSetArr(pairAxis, arr);

  589.     PlsrHwTimerSetCcr(axis, compare);

  590.     PlsrHwTimerSetCcr(pairAxis, compare);

  591.     PlsrHwTimerSetPwmMode1(axis);

  592.     PlsrHwTimerSetPwmMode1(pairAxis);

  593.     PlsrHwTimerSetArpe(axis, 1UL);

  594.     PlsrHwTimerSetArpe(pairAxis, 1UL);

  595.     PlsrHwAxes[axis].abActiveBasePsc = basePsc;

  596.     PlsrHwAxes[axis].abActivePairPsc = pairPsc;

  597.     PlsrHwAxes[axis].abActiveArr = arr;

  598. }

  599. 

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

  601. {

  602.     uint16_t basePsc;

  603.     uint16_t pairPsc;

  604.     uint16_t arr;

  605. 

  606.     if (PlsrHwCalculateAbDividers(axis,

  607.                                   frequencyHz,

  608.                                   &basePsc,

  609.                                   &pairPsc,

  610.                                   &arr) == 0U)

  611.     {

  612.         return 0U;

  613.     }

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

  615.     return 1U;

  616. }

  617. 

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

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

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

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

  622. {

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

  624.     uint16_t basePsc;

  625.     uint16_t pairPsc;

  626.     uint16_t arr;

  627. #ifndef PLSR_HOST_TEST

  628.     uint32_t interruptState;

  629. #endif

  630. 

  631.     if (PlsrHwCalculateAbDividers(axis,

  632.                                   frequencyHz,

  633.                                   &basePsc,

  634.                                   &pairPsc,

  635.                                   &arr) == 0U)

  636.     {

  637.         return 0U;

  638.     }

  639. #ifndef PLSR_HOST_TEST

  640.     interruptState = __get_PRIMASK();

  641.     __disable_irq();

  642.     __DMB();

  643. #endif

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

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

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

  647.     {

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

  649.         state->abFrequencyPending = 0U;

  650.     }

  651.     else

  652.     {

  653.         state->abPendingBasePsc = basePsc;

  654.         state->abPendingPairPsc = pairPsc;

  655.         state->abPendingArr = arr;

  656.         state->abFrequencyPending = 1U;

  657.     }

  658. #ifndef PLSR_HOST_TEST

  659.     __DMB();

  660.     if (interruptState == 0UL)

  661.     {

  662.         __enable_irq();

  663.     }

  664. #endif

  665.     return 1U;

  666. }

  667. 

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

  669. {

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

  671.     uint8_t pairAxis = PlsrHwGetPairedAxis(axis);

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

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

  674.     uint32_t periodTicks;

  675.     uint32_t leadStart;

  676.     uint32_t lagStart;

  677. #ifndef PLSR_HOST_TEST

  678.     uint32_t interruptState;

  679. #else

  680.     (void)debugReason;

  681. #endif

  682. 

  683. #ifdef PLSR_HOST_TEST

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

  685. #else

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

  687. #endif

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

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

  690.     lagStart = periodTicks / 2UL;

  691.     state->abCountAxis = lagAxis;

  692.     state->abQuarter = 0U;

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

  694. 

  695. #ifndef PLSR_HOST_TEST

  696.     interruptState = __get_PRIMASK();

  697.     __disable_irq();

  698.     __DMB();

  699.     PlsrHwHoldPulsePinLow(axis);

  700.     PlsrHwHoldPulsePinLow(pairAxis);

  701. #endif

  702.     PlsrHwTimerSetCen(axis, 0UL);

  703.     PlsrHwTimerSetCen(pairAxis, 0UL);

  704.     PlsrHwTimerSetCc1e(axis, 0UL);

  705.     PlsrHwTimerSetCc1e(pairAxis, 0UL);

  706.     PlsrHwTimerSetUie(axis, 0UL);

  707.     PlsrHwTimerSetUie(pairAxis, 0UL);

  708.     PlsrHwTimerSetCc1ie(axis, 0UL);

  709.     PlsrHwTimerSetCc1ie(pairAxis, 0UL);

  710.     PlsrHwTimerSetForcedInactive(axis);

  711.     PlsrHwTimerSetForcedInactive(pairAxis);

  712.     PlsrHwTimerSetFrozen(axis);

  713.     PlsrHwTimerSetFrozen(pairAxis);

  714.     PlsrHwTimerSetUg(axis);

  715.     PlsrHwTimerSetUg(pairAxis);

  716.     PlsrHwTimerClearUif(axis);

  717.     PlsrHwTimerClearUif(pairAxis);

  718.     PlsrHwTimerClearCc1if(axis);

  719.     PlsrHwTimerClearCc1if(pairAxis);

  720.     PlsrHwTimerSetCnt(leadAxis, leadStart);

  721.     PlsrHwTimerSetCnt(lagAxis, lagStart);

  722. #ifdef PLSR_HOST_TEST

  723.     PlsrHwTimerSetCc1e(axis, 1UL);

  724.     PlsrHwTimerSetCc1e(pairAxis, 1UL);

  725.     PlsrHwTimerSetPwmMode1(axis);

  726.     PlsrHwTimerSetPwmMode1(pairAxis);

  727.     PlsrHwTimerClearCc1if(axis);

  728.     PlsrHwTimerClearCc1if(pairAxis);

  729.     PlsrHwTimerSetCen(axis, 1UL);

  730.     PlsrHwTimerSetCen(pairAxis, 1UL);

  731.     PlsrHwTimerClearCc1if(axis);

  732.     PlsrHwTimerClearCc1if(pairAxis);

  733.     PlsrHwTimerSetCc1ie(lagAxis, 1UL);

  734. #else

  735.     PlsrHwTimerSetCc1e(axis, 1UL);

  736.     PlsrHwTimerSetCc1e(pairAxis, 1UL);

  737.     PlsrHwTimerSetPwmMode1(axis);

  738.     PlsrHwTimerSetPwmMode1(pairAxis);

  739.     PlsrHwTimerClearCc1if(axis);

  740.     PlsrHwTimerClearCc1if(pairAxis);

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

  742.     {

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

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

  745.         PlsrHwReleasePulsePin(axis);

  746.         PlsrHwReleasePulsePin(pairAxis);

  747.     }

  748.     PlsrHwTimerSetCen(axis, 1UL);

  749.     PlsrHwTimerSetCen(pairAxis, 1UL);

  750.     PlsrHwTimerClearCc1if(axis);

  751.     PlsrHwTimerClearCc1if(pairAxis);

  752.     PlsrHwTimerSetCc1ie(lagAxis, 1UL);

  753.     __DMB();

  754.     if (interruptState == 0UL)

  755.     {

  756.         __enable_irq();

  757.     }

  758. #endif

  759.     PlsrHwDbgCapture(axis, debugReason);

  760. }

  761. 

  762. static void PlsrHwConfigureActiveOutput(uint8_t axis,

  763.                                         PLSR_OUTPUT_MODE outputMode,

  764.                                         uint32_t frequencyHz)

  765. {

  766.     if (outputMode == PLSR_OUTPUT_AB)

  767.     {

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

  769.     }

  770.     else

  771.     {

  772.         PlsrHwConfigurePwm(axis, frequencyHz);

  773.     }

  774. }

  775. 

  776. static void PlsrHwBeginActiveOutput(uint8_t axis,

  777.                                     PLSR_OUTPUT_MODE outputMode)

  778. {

  779.     if (outputMode == PLSR_OUTPUT_AB)

  780.     {

  781.         PlsrHwBeginAbOutput(axis, 0U);

  782.     }

  783.     else

  784.     {

  785.         PlsrHwPwmBegin(axis);

  786.     }

  787. }

  788. 

  789. static void PlsrHwStopActiveOutput(uint8_t axis,

  790.                                    PLSR_OUTPUT_MODE outputMode)

  791. {

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

  793.     {

  794.         uint8_t pairAxis = PlsrHwGetPairedAxis(axis);

  795. #ifndef PLSR_HOST_TEST

  796.         uint32_t interruptState = __get_PRIMASK();

  797. 

  798.         __disable_irq();

  799.         __DMB();

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

  801.         PlsrHwHoldPulsePinLow(axis);

  802.         PlsrHwHoldPulsePinLow(pairAxis);

  803. #endif

  804.         PlsrHwStopPwmTimer(axis);

  805.         PlsrHwStopPwmTimer(pairAxis);

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

  807. #ifndef PLSR_HOST_TEST

  808.         __DMB();

  809.         if (interruptState == 0UL)

  810.         {

  811.             __enable_irq();

  812.         }

  813. #endif

  814.     }

  815.     else

  816.     {

  817.         PlsrHwStopPwmTimer(axis);

  818.     }

  819. }

  820. 

  821. uint8_t PlsrHwResolveDirectionPoint(uint8_t pointNumber)

  822. {

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

  824.     const uint32_t validOutputMask = 0x0013FCFFUL;

  825. 

  826.     if (pointNumber >= PLSR_HW_OUTPUT_POINT_COUNT)

  827.     {

  828.         return 0U;

  829.     }

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

  831.     {

  832.         return 0U;

  833.     }

  834. #ifndef PLSR_HOST_TEST

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

  836.     {

  837.         return 0U;

  838.     }

  839. #endif

  840.     return 1U;

  841. }

  842. 

  843. PLSR_RESULT PlsrHwInit(void)

  844. {

  845.     uint8_t axis;

  846. 

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

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

  849.     {

  850.         PlsrHwAxes[axis].state = PLSR_HW_STATE_IDLE;

  851.         PlsrHwAxes[axis].directionPoint = PLSR_HW_DIR_POINT_NONE;

  852. #ifdef PLSR_HOST_TEST

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

  854. #else

  855.         PlsrHwTimerSetCc1e(axis, 0UL);

  856.         PlsrHwTimerSetUie(axis, 0UL);

  857.         PlsrHwTimerSetCc1ie(axis, 0UL);

  858.         PlsrHwTimerSetCen(axis, 0UL);

  859. #endif

  860.     }

  861. 

  862. #ifndef PLSR_HOST_TEST

  863.     {

  864.         GPIO_InitTypeDef gpio;

  865. 

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

  867.         __HAL_RCC_GPIOF_CLK_ENABLE();

  868.         __HAL_RCC_GPIOI_CLK_ENABLE();

  869.         __HAL_RCC_GPIOE_CLK_ENABLE();

  870.         __HAL_RCC_GPIOG_CLK_ENABLE();

  871.         __HAL_RCC_GPIOH_CLK_ENABLE();

  872.         __HAL_RCC_GPIOB_CLK_ENABLE();

  873. 

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

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

  876. 

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

  878.         __HAL_RCC_TIM10_CLK_ENABLE();

  879.         __HAL_RCC_TIM11_CLK_ENABLE();

  880.         __HAL_RCC_TIM13_CLK_ENABLE();

  881.         __HAL_RCC_TIM14_CLK_ENABLE();

  882. 

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

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

  885.         gpio.Mode = GPIO_MODE_AF_PP;

  886.         gpio.Pull = GPIO_NOPULL;

  887.         gpio.Speed = GPIO_SPEED_FREQ_VERY_HIGH;

  888.         gpio.Pin = GPIO_PIN_6 | GPIO_PIN_7;

  889.         gpio.Alternate = 3U;

  890.         HAL_GPIO_Init(GPIOF, &gpio);

  891.         gpio.Pin = GPIO_PIN_8 | GPIO_PIN_9;

  892.         gpio.Alternate = 9U;

  893.         HAL_GPIO_Init(GPIOF, &gpio);

  894. 

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

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

  897.         HAL_NVIC_EnableIRQ(TIM1_UP_TIM10_IRQn);

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

  899.         HAL_NVIC_EnableIRQ(TIM8_UP_TIM13_IRQn);

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

  901.         HAL_NVIC_EnableIRQ(TIM1_TRG_COM_TIM11_IRQn);

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

  903.         HAL_NVIC_EnableIRQ(TIM8_TRG_COM_TIM14_IRQn);

  904.     }

  905. #endif

  906.     return PLSR_RESULT_OK;

  907. }

  908. 

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

  910. {

  911.     PLSR_HW_AXIS_STATE *state;

  912.     uint8_t directionChanged = 0U;

  913. 

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

  915.     {

  916.         return PLSR_RESULT_INVALID_ARGUMENT;

  917.     }

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

  919.     {

  920.         return PLSR_RESULT_INVALID_ARGUMENT;

  921.     }

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

  923.     {

  924.         return PLSR_RESULT_INVALID_ARGUMENT;

  925.     }

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

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

  928.     {

  929.         return PLSR_RESULT_INVALID_AXIS;

  930.     }

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

  932.     {

  933.         return PLSR_RESULT_NOT_SUPPORTED;

  934.     }

  935.     state = &PlsrHwAxes[axis];

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

  937.     {

  938.         return PLSR_RESULT_BUSY;

  939.     }

  940. 

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

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

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

  944.     {

  945.         directionChanged =

  946.             (state->directionPoint == PLSR_HW_DIR_POINT_NONE)

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

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

  949.     }

  950. 

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

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

  953.     state->emittedPulses = 0;

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

  955.     state->directionPoint =

  956.         (params->outputMode == PLSR_OUTPUT_PULSE_DIR)

  957.             ? params->directionPoint

  958.             : PLSR_HW_DIR_POINT_NONE;

  959.     state->directionDelayRemainingMs =

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

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

  962.             ? params->directionDelayMs

  963.             : 0U;

  964.     state->abQuarter = 0U;

  965.     state->abFrequencyPending = 0U;

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

  967.     {

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

  969.     }

  970.     else

  971.     {

  972.         state->directionPositive =

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

  974.     }

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

  976.                        ? PLSR_HW_STATE_DIR_SETTLING

  977.                        : PLSR_HW_STATE_PWM_PENDING;

  978.     return PLSR_RESULT_OK;

  979. }

  980. 

  981. PLSR_RESULT PlsrHwSetFrequency(uint8_t axis, uint32_t frequencyHz)

  982. {

  983.     PLSR_HW_AXIS_STATE *state;

  984. 

  985.     if (axis >= PLSR_HW_AXIS_COUNT)

  986.     {

  987.         return PLSR_RESULT_INVALID_ARGUMENT;

  988.     }

  989.     state = &PlsrHwAxes[axis];

  990.     state->currentFrequencyHz = frequencyHz;

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

  992.     {

  993.         if (frequencyHz > 0UL)

  994.         {

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

  996.             {

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

  998.                 {

  999.                     return PLSR_RESULT_DIVIDER_UNREPRESENTABLE;

  1000.                 }

  1001.             }

  1002.             else

  1003.             {

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

  1005.                 PlsrHwConfigureActiveOutput(axis,

  1006.                                             state->outputMode,

  1007.                                             frequencyHz);

  1008.             }

  1009.         }

  1010.         else

  1011.         {

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

  1013.         }

  1014.     }

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

  1016.              && (frequencyHz > 0UL))

  1017.     {

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

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

  1020.         state->state = PLSR_HW_STATE_RUNNING;

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

  1022.     }

  1023.     return PLSR_RESULT_OK;

  1024. }

  1025. 

  1026. PLSR_RESULT PlsrHwStopPulse(uint8_t axis)

  1027. {

  1028.     PLSR_HW_AXIS_STATE *state;

  1029. 

  1030.     if (axis >= PLSR_HW_AXIS_COUNT)

  1031.     {

  1032.         return PLSR_RESULT_INVALID_ARGUMENT;

  1033.     }

  1034.     state = &PlsrHwAxes[axis];

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

  1036.     {

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

  1038.         state->abQuarter = 0U;

  1039.         state->abFrequencyPending = 0U;

  1040.         state->state = PLSR_HW_STATE_IDLE;

  1041.     }

  1042.     return PLSR_RESULT_OK;

  1043. }

  1044. 

  1045. uint8_t PlsrHwIsPulseActive(uint8_t axis)

  1046. {

  1047.     if (axis >= PLSR_HW_AXIS_COUNT)

  1048.     {

  1049.         return 0U;

  1050.     }

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

  1052. }

  1053. 

  1054. PLSR_HW_STATE PlsrHwGetState(uint8_t axis)

  1055. {

  1056.     if (axis >= PLSR_HW_AXIS_COUNT)

  1057.     {

  1058.         return PLSR_HW_STATE_IDLE;

  1059.     }

  1060.     return PlsrHwAxes[axis].state;

  1061. }

  1062. 

  1063. uint32_t PlsrHwGetTimerClockHz(uint8_t axis)

  1064. {

  1065.     if (axis >= PLSR_HW_AXIS_COUNT)

  1066.     {

  1067.         return 0UL;

  1068.     }

  1069.     return PlsrHwAxisMap[axis].timerClockHz;

  1070. }

  1071. 

  1072. uint32_t PlsrHwGetCurrentFrequencyHz(uint8_t axis)

  1073. {

  1074.     if ((axis >= PLSR_HW_AXIS_COUNT)

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

  1076.     {

  1077.         return 0UL;

  1078.     }

  1079.     return PlsrHwAxes[axis].currentFrequencyHz;

  1080. }

  1081. 

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

  1083. int64_t PlsrHwGetEmittedPulses(uint8_t axis)

  1084. {

  1085.     int64_t emittedPulses;

  1086. 

  1087.     if (axis >= PLSR_HW_AXIS_COUNT)

  1088.     {

  1089.         return 0;

  1090.     }

  1091. #ifdef PLSR_HOST_TEST

  1092.     emittedPulses = PlsrHwAxes[axis].emittedPulses;

  1093. #else

  1094.     {

  1095.         uint32_t interruptState = __get_PRIMASK();

  1096. 

  1097.         __disable_irq();

  1098.         __DMB();

  1099.         emittedPulses = PlsrHwAxes[axis].emittedPulses;

  1100.         __DMB();

  1101.         if (interruptState == 0UL)

  1102.         {

  1103.             __enable_irq();

  1104.         }

  1105.     }

  1106. #endif

  1107.     return emittedPulses;

  1108. }

  1109. 

  1110. uint8_t PlsrHwIsAbStartupPriming(uint8_t axis)

  1111. {

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

  1113.     {

  1114.         return 0U;

  1115.     }

  1116.     return PlsrHwAxes[axis].abStartupPriming;

  1117. }

  1118. 

  1119. void PlsrHwTick(uint8_t axis)

  1120. {

  1121.     PLSR_HW_AXIS_STATE *state;

  1122. 

  1123.     if (axis >= PLSR_HW_AXIS_COUNT)

  1124.     {

  1125.         return;

  1126.     }

  1127.     state = &PlsrHwAxes[axis];

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

  1129.     PlsrHwDbgCapture(axis, 3U);

  1130.     switch (state->state)

  1131.     {

  1132.         case PLSR_HW_STATE_DIR_SETTLING:

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

  1134.             {

  1135.                 state->directionDelayRemainingMs--;

  1136.             }

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

  1138.             {

  1139.                 state->state = PLSR_HW_STATE_PWM_PENDING;

  1140.             }

  1141.             break;

  1142. 

  1143.         case PLSR_HW_STATE_PWM_PENDING:

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

  1145.             {

  1146.                 PlsrHwConfigureActiveOutput(axis,

  1147.                                             state->outputMode,

  1148.                                             state->currentFrequencyHz);

  1149.                 state->state = PLSR_HW_STATE_RUNNING;

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

  1151.             }

  1152.             break;

  1153. 

  1154.         default:

  1155.             break;

  1156.     }

  1157. }

  1158. 

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

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

  1161. void PlsrHwOnTimerUpdate(uint8_t axis)

  1162. {

  1163.     PLSR_HW_AXIS_STATE *state;

  1164.     uint8_t ownerAxis;

  1165.     uint8_t hasCc1;

  1166. 

  1167.     if (axis >= PLSR_HW_AXIS_COUNT)

  1168.     {

  1169.         return;

  1170.     }

  1171. 

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

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

  1174.     hasCc1 = PlsrHwTimerHasCc1if(axis);

  1175.     if (hasCc1 != 0U)

  1176.     {

  1177.         PlsrHwTimerClearCc1if(axis);

  1178.     }

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

  1180.     state = &PlsrHwAxes[ownerAxis];

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

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

  1183.     {

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

  1185.         {

  1186.             PlsrHwTimerClearUif(axis);

  1187.         }

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

  1189.         {

  1190.             return;

  1191.         }

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

  1193.         {

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

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

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

  1197.             state->abStartupPriming = 0U;

  1198.             state->abOutputPrimed = 1U;

  1199. #ifndef PLSR_HOST_TEST

  1200.             PlsrHwReleasePulsePin(ownerAxis);

  1201.             PlsrHwReleasePulsePin(PlsrHwGetPairedAxis(ownerAxis));

  1202. #endif

  1203.             return;

  1204.         }

  1205.         state->emittedPulses++;

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

  1207.         {

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

  1209.             state->abQuarter = 0U;

  1210.             state->abFrequencyPending = 0U;

  1211.             state->state = PLSR_HW_STATE_DONE;

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

  1213.         }

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

  1215.         {

  1216.             uint16_t basePsc = state->abPendingBasePsc;

  1217.             uint16_t pairPsc = state->abPendingPairPsc;

  1218.             uint16_t arr = state->abPendingArr;

  1219. 

  1220.             state->abFrequencyPending = 0U;

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

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

  1223.             PlsrHwBeginAbOutput(ownerAxis, 4U);

  1224.         }

  1225.         return;

  1226.     }

  1227. 

  1228.     if (hasCc1 != 0U)

  1229.     {

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

  1231.         return;

  1232.     }

  1233. 

  1234.     state = &PlsrHwAxes[axis];

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

  1236.     {

  1237.         return;

  1238.     }

  1239.     PlsrHwTimerClearUif(axis);

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

  1241.     {

  1242.         return;

  1243.     }

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

  1245.     {

  1246.         return;

  1247.     }

  1248. 

  1249.     state->emittedPulses++;

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

  1251.     {

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

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

  1254.         state->state = PLSR_HW_STATE_DONE;

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

  1256.     }

  1257. }

  1258. 

  1259. #ifdef PLSR_HOST_TEST

  1260. uint32_t PlsrHwTestGetArr(uint8_t axis)

  1261. {

  1262.     return PlsrHwTimers[axis].arr;

  1263. }

  1264. 

  1265. uint32_t PlsrHwTestGetCcr(uint8_t axis)

  1266. {

  1267.     return PlsrHwTimers[axis].ccr1;

  1268. }

  1269. 

  1270. uint32_t PlsrHwTestGetCnt(uint8_t axis)

  1271. {

  1272.     return PlsrHwTimers[axis].cnt;

  1273. }

  1274. 

  1275. uint32_t PlsrHwTestGetCcmr1(uint8_t axis)

  1276. {

  1277.     return PlsrHwTimers[axis].ccmr1;

  1278. }

  1279. 

  1280. uint32_t PlsrHwTestGetCr1(uint8_t axis)

  1281. {

  1282.     return PlsrHwTimers[axis].cr1;

  1283. }

  1284. 

  1285. uint32_t PlsrHwTestGetPsc(uint8_t axis)

  1286. {

  1287.     return PlsrHwTimers[axis].psc;

  1288. }

  1289. 

  1290. uint8_t PlsrHwTestGetPwmEnabled(uint8_t axis)

  1291. {

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

  1293.                ? 1U

  1294.                : 0U;

  1295. }

  1296. 

  1297. uint8_t PlsrHwTestGetDirLevel(uint8_t axis)

  1298. {

  1299.     return PlsrHwTimers[axis].dirLevel;

  1300. }

  1301. 

  1302. uint8_t PlsrHwTestGetAbPhaseA(uint8_t axis)

  1303. {

  1304.     const PLSR_HW_AXIS_STATE *state;

  1305. 

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

  1307.     {

  1308.         return 0U;

  1309.     }

  1310.     state = &PlsrHwAxes[axis];

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

  1312.     {

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

  1314.                    ? 1U

  1315.                    : 0U;

  1316.     }

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

  1318.                ? 1U

  1319.                : 0U;

  1320. }

  1321. 

  1322. uint8_t PlsrHwTestGetAbPhaseB(uint8_t axis)

  1323. {

  1324.     const PLSR_HW_AXIS_STATE *state;

  1325. 

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

  1327.     {

  1328.         return 0U;

  1329.     }

  1330.     state = &PlsrHwAxes[axis];

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

  1332.     {

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

  1334.                    ? 1U

  1335.                    : 0U;

  1336.     }

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

  1338.                ? 1U

  1339.                : 0U;

  1340. }

  1341. 

  1342. uint8_t PlsrHwTestGetAbQuarter(uint8_t axis)

  1343. {

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

  1345.     {

  1346.         return 0U;

  1347.     }

  1348.     return PlsrHwAxes[axis].abQuarter;

  1349. }

  1350. 

  1351. void PlsrHwTestAdvanceAbQuarter(uint8_t axis)

  1352. {

  1353.     PLSR_HW_AXIS_STATE *state;

  1354. 

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

  1356.     {

  1357.         return;

  1358.     }

  1359.     state = &PlsrHwAxes[axis];

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

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

  1362.     {

  1363.         return;

  1364.     }

  1365. 

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

  1367.                                  % PLSR_HW_AB_QUARTER_COUNT);

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

  1369.     {

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

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

  1372.         PlsrHwOnTimerUpdate(state->abCountAxis);

  1373.     }

  1374. }

  1375. 

  1376. void PlsrHwTestTriggerUpdate(uint8_t axis)

  1377. {

  1378.     if (axis < PLSR_HW_AXIS_COUNT)

  1379.     {

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

  1381.     }

  1382.     PlsrHwOnTimerUpdate(axis);

  1383. }

  1384. #endif

  1385. 

  1386. #ifndef PLSR_HOST_TEST

  1387. void TIM1_UP_TIM10_IRQHandler(void)

  1388. {

  1389.     PlsrHwOnTimerUpdate(0U);

  1390. }

  1391. 

  1392. void TIM8_UP_TIM13_IRQHandler(void)

  1393. {

  1394.     PlsrHwOnTimerUpdate(1U);

  1395. }

  1396. 

  1397. void TIM1_TRG_COM_TIM11_IRQHandler(void)

  1398. {

  1399.     PlsrHwOnTimerUpdate(2U);

  1400. }

  1401. 

  1402. void TIM8_TRG_COM_TIM14_IRQHandler(void)

  1403. {

  1404.     PlsrHwOnTimerUpdate(3U);

  1405. }

  1406. #endif