yuwenhao
/
Modbus-rtu
1
0
Креирај огранак 0
Код Дискусије 0 Захтеви за спајање 0 Издања 0 Вики Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
36 Комити
3 Гране
138 MiB
 
 
 
 
 
 
Дрво: f1babb383a
Гране Ознаке
${ item.name }
Create branch ${ searchTerm }
from 'f1babb383a'
${ noResults }
Modbus-rtu/PLSR/Src/plsr_hal_f407.c

933 lines
25 KiB
Датотека 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_OUTPUT_POINT_COUNT    (21U)

  15. #define PLSR_HW_DBG_SNAPSHOT_COUNT    (160U)

  16. #define PLSR_HW_AB_QUARTER_COUNT      (4U)

  17. 

  18. typedef struct

  19. {

  20.     uint32_t timerClockHz;

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

  22. #ifndef PLSR_HOST_TEST

  23.     TIM_TypeDef *timer;

  24.     GPIO_TypeDef *gpioPort;

  25.     uint16_t gpioPin;

  26.     uint8_t afMode;

  27.     IRQn_Type irq;

  28. #endif

  29. } PLSR_HW_AXIS_MAP;

  30. 

  31. #ifndef PLSR_HOST_TEST

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

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

  34. typedef struct

  35. {

  36.     GPIO_TypeDef *port;

  37.     uint16_t pin;

  38. } PLSR_HW_OUTPUT_PIN;

  39. 

  40. static const PLSR_HW_OUTPUT_PIN PlsrHwOutputPins[PLSR_HW_OUTPUT_POINT_COUNT] =

  41. {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  63. };

  64. #endif

  65. 

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

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

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

  69. static const PLSR_HW_AXIS_MAP PlsrHwAxisMap[PLSR_HW_AXIS_COUNT] =

  70. {

  71. #ifndef PLSR_HOST_TEST

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

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

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

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

  76. #else

  77.     {168000000UL, PLSR_HW_DIR_POINT_NONE},

  78.     {84000000UL, PLSR_HW_DIR_POINT_NONE},

  79.     {168000000UL, PLSR_HW_DIR_POINT_NONE},

  80.     {84000000UL, PLSR_HW_DIR_POINT_NONE}

  81. #endif

  82. };

  83. 

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

  85. #ifdef PLSR_HOST_TEST

  86. typedef struct

  87. {

  88.     uint32_t cr1;

  89.     uint32_t dier;

  90.     uint32_t sr;

  91.     uint32_t psc;

  92.     uint32_t arr;

  93.     uint32_t ccr1;

  94.     uint32_t ccmr1;

  95.     uint32_t ccer;

  96.     uint8_t dirLevel;

  97. } PLSR_HW_TIMER_REGS;

  98. 

  99. static PLSR_HW_TIMER_REGS PlsrHwTimers[PLSR_HW_AXIS_COUNT];

  100. #endif

  101. 

  102. typedef struct

  103. {

  104.     PLSR_HW_STATE state;

  105.     PLSR_OUTPUT_MODE outputMode;

  106.     uint32_t currentFrequencyHz;

  107.     int64_t targetPulses;

  108.     int64_t emittedPulses;

  109.     uint16_t directionDelayRemainingMs;

  110.     uint8_t directionPoint;

  111.     uint8_t directionPositive;

  112.     uint8_t abQuarter;

  113. } PLSR_HW_AXIS_STATE;

  114. 

  115. static PLSR_HW_AXIS_STATE PlsrHwAxes[PLSR_HW_AXIS_COUNT];

  116. 

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

  118.  * PlsrHwTick 互相混入，同时控制临时 RAM 占用。reason=0 表示 PwmBegin，

  119.  * reason=3 表示 1 ms HAL tick。 */

  120. #ifndef PLSR_HOST_TEST

  121. typedef struct

  122. {

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

  124.     uint32_t psc;

  125.     uint32_t arr;

  126.     uint32_t ccr;

  127.     uint32_t cnt;

  128.     uint32_t frequencyHz;

  129.     int64_t emittedPulses;

  130. } PLSR_HW_DBG_SNAP;

  131. 

  132. static PLSR_HW_DBG_SNAP PlsrHwDbgSnap[PLSR_HW_DBG_SNAPSHOT_COUNT];

  133. static volatile uint16_t PlsrHwDbgCount;

  134. 

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

  136. {

  137.     if (axis != 0U)

  138.     {

  139.         return;

  140.     }

  141.     if (reason == 0U)

  142.     {

  143.         PlsrHwDbgCount = 0U;

  144.     }

  145.     if (PlsrHwDbgCount < PLSR_HW_DBG_SNAPSHOT_COUNT)

  146.     {

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

  148.         snap->reason = reason;

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

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

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

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

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

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

  155.     }

  156. }

  157. #else

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

  159. #endif

  160. 

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

  162. 

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

  164. {

  165. #ifdef PLSR_HOST_TEST

  166.     PlsrHwTimers[axis].arr = value;

  167. #else

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

  169. #endif

  170. }

  171. 

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

  173. {

  174. #ifdef PLSR_HOST_TEST

  175.     PlsrHwTimers[axis].psc = value;

  176. #else

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

  178. #endif

  179. }

  180. 

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

  182. {

  183. #ifdef PLSR_HOST_TEST

  184.     PlsrHwTimers[axis].ccr1 = value;

  185. #else

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

  187. #endif

  188. }

  189. 

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

  191. {

  192. #ifdef PLSR_HOST_TEST

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

  194. #else

  195.     if (value != 0UL)

  196.     {

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

  198.     }

  199.     else

  200.     {

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

  202.     }

  203. #endif

  204. }

  205. 

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

  207. {

  208. #ifdef PLSR_HOST_TEST

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

  210. #else

  211.     if (value != 0UL)

  212.     {

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

  214.     }

  215.     else

  216.     {

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

  218.     }

  219. #endif

  220. }

  221. 

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

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

  224. static void PlsrHwTimerSetPwmMode1(uint8_t axis)

  225. {

  226. #ifdef PLSR_HOST_TEST

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

  228. #else

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

  230.                                        | TIM_CCMR1_OC1PE;

  231. #endif

  232. }

  233. 

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

  235. {

  236. #ifdef PLSR_HOST_TEST

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

  238. #else

  239.     if (value != 0UL)

  240.     {

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

  242.     }

  243.     else

  244.     {

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

  246.     }

  247. #endif

  248. }

  249. 

  250. static void PlsrHwTimerClearUif(uint8_t axis)

  251. {

  252. #ifdef PLSR_HOST_TEST

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

  254. #else

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

  256. #endif

  257. }

  258. 

  259. static uint8_t PlsrHwTimerHasUif(uint8_t axis)

  260. {

  261. #ifdef PLSR_HOST_TEST

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

  263.                ? 1U

  264.                : 0U;

  265. #else

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

  267. #endif

  268. }

  269. 

  270. /* ---- DIR 输出 ----

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

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

  273. 

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

  275. {

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

  277. 

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

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

  280.     {

  281.         return;

  282.     }

  283. #ifdef PLSR_HOST_TEST

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

  285. #else

  286.     if (state->directionPoint < PLSR_HW_OUTPUT_POINT_COUNT)

  287.     {

  288.         const PLSR_HW_OUTPUT_PIN *pin =

  289.             &PlsrHwOutputPins[state->directionPoint];

  290.         GPIO_InitTypeDef gpio;

  291. 

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

  293.         {

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

  295.             gpio.Pin = pin->pin;

  296.             gpio.Mode = GPIO_MODE_OUTPUT_PP;

  297.             gpio.Pull = GPIO_NOPULL;

  298.             gpio.Speed = GPIO_SPEED_FREQ_VERY_HIGH;

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

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

  301.             HAL_GPIO_WritePin(pin->port,

  302.                               pin->pin,

  303.                               (positive != 0U) ? GPIO_PIN_RESET

  304.                                                : GPIO_PIN_SET);

  305.         }

  306.     }

  307. #endif

  308. }

  309. 

  310. /* ---- PWM 启停 ----

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

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

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

  314. 

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

  316. {

  317. #ifdef PLSR_HOST_TEST

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

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

  320. #else

  321.     if (value != 0UL)

  322.     {

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

  324.     }

  325.     else

  326.     {

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

  328.     }

  329. #endif

  330. }

  331. 

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

  333. static void PlsrHwTimerSetUg(uint8_t axis)

  334. {

  335. #ifdef PLSR_HOST_TEST

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

  337. #else

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

  339. #endif

  340. }

  341. 

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

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

  344. {

  345.     uint16_t psc;

  346.     uint16_t arr;

  347. 

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

  349.                                   frequencyHz,

  350.                                   &psc,

  351.                                   &arr) != PLSR_RESULT_OK)

  352.     {

  353.         return;

  354.     }

  355.     PlsrHwTimerSetPsc(axis, psc);

  356.     PlsrHwTimerSetArr(axis, arr);

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

  358.     PlsrHwTimerSetPwmMode1(axis);

  359.     PlsrHwTimerSetArpe(axis, 1UL);

  360. }

  361. 

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

  363. static void PlsrHwPwmBegin(uint8_t axis)

  364. {

  365.     PlsrHwTimerSetUg(axis);

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

  367.     PlsrHwTimerClearUif(axis);

  368.     PlsrHwDbgCapture(axis, 0U);

  369.     PlsrHwTimerSetUie(axis, 1UL);

  370.     PlsrHwTimerSetCc1e(axis, 1UL);

  371.     PlsrHwTimerSetCen(axis, 1UL);

  372. }

  373. 

  374. static void PlsrHwStopPwmTimer(uint8_t axis)

  375. {

  376.     PlsrHwTimerSetCc1e(axis, 0UL);

  377.     PlsrHwTimerSetUie(axis, 0UL);

  378.     PlsrHwTimerSetCen(axis, 0UL);

  379. }

  380. 

  381. static uint8_t PlsrHwIsAbBaseAxis(uint8_t axis)

  382. {

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

  384. }

  385. 

  386. #ifdef PLSR_HOST_TEST

  387. static uint8_t PlsrHwGetPairedAxis(uint8_t axis)

  388. {

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

  390. }

  391. #endif

  392. 

  393. /* P3b-1：AB 正交相序先在 host 模型中闭环。真实 STM32 双定时器的

  394.  * 同步启动、相位偏置和安全停止将在 P3b-2 接入。 */

  395. static void PlsrHwConfigureActiveOutput(uint8_t axis,

  396.                                         PLSR_OUTPUT_MODE outputMode,

  397.                                         uint32_t frequencyHz)

  398. {

  399.     PlsrHwConfigurePwm(axis, frequencyHz);

  400. #ifdef PLSR_HOST_TEST

  401.     if (outputMode == PLSR_OUTPUT_AB)

  402.     {

  403.         PlsrHwConfigurePwm(PlsrHwGetPairedAxis(axis), frequencyHz);

  404.     }

  405. #else

  406.     (void)outputMode;

  407. #endif

  408. }

  409. 

  410. static void PlsrHwBeginActiveOutput(uint8_t axis,

  411.                                     PLSR_OUTPUT_MODE outputMode)

  412. {

  413.     PlsrHwPwmBegin(axis);

  414. #ifdef PLSR_HOST_TEST

  415.     if (outputMode == PLSR_OUTPUT_AB)

  416.     {

  417.         PlsrHwPwmBegin(PlsrHwGetPairedAxis(axis));

  418.     }

  419. #else

  420.     (void)outputMode;

  421. #endif

  422. }

  423. 

  424. static void PlsrHwStopActiveOutput(uint8_t axis,

  425.                                    PLSR_OUTPUT_MODE outputMode)

  426. {

  427.     PlsrHwStopPwmTimer(axis);

  428. #ifdef PLSR_HOST_TEST

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

  430.     {

  431.         PlsrHwStopPwmTimer(PlsrHwGetPairedAxis(axis));

  432.     }

  433. #else

  434.     (void)outputMode;

  435. #endif

  436. }

  437. 

  438. uint8_t PlsrHwResolveDirectionPoint(uint8_t pointNumber)

  439. {

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

  441.     const uint32_t validOutputMask = 0x0013FCFFUL;

  442. 

  443.     if (pointNumber >= PLSR_HW_OUTPUT_POINT_COUNT)

  444.     {

  445.         return 0U;

  446.     }

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

  448.     {

  449.         return 0U;

  450.     }

  451. #ifndef PLSR_HOST_TEST

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

  453.     {

  454.         return 0U;

  455.     }

  456. #endif

  457.     return 1U;

  458. }

  459. 

  460. PLSR_RESULT PlsrHwInit(void)

  461. {

  462.     uint8_t axis;

  463. 

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

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

  466.     {

  467.         PlsrHwAxes[axis].state = PLSR_HW_STATE_IDLE;

  468.         PlsrHwAxes[axis].directionPoint = PLSR_HW_DIR_POINT_NONE;

  469. #ifdef PLSR_HOST_TEST

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

  471. #else

  472.         PlsrHwTimerSetCc1e(axis, 0UL);

  473.         PlsrHwTimerSetUie(axis, 0UL);

  474.         PlsrHwTimerSetCen(axis, 0UL);

  475. #endif

  476.     }

  477. 

  478. #ifndef PLSR_HOST_TEST

  479.     {

  480.         GPIO_InitTypeDef gpio;

  481. 

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

  483.         __HAL_RCC_GPIOF_CLK_ENABLE();

  484.         __HAL_RCC_GPIOI_CLK_ENABLE();

  485.         __HAL_RCC_GPIOE_CLK_ENABLE();

  486.         __HAL_RCC_GPIOG_CLK_ENABLE();

  487.         __HAL_RCC_GPIOH_CLK_ENABLE();

  488.         __HAL_RCC_GPIOB_CLK_ENABLE();

  489. 

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

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

  492. 

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

  494.         __HAL_RCC_TIM10_CLK_ENABLE();

  495.         __HAL_RCC_TIM11_CLK_ENABLE();

  496.         __HAL_RCC_TIM13_CLK_ENABLE();

  497.         __HAL_RCC_TIM14_CLK_ENABLE();

  498. 

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

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

  501.         gpio.Mode = GPIO_MODE_AF_PP;

  502.         gpio.Pull = GPIO_NOPULL;

  503.         gpio.Speed = GPIO_SPEED_FREQ_VERY_HIGH;

  504.         gpio.Pin = GPIO_PIN_6 | GPIO_PIN_7;

  505.         gpio.Alternate = 3U;

  506.         HAL_GPIO_Init(GPIOF, &gpio);

  507.         gpio.Pin = GPIO_PIN_8 | GPIO_PIN_9;

  508.         gpio.Alternate = 9U;

  509.         HAL_GPIO_Init(GPIOF, &gpio);

  510. 

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

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

  513.         HAL_NVIC_EnableIRQ(TIM1_UP_TIM10_IRQn);

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

  515.         HAL_NVIC_EnableIRQ(TIM8_UP_TIM13_IRQn);

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

  517.         HAL_NVIC_EnableIRQ(TIM1_TRG_COM_TIM11_IRQn);

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

  519.         HAL_NVIC_EnableIRQ(TIM8_TRG_COM_TIM14_IRQn);

  520.     }

  521. #endif

  522.     return PLSR_RESULT_OK;

  523. }

  524. 

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

  526. {

  527.     PLSR_HW_AXIS_STATE *state;

  528.     uint8_t directionChanged = 0U;

  529. 

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

  531.     {

  532.         return PLSR_RESULT_INVALID_ARGUMENT;

  533.     }

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

  535.     {

  536.         return PLSR_RESULT_INVALID_ARGUMENT;

  537.     }

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

  539.     {

  540.         return PLSR_RESULT_INVALID_ARGUMENT;

  541.     }

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

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

  544.     {

  545.         return PLSR_RESULT_INVALID_AXIS;

  546.     }

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

  548.     {

  549.         return PLSR_RESULT_NOT_SUPPORTED;

  550.     }

  551. #ifndef PLSR_HOST_TEST

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

  553.     {

  554.         /* P3b-1 只交付可验证的 host 相序模型；禁止目标板误输出成

  555.          * 单路 PULSE/DIR。P3b-2 接入双定时器后移除此保护。 */

  556.         return PLSR_RESULT_NOT_SUPPORTED;

  557.     }

  558. #endif

  559.     state = &PlsrHwAxes[axis];

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

  561.     {

  562.         return PLSR_RESULT_BUSY;

  563.     }

  564. 

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

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

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

  568.     {

  569.         directionChanged =

  570.             (state->directionPoint == PLSR_HW_DIR_POINT_NONE)

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

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

  573.     }

  574. 

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

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

  577.     state->emittedPulses = 0;

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

  579.     state->directionPoint =

  580.         (params->outputMode == PLSR_OUTPUT_PULSE_DIR)

  581.             ? params->directionPoint

  582.             : PLSR_HW_DIR_POINT_NONE;

  583.     state->directionDelayRemainingMs =

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

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

  586.             ? params->directionDelayMs

  587.             : 0U;

  588.     state->abQuarter = 0U;

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

  590.     {

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

  592.     }

  593.     else

  594.     {

  595.         state->directionPositive =

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

  597.     }

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

  599.                        ? PLSR_HW_STATE_DIR_SETTLING

  600.                        : PLSR_HW_STATE_PWM_PENDING;

  601.     return PLSR_RESULT_OK;

  602. }

  603. 

  604. PLSR_RESULT PlsrHwSetFrequency(uint8_t axis, uint32_t frequencyHz)

  605. {

  606.     PLSR_HW_AXIS_STATE *state;

  607. 

  608.     if (axis >= PLSR_HW_AXIS_COUNT)

  609.     {

  610.         return PLSR_RESULT_INVALID_ARGUMENT;

  611.     }

  612.     state = &PlsrHwAxes[axis];

  613.     state->currentFrequencyHz = frequencyHz;

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

  615.     {

  616.         if (frequencyHz > 0UL)

  617.         {

  618.             /* 运行中调频：预装载写入，更新事件时生效，不触碰使能位。 */

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

  620.         }

  621.         else

  622.         {

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

  624.         }

  625.     }

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

  627.              && (frequencyHz > 0UL))

  628.     {

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

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

  631.         state->state = PLSR_HW_STATE_RUNNING;

  632.     }

  633.     return PLSR_RESULT_OK;

  634. }

  635. 

  636. PLSR_RESULT PlsrHwStopPulse(uint8_t axis)

  637. {

  638.     PLSR_HW_AXIS_STATE *state;

  639. 

  640.     if (axis >= PLSR_HW_AXIS_COUNT)

  641.     {

  642.         return PLSR_RESULT_INVALID_ARGUMENT;

  643.     }

  644.     state = &PlsrHwAxes[axis];

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

  646.     {

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

  648.         state->abQuarter = 0U;

  649.         state->state = PLSR_HW_STATE_IDLE;

  650.     }

  651.     return PLSR_RESULT_OK;

  652. }

  653. 

  654. uint8_t PlsrHwIsPulseActive(uint8_t axis)

  655. {

  656.     if (axis >= PLSR_HW_AXIS_COUNT)

  657.     {

  658.         return 0U;

  659.     }

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

  661. }

  662. 

  663. PLSR_HW_STATE PlsrHwGetState(uint8_t axis)

  664. {

  665.     if (axis >= PLSR_HW_AXIS_COUNT)

  666.     {

  667.         return PLSR_HW_STATE_IDLE;

  668.     }

  669.     return PlsrHwAxes[axis].state;

  670. }

  671. 

  672. uint32_t PlsrHwGetTimerClockHz(uint8_t axis)

  673. {

  674.     if (axis >= PLSR_HW_AXIS_COUNT)

  675.     {

  676.         return 0UL;

  677.     }

  678.     return PlsrHwAxisMap[axis].timerClockHz;

  679. }

  680. 

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

  682. int64_t PlsrHwGetEmittedPulses(uint8_t axis)

  683. {

  684.     int64_t emittedPulses;

  685. 

  686.     if (axis >= PLSR_HW_AXIS_COUNT)

  687.     {

  688.         return 0;

  689.     }

  690. #ifdef PLSR_HOST_TEST

  691.     emittedPulses = PlsrHwAxes[axis].emittedPulses;

  692. #else

  693.     {

  694.         uint32_t interruptState = __get_PRIMASK();

  695. 

  696.         __disable_irq();

  697.         __DMB();

  698.         emittedPulses = PlsrHwAxes[axis].emittedPulses;

  699.         __DMB();

  700.         if (interruptState == 0UL)

  701.         {

  702.             __enable_irq();

  703.         }

  704.     }

  705. #endif

  706.     return emittedPulses;

  707. }

  708. 

  709. void PlsrHwTick(uint8_t axis)

  710. {

  711.     PLSR_HW_AXIS_STATE *state;

  712. 

  713.     if (axis >= PLSR_HW_AXIS_COUNT)

  714.     {

  715.         return;

  716.     }

  717.     state = &PlsrHwAxes[axis];

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

  719.     PlsrHwDbgCapture(axis, 3U);

  720.     switch (state->state)

  721.     {

  722.         case PLSR_HW_STATE_DIR_SETTLING:

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

  724.             {

  725.                 state->directionDelayRemainingMs--;

  726.             }

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

  728.             {

  729.                 state->state = PLSR_HW_STATE_PWM_PENDING;

  730.             }

  731.             break;

  732. 

  733.         case PLSR_HW_STATE_PWM_PENDING:

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

  735.             {

  736.                 PlsrHwConfigureActiveOutput(axis,

  737.                                             state->outputMode,

  738.                                             state->currentFrequencyHz);

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

  740.                 state->state = PLSR_HW_STATE_RUNNING;

  741.             }

  742.             break;

  743. 

  744.         default:

  745.             break;

  746.     }

  747. }

  748. 

  749. /* 输出定时器更新中断：每周期末触发一次（=1 个脉冲）。 */

  750. void PlsrHwOnTimerUpdate(uint8_t axis)

  751. {

  752.     PLSR_HW_AXIS_STATE *state;

  753. 

  754.     if (axis >= PLSR_HW_AXIS_COUNT)

  755.     {

  756.         return;

  757.     }

  758.     state = &PlsrHwAxes[axis];

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

  760.     {

  761.         return;

  762.     }

  763.     PlsrHwTimerClearUif(axis);

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

  765.     {

  766.         return;

  767.     }

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

  769.     {

  770.         /* AB host 模型按四分之一周期推进，不能把任一物理定时器的

  771.          * update 直接当成完整 AB 指令脉冲。 */

  772.         return;

  773.     }

  774. 

  775.     state->emittedPulses++;

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

  777.     {

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

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

  780.         state->state = PLSR_HW_STATE_DONE;

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

  782.     }

  783. }

  784. 

  785. #ifdef PLSR_HOST_TEST

  786. uint32_t PlsrHwTestGetArr(uint8_t axis)

  787. {

  788.     return PlsrHwTimers[axis].arr;

  789. }

  790. 

  791. uint32_t PlsrHwTestGetCcr(uint8_t axis)

  792. {

  793.     return PlsrHwTimers[axis].ccr1;

  794. }

  795. 

  796. uint32_t PlsrHwTestGetCcmr1(uint8_t axis)

  797. {

  798.     return PlsrHwTimers[axis].ccmr1;

  799. }

  800. 

  801. uint32_t PlsrHwTestGetCr1(uint8_t axis)

  802. {

  803.     return PlsrHwTimers[axis].cr1;

  804. }

  805. 

  806. uint32_t PlsrHwTestGetPsc(uint8_t axis)

  807. {

  808.     return PlsrHwTimers[axis].psc;

  809. }

  810. 

  811. uint8_t PlsrHwTestGetPwmEnabled(uint8_t axis)

  812. {

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

  814.                ? 1U

  815.                : 0U;

  816. }

  817. 

  818. uint8_t PlsrHwTestGetDirLevel(uint8_t axis)

  819. {

  820.     return PlsrHwTimers[axis].dirLevel;

  821. }

  822. 

  823. uint8_t PlsrHwTestGetAbPhaseA(uint8_t axis)

  824. {

  825.     const PLSR_HW_AXIS_STATE *state;

  826. 

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

  828.     {

  829.         return 0U;

  830.     }

  831.     state = &PlsrHwAxes[axis];

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

  833.     {

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

  835.                    ? 1U

  836.                    : 0U;

  837.     }

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

  839.                ? 1U

  840.                : 0U;

  841. }

  842. 

  843. uint8_t PlsrHwTestGetAbPhaseB(uint8_t axis)

  844. {

  845.     const PLSR_HW_AXIS_STATE *state;

  846. 

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

  848.     {

  849.         return 0U;

  850.     }

  851.     state = &PlsrHwAxes[axis];

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

  853.     {

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

  855.                    ? 1U

  856.                    : 0U;

  857.     }

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

  859.                ? 1U

  860.                : 0U;

  861. }

  862. 

  863. uint8_t PlsrHwTestGetAbQuarter(uint8_t axis)

  864. {

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

  866.     {

  867.         return 0U;

  868.     }

  869.     return PlsrHwAxes[axis].abQuarter;

  870. }

  871. 

  872. void PlsrHwTestAdvanceAbQuarter(uint8_t axis)

  873. {

  874.     PLSR_HW_AXIS_STATE *state;

  875. 

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

  877.     {

  878.         return;

  879.     }

  880.     state = &PlsrHwAxes[axis];

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

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

  883.     {

  884.         return;

  885.     }

  886. 

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

  888.                                  % PLSR_HW_AB_QUARTER_COUNT);

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

  890.     {

  891.         state->emittedPulses++;

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

  893.         {

  894.             /* 仅在完整 00 边界停机，禁止留下半个正交周期。 */

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

  896.             state->state = PLSR_HW_STATE_DONE;

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

  898.         }

  899.     }

  900. }

  901. 

  902. void PlsrHwTestTriggerUpdate(uint8_t axis)

  903. {

  904.     if (axis < PLSR_HW_AXIS_COUNT)

  905.     {

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

  907.     }

  908.     PlsrHwOnTimerUpdate(axis);

  909. }

  910. #endif

  911. 

  912. #ifndef PLSR_HOST_TEST

  913. void TIM1_UP_TIM10_IRQHandler(void)

  914. {

  915.     PlsrHwOnTimerUpdate(0U);

  916. }

  917. 

  918. void TIM8_UP_TIM13_IRQHandler(void)

  919. {

  920.     PlsrHwOnTimerUpdate(1U);

  921. }

  922. 

  923. void TIM1_TRG_COM_TIM11_IRQHandler(void)

  924. {

  925.     PlsrHwOnTimerUpdate(2U);

  926. }

  927. 

  928. void TIM8_TRG_COM_TIM14_IRQHandler(void)

  929. {

  930.     PlsrHwOnTimerUpdate(3U);

  931. }

  932. #endif