yuwenhao
/
Modbus-rtu
1
0
Rozštěpit 0
Zdrojový kód Úkoly 0 Požadavky na natažení 0 Vydání 0 Wiki Aktivita
Nelze vybrat více než 25 témat Téma musí začínat písmenem nebo číslem, může obsahovat pomlčky („-“) a může být dlouhé až 35 znaků.
36 Revize
3 Větve
138 MiB
 
 
 
 
 
 
Strom: f1babb383a
Větve Značky
${ item.name }
Vytvořit větev ${ searchTerm }
z „f1babb383a“
${ noResults }
Modbus-rtu/PLSR/Test/test_plsr_hal.c

648 řádky
22 KiB
Surový Blame Historie 

  1. #include "plc_device.h"

  2. #include "plsr_core.h"

  3. #include "plsr_hal_f407.h"

  4. #include "plsr_job.h"

  5. #include "plsr_persistence.h"

  6. #include <stdio.h>

  7. #include <string.h>

  8. 

  9. #define TEST_WORD_CAPACITY  (3000U)

  10. #define TEST_S0_BASE        (100U)

  11. #define TEST_S1_BASE        (200U)

  12. 

  13. typedef struct

  14. {

  15.     uint16_t words[3][TEST_WORD_CAPACITY];

  16. } TEST_MEMORY;

  17. 

  18. static int TestFailures;

  19. static int TestChecks;

  20. 

  21. #define CHECK(condition)                                                     \

  22.     do                                                                       \

  23.     {                                                                        \

  24.         TestChecks++;                                                        \

  25.         if (!(condition))                                                    \

  26.         {                                                                    \

  27.             TestFailures++;                                                  \

  28.             (void)printf("FAIL line %d: %s\n", __LINE__, #condition);       \

  29.         }                                                                    \

  30.     } while (0)

  31. 

  32. static uint8_t TestValidateWords(void *context,

  33.                                  PLSR_DEVICE_TYPE device,

  34.                                  uint32_t firstAddress,

  35.                                  uint32_t wordCount)

  36. {

  37.     (void)context;

  38.     (void)device;

  39.     return (((uint64_t)firstAddress + wordCount) <= TEST_WORD_CAPACITY)

  40.                ? 1U

  41.                : 0U;

  42. }

  43. 

  44. static uint8_t TestReadWord(void *context,

  45.                             PLSR_DEVICE_TYPE device,

  46.                             uint32_t address,

  47.                             uint16_t *value)

  48. {

  49.     TEST_MEMORY *memory = (TEST_MEMORY *)context;

  50. 

  51.     if ((memory == NULL) || (value == NULL) || (device > PLSR_DEVICE_FD)

  52.         || (address >= TEST_WORD_CAPACITY))

  53.     {

  54.         return 0U;

  55.     }

  56.     *value = memory->words[device][address];

  57.     return 1U;

  58. }

  59. 

  60. static uint8_t TestReadBit(void *context,

  61.                            PLSR_DEVICE_TYPE device,

  62.                            uint32_t address,

  63.                            uint8_t *value)

  64. {

  65.     (void)context;

  66.     (void)device;

  67.     (void)address;

  68.     *value = 0U;

  69.     return 1U;

  70. }

  71. 

  72. static void TestWriteDword(TEST_MEMORY *memory,

  73.                            PLSR_DEVICE_TYPE device,

  74.                            uint32_t address,

  75.                            int32_t value)

  76. {

  77.     uint32_t raw = (uint32_t)value;

  78. 

  79.     memory->words[device][address] = (uint16_t)(raw & 0xFFFFUL);

  80.     memory->words[device][address + 1UL] = (uint16_t)(raw >> 16U);

  81. }

  82. 

  83. static void TestSetSegment(TEST_MEMORY *memory,

  84.                            uint16_t number,

  85.                            uint32_t frequency,

  86.                            int32_t pulses)

  87. {

  88.     uint32_t base = TEST_S0_BASE + (uint32_t)number * 10UL;

  89. 

  90.     TestWriteDword(memory, PLSR_DEVICE_D, base, (int32_t)frequency);

  91.     TestWriteDword(memory, PLSR_DEVICE_D, base + 2UL, pulses);

  92.     memory->words[PLSR_DEVICE_D][base + 4UL] = 0U;

  93.     TestWriteDword(memory, PLSR_DEVICE_D, base + 5UL, 0);

  94.     memory->words[PLSR_DEVICE_D][base + 7UL] = 0U;

  95.     TestWriteDword(memory, PLSR_DEVICE_D, base + 8UL, 0);

  96. }

  97. 

  98. static void TestResetEnvironment(void)

  99. {

  100.     PlsrPersistenceTestResetStorage();

  101.     CHECK(PlcDeviceInit() == PLC_DEVICE_OK);

  102.     CHECK(PlcDeviceWriteSfd(906U, 4) == PLC_DEVICE_OK);

  103.     CHECK(PlsrInit() == PLSR_RESULT_OK);

  104. }

  105. 

  106. static PLSR_CALL TestMakeCall(TEST_MEMORY *memory)

  107. {

  108.     PLSR_CALL call;

  109. 

  110.     (void)memset(&call, 0, sizeof(call));

  111.     call.sequence = 10UL;

  112.     call.source.context = memory;

  113.     call.source.validateWords = TestValidateWords;

  114.     call.source.readWord = TestReadWord;

  115.     call.source.readBit = TestReadBit;

  116.     call.s0.device = PLSR_DEVICE_D;

  117.     call.s0.address = TEST_S0_BASE;

  118.     call.s1.device = PLSR_DEVICE_D;

  119.     call.s1.address = TEST_S1_BASE;

  120.     call.s2.type = PLSR_OPERAND_CONSTANT;

  121.     call.s2.constant = 1;

  122.     call.dAxis = 0U;

  123.     call.outputModeOverride = PLSR_OUTPUT_MODE_FROM_SFD;

  124.     return call;

  125. }

  126. 

  127. static PLSR_STATUS TestGetStatus(void)

  128. {

  129.     PLSR_STATUS status;

  130. 

  131.     (void)memset(&status, 0, sizeof(status));

  132.     CHECK(PlsrGetStatus(0U, &status) == PLSR_RESULT_OK);

  133.     return status;

  134. }

  135. 

  136. /* ---- HAL 单测 ---- */

  137. 

  138. static void TestMapping(void)

  139. {

  140.     (void)PlsrHwInit();

  141.     CHECK(PlsrHwGetTimerClockHz(0U) == 168000000UL);

  142.     CHECK(PlsrHwGetTimerClockHz(1U) == 84000000UL);

  143.     CHECK(PlsrHwGetTimerClockHz(2U) == 168000000UL);

  144.     CHECK(PlsrHwGetTimerClockHz(3U) == 84000000UL);

  145.     CHECK(PlsrHwGetTimerClockHz(4U) == 0UL);

  146.     CHECK(PlsrHwResolveDirectionPoint(4U) != 0U);

  147.     CHECK(PlsrHwResolveDirectionPoint(8U) == 0U);

  148.     CHECK(PlsrHwResolveDirectionPoint(20U) != 0U);

  149.     CHECK(PlsrHwResolveDirectionPoint(21U) == 0U);

  150. }

  151. 

  152. static void TestDirDelaySequence(void)

  153. {

  154.     (void)PlsrHwInit();

  155.     PLSR_HW_START_PARAMS params;

  156.     uint16_t psc;

  157.     uint16_t arr;

  158.     int ticks;

  159. 

  160.     (void)memset(&params, 0, sizeof(params));

  161.     params.frequencyHz = 1000UL;

  162.     params.targetPulses = 100;

  163.     params.directionPoint = 4U;

  164.     params.directionPositive = 1U;

  165.     params.directionDelayMs = 10U;

  166. 

  167.     CHECK(PlsrHwStartPulse(0U, &params) == PLSR_RESULT_OK);

  168.     CHECK(PlsrHwGetState(0U) == PLSR_HW_STATE_DIR_SETTLING);

  169.     CHECK(PlsrHwTestGetDirLevel(0U) == 1U);

  170.     CHECK(PlsrHwTestGetPwmEnabled(0U) == 0U);

  171.     CHECK(PlsrHwIsPulseActive(0U) == 0U);

  172. 

  173.     for (ticks = 0; ticks < 9; ticks++)

  174.     {

  175.         PlsrHwTick(0U);

  176.     }

  177.     CHECK(PlsrHwGetState(0U) == PLSR_HW_STATE_DIR_SETTLING);

  178. 

  179.     PlsrHwTick(0U);

  180.     CHECK(PlsrHwGetState(0U) == PLSR_HW_STATE_PWM_PENDING);

  181. 

  182.     /* 首个非零频率启动 PWM，ARR/CCR 与分频计算一致。 */

  183.     CHECK(PlsrHwSetFrequency(0U, 1000UL) == PLSR_RESULT_OK);

  184.     CHECK(PlsrHwGetState(0U) == PLSR_HW_STATE_RUNNING);

  185.     CHECK(PlsrHwTestGetPwmEnabled(0U) == 1U);

  186.     CHECK(PlsrHwIsPulseActive(0U) == 1U);

  187.     CHECK(PlsrCalculateTimerDivider(168000000UL, 1000UL, &psc, &arr)

  188.           == PLSR_RESULT_OK);

  189.     CHECK(PlsrHwTestGetArr(0U) == arr);

  190.     CHECK(PlsrHwTestGetPsc(0U) == psc);

  191.     CHECK(PlsrHwTestGetCcr(0U) == arr / 2UL);

  192.     /* PWM 模式 1（OC1M=110）：复位后 CCMR1=0 冻结，无此配置输出恒定电平。 */

  193.     CHECK((PlsrHwTestGetCcmr1(0U) & 0x70UL) == 0x60UL);

  194.     /* ARR/CCR 预装载（ARPE=CR1 bit7，OC1PE=CCMR1 bit3）：

  195.      * 运行中调频不产生提前回绕，否则加速段多出 ~ln(f1/f0) 个假脉冲。 */

  196.     CHECK((PlsrHwTestGetCr1(0U) & 0x80UL) == 0x80UL);

  197.     CHECK((PlsrHwTestGetCcmr1(0U) & 0x08UL) == 0x08UL);

  198. 

  199.     /* 段间同向衔接：方向不变时跳过方向延时，直接进入 PWM 待启动。 */

  200.     CHECK(PlsrHwStopPulse(0U) == PLSR_RESULT_OK);

  201.     params.targetPulses = 50;

  202.     CHECK(PlsrHwStartPulse(0U, &params) == PLSR_RESULT_OK);

  203.     CHECK(PlsrHwGetState(0U) == PLSR_HW_STATE_PWM_PENDING);

  204.     CHECK(PlsrHwTestGetDirLevel(0U) == 1U);

  205. 

  206.     /* 反向时方向延时仍生效。 */

  207.     params.directionPositive = 0U;

  208.     CHECK(PlsrHwStartPulse(0U, &params) == PLSR_RESULT_OK);

  209.     CHECK(PlsrHwGetState(0U) == PLSR_HW_STATE_DIR_SETTLING);

  210.     CHECK(PlsrHwTestGetDirLevel(0U) == 0U);

  211. }

  212. 

  213. static void TestZeroFrequencyWaits(void)

  214. {

  215.     (void)PlsrHwInit();

  216.     PLSR_HW_START_PARAMS params;

  217. 

  218.     (void)memset(&params, 0, sizeof(params));

  219.     params.frequencyHz = 0UL;

  220.     params.targetPulses = 50;

  221.     params.directionPoint = PLSR_HW_DIR_POINT_NONE;

  222.     params.directionPositive = 1U;

  223.     params.directionDelayMs = 0U;

  224. 

  225.     CHECK(PlsrHwStartPulse(0U, &params) == PLSR_RESULT_OK);

  226.     CHECK(PlsrHwGetState(0U) == PLSR_HW_STATE_PWM_PENDING);

  227.     PlsrHwTick(0U);

  228.     CHECK(PlsrHwGetState(0U) == PLSR_HW_STATE_PWM_PENDING);

  229.     CHECK(PlsrHwTestGetPwmEnabled(0U) == 0U);

  230. 

  231.     /* 起始速度为 0：profile 升频后首个非零频率才启动 PWM。 */

  232.     CHECK(PlsrHwSetFrequency(0U, 10UL) == PLSR_RESULT_OK);

  233.     CHECK(PlsrHwGetState(0U) == PLSR_HW_STATE_RUNNING);

  234.     CHECK(PlsrHwTestGetPwmEnabled(0U) == 1U);

  235. }

  236. 

  237. static void TestPulseCounting(void)

  238. {

  239.     (void)PlsrHwInit();

  240.     PLSR_HW_START_PARAMS params;

  241.     int pulse;

  242. 

  243.     (void)memset(&params, 0, sizeof(params));

  244.     params.frequencyHz = 1000UL;

  245.     params.targetPulses = 5;

  246.     params.directionPoint = PLSR_HW_DIR_POINT_NONE;

  247.     params.directionPositive = 1U;

  248.     params.directionDelayMs = 0U;

  249. 

  250.     CHECK(PlsrHwStartPulse(0U, &params) == PLSR_RESULT_OK);

  251.     CHECK(PlsrHwSetFrequency(0U, 1000UL) == PLSR_RESULT_OK);

  252.     CHECK(PlsrHwGetState(0U) == PLSR_HW_STATE_RUNNING);

  253.     CHECK(PlsrHwGetEmittedPulses(0U) == 0);

  254. 

  255.     /* EGR.UG 只加载预装载寄存器，不能被当作物理脉冲。

  256.      * 共享 IRQ 入口在对应定时器没有 UIF 时也必须无动作。 */

  257.     PlsrHwOnTimerUpdate(0U);

  258.     CHECK(PlsrHwGetEmittedPulses(0U) == 0);

  259. 

  260.     for (pulse = 0; pulse < 4; pulse++)

  261.     {

  262.         PlsrHwTestTriggerUpdate(0U);

  263.         CHECK(PlsrHwGetEmittedPulses(0U) == pulse + 1);

  264.         CHECK(PlsrHwGetState(0U) == PLSR_HW_STATE_RUNNING);

  265.     }

  266.     /* 第 5 个脉冲：到目标，停止 + 段完成事件。 */

  267.     PlsrHwTestTriggerUpdate(0U);

  268.     CHECK(PlsrHwGetState(0U) == PLSR_HW_STATE_DONE);

  269.     CHECK(PlsrHwTestGetPwmEnabled(0U) == 0U);

  270.     CHECK(PlsrHwIsPulseActive(0U) == 0U);

  271. 

  272.     /* 停止后再触发更新中断无动作。 */

  273.     PlsrHwTestTriggerUpdate(0U);

  274.     CHECK(PlsrHwGetState(0U) == PLSR_HW_STATE_DONE);

  275. }

  276. 

  277. static void TestAbPhaseAndCounting(void)

  278. {

  279.     PLSR_HW_START_PARAMS params;

  280.     uint16_t psc;

  281.     uint16_t arr;

  282.     static const uint8_t positiveA[4] = {1U, 1U, 0U, 0U};

  283.     static const uint8_t positiveB[4] = {0U, 1U, 1U, 0U};

  284.     static const uint8_t negativeA[4] = {0U, 1U, 1U, 0U};

  285.     static const uint8_t negativeB[4] = {1U, 1U, 0U, 0U};

  286.     int quarter;

  287. 

  288.     (void)PlsrHwInit();

  289.     (void)memset(&params, 0, sizeof(params));

  290.     params.frequencyHz = 1000UL;

  291.     params.targetPulses = 2;

  292.     params.outputMode = PLSR_OUTPUT_AB;

  293.     params.directionPoint = 4U;       /* AB 模式必须忽略独立 DIR 点。 */

  294.     params.directionPositive = 1U;

  295.     params.directionDelayMs = 10U;    /* AB 模式不得执行方向延时。 */

  296. 

  297.     CHECK(PlsrHwStartPulse(1U, &params) == PLSR_RESULT_INVALID_AXIS);

  298.     CHECK(PlsrHwStartPulse(0U, &params) == PLSR_RESULT_OK);

  299.     CHECK(PlsrHwGetState(0U) == PLSR_HW_STATE_PWM_PENDING);

  300.     CHECK(PlsrHwTestGetAbPhaseA(0U) == 0U);

  301.     CHECK(PlsrHwTestGetAbPhaseB(0U) == 0U);

  302.     CHECK(PlsrHwSetFrequency(0U, 1000UL) == PLSR_RESULT_OK);

  303.     CHECK(PlsrHwGetState(0U) == PLSR_HW_STATE_RUNNING);

  304.     CHECK(PlsrHwTestGetPwmEnabled(0U) != 0U);

  305.     CHECK(PlsrHwTestGetPwmEnabled(1U) != 0U);

  306.     CHECK(PlsrCalculateTimerDivider(168000000UL, 1000UL, &psc, &arr)

  307.           == PLSR_RESULT_OK);

  308.     CHECK(PlsrHwTestGetPsc(0U) == psc);

  309.     CHECK(PlsrHwTestGetArr(0U) == arr);

  310.     CHECK(PlsrCalculateTimerDivider(84000000UL, 1000UL, &psc, &arr)

  311.           == PLSR_RESULT_OK);

  312.     CHECK(PlsrHwTestGetPsc(1U) == psc);

  313.     CHECK(PlsrHwTestGetArr(1U) == arr);

  314. 

  315.     /* 任一物理 timer update 不能直接计作完整 AB 周期。 */

  316.     PlsrHwTestTriggerUpdate(0U);

  317.     CHECK(PlsrHwGetEmittedPulses(0U) == 0);

  318. 

  319.     /* 正向：00→10→11→01→00；四次相位跳变只计一个脉冲。 */

  320.     for (quarter = 0; quarter < 4; quarter++)

  321.     {

  322.         PlsrHwTestAdvanceAbQuarter(0U);

  323.         CHECK(PlsrHwTestGetAbPhaseA(0U) == positiveA[quarter]);

  324.         CHECK(PlsrHwTestGetAbPhaseB(0U) == positiveB[quarter]);

  325.     }

  326.     CHECK(PlsrHwGetEmittedPulses(0U) == 1);

  327.     CHECK(PlsrHwGetState(0U) == PLSR_HW_STATE_RUNNING);

  328. 

  329.     /* 调频同时更新 A/B 两路，且不得重置正交相位。 */

  330.     CHECK(PlsrHwSetFrequency(0U, 2000UL) == PLSR_RESULT_OK);

  331.     CHECK(PlsrHwTestGetAbQuarter(0U) == 0U);

  332.     CHECK(PlsrCalculateTimerDivider(168000000UL, 2000UL, &psc, &arr)

  333.           == PLSR_RESULT_OK);

  334.     CHECK(PlsrHwTestGetArr(0U) == arr);

  335.     CHECK(PlsrCalculateTimerDivider(84000000UL, 2000UL, &psc, &arr)

  336.           == PLSR_RESULT_OK);

  337.     CHECK(PlsrHwTestGetArr(1U) == arr);

  338. 

  339.     for (quarter = 0; quarter < 4; quarter++)

  340.     {

  341.         PlsrHwTestAdvanceAbQuarter(0U);

  342.     }

  343.     CHECK(PlsrHwGetEmittedPulses(0U) == 2);

  344.     CHECK(PlsrHwGetState(0U) == PLSR_HW_STATE_DONE);

  345.     CHECK(PlsrHwTestGetPwmEnabled(0U) == 0U);

  346.     CHECK(PlsrHwTestGetPwmEnabled(1U) == 0U);

  347.     CHECK(PlsrHwTestGetAbPhaseA(0U) == 0U);

  348.     CHECK(PlsrHwTestGetAbPhaseB(0U) == 0U);

  349. 

  350.     /* 反向：00→01→11→10→00。 */

  351.     params.targetPulses = 1;

  352.     params.directionPositive = 0U;

  353.     CHECK(PlsrHwStartPulse(0U, &params) == PLSR_RESULT_OK);

  354.     CHECK(PlsrHwSetFrequency(0U, 1000UL) == PLSR_RESULT_OK);

  355.     for (quarter = 0; quarter < 4; quarter++)

  356.     {

  357.         PlsrHwTestAdvanceAbQuarter(0U);

  358.         CHECK(PlsrHwTestGetAbPhaseA(0U) == negativeA[quarter]);

  359.         CHECK(PlsrHwTestGetAbPhaseB(0U) == negativeB[quarter]);

  360.     }

  361.     CHECK(PlsrHwGetEmittedPulses(0U) == 1);

  362.     CHECK(PlsrHwGetState(0U) == PLSR_HW_STATE_DONE);

  363. 

  364.     /* 紧急停止即使发生在周期中间，也必须回到安全 00。 */

  365.     params.targetPulses = 10;

  366.     CHECK(PlsrHwStartPulse(0U, &params) == PLSR_RESULT_OK);

  367.     CHECK(PlsrHwSetFrequency(0U, 1000UL) == PLSR_RESULT_OK);

  368.     PlsrHwTestAdvanceAbQuarter(0U);

  369.     CHECK(PlsrHwTestGetAbQuarter(0U) == 1U);

  370.     CHECK(PlsrHwStopPulse(0U) == PLSR_RESULT_OK);

  371.     CHECK(PlsrHwTestGetAbQuarter(0U) == 0U);

  372.     CHECK(PlsrHwTestGetAbPhaseA(0U) == 0U);

  373.     CHECK(PlsrHwTestGetAbPhaseB(0U) == 0U);

  374. }

  375. 

  376. static void TestTwoAbAxesIndependent(void)

  377. {

  378.     PLSR_HW_START_PARAMS params;

  379.     int quarter;

  380. 

  381.     (void)PlsrHwInit();

  382.     (void)memset(&params, 0, sizeof(params));

  383.     params.frequencyHz = 1000UL;

  384.     params.targetPulses = 1;

  385.     params.outputMode = PLSR_OUTPUT_AB;

  386.     params.directionPoint = PLSR_HW_DIR_POINT_NONE;

  387.     params.directionPositive = 1U;

  388. 

  389.     CHECK(PlsrHwStartPulse(0U, &params) == PLSR_RESULT_OK);

  390.     CHECK(PlsrHwStartPulse(2U, &params) == PLSR_RESULT_OK);

  391.     CHECK(PlsrHwSetFrequency(0U, 1000UL) == PLSR_RESULT_OK);

  392.     CHECK(PlsrHwSetFrequency(2U, 2000UL) == PLSR_RESULT_OK);

  393.     CHECK(PlsrHwTestGetPwmEnabled(0U) != 0U);

  394.     CHECK(PlsrHwTestGetPwmEnabled(1U) != 0U);

  395.     CHECK(PlsrHwTestGetPwmEnabled(2U) != 0U);

  396.     CHECK(PlsrHwTestGetPwmEnabled(3U) != 0U);

  397. 

  398.     for (quarter = 0; quarter < 4; quarter++)

  399.     {

  400.         PlsrHwTestAdvanceAbQuarter(0U);

  401.     }

  402.     CHECK(PlsrHwGetState(0U) == PLSR_HW_STATE_DONE);

  403.     CHECK(PlsrHwGetState(2U) == PLSR_HW_STATE_RUNNING);

  404.     CHECK(PlsrHwGetEmittedPulses(2U) == 0);

  405.     CHECK(PlsrHwTestGetPwmEnabled(0U) == 0U);

  406.     CHECK(PlsrHwTestGetPwmEnabled(1U) == 0U);

  407.     CHECK(PlsrHwTestGetPwmEnabled(2U) != 0U);

  408.     CHECK(PlsrHwTestGetPwmEnabled(3U) != 0U);

  409. 

  410.     for (quarter = 0; quarter < 4; quarter++)

  411.     {

  412.         PlsrHwTestAdvanceAbQuarter(2U);

  413.     }

  414.     CHECK(PlsrHwGetState(2U) == PLSR_HW_STATE_DONE);

  415.     CHECK(PlsrHwGetEmittedPulses(2U) == 1);

  416. }

  417. 

  418. static void TestStopAndInvalidArgs(void)

  419. {

  420.     (void)PlsrHwInit();

  421.     PLSR_HW_START_PARAMS params;

  422. 

  423.     (void)memset(&params, 0, sizeof(params));

  424.     params.frequencyHz = 1000UL;

  425.     params.targetPulses = 100;

  426.     params.directionPoint = PLSR_HW_DIR_POINT_NONE;

  427.     params.directionPositive = 1U;

  428.     params.directionDelayMs = 0U;

  429. 

  430.     CHECK(PlsrHwStartPulse(0U, &params) == PLSR_RESULT_OK);

  431.     CHECK(PlsrHwSetFrequency(0U, 1000UL) == PLSR_RESULT_OK);

  432.     CHECK(PlsrHwIsPulseActive(0U) == 1U);

  433.     CHECK(PlsrHwStopPulse(0U) == PLSR_RESULT_OK);

  434.     CHECK(PlsrHwIsPulseActive(0U) == 0U);

  435.     CHECK(PlsrHwGetState(0U) == PLSR_HW_STATE_IDLE);

  436.     CHECK(PlsrHwTestGetPwmEnabled(0U) == 0U);

  437. 

  438.     CHECK(PlsrHwStartPulse(4U, &params) == PLSR_RESULT_INVALID_ARGUMENT);

  439.     CHECK(PlsrHwStartPulse(0U, NULL) == PLSR_RESULT_INVALID_ARGUMENT);

  440.     params.targetPulses = 0;

  441.     CHECK(PlsrHwStartPulse(0U, &params) == PLSR_RESULT_INVALID_ARGUMENT);

  442.     params.targetPulses = 1;

  443.     params.outputMode = PLSR_OUTPUT_CW_CCW;

  444.     CHECK(PlsrHwStartPulse(0U, &params) == PLSR_RESULT_NOT_SUPPORTED);

  445.     params.outputMode = (PLSR_OUTPUT_MODE)99;

  446.     CHECK(PlsrHwStartPulse(0U, &params) == PLSR_RESULT_INVALID_ARGUMENT);

  447.     CHECK(PlsrHwSetFrequency(4U, 1000UL) == PLSR_RESULT_INVALID_ARGUMENT);

  448.     CHECK(PlsrHwStopPulse(4U) == PLSR_RESULT_INVALID_ARGUMENT);

  449. }

  450. 

  451. /* ---- 端到端集成：START → 硬件 → 计数 → 事件 → 段间 → 完成 ---- */

  452. 

  453. static void TestEndToEndTwoSegments(void)

  454. {

  455.     TEST_MEMORY memory;

  456.     PLSR_CALL call;

  457.     PLSR_STATUS status;

  458.     uint16_t initialPsc;

  459.     uint16_t initialArr;

  460.     int ticks;

  461.     int pulse;

  462. 

  463.     TestResetEnvironment();

  464.     (void)memset(&memory, 0, sizeof(memory));

  465.     TestWriteDword(&memory, PLSR_DEVICE_D, TEST_S0_BASE, 2);

  466.     TestSetSegment(&memory, 1U, 1000U, 100);

  467.     TestSetSegment(&memory, 2U, 2000U, 200);

  468. 

  469.     call = TestMakeCall(&memory);

  470.     CHECK(PlsrPostCall(&call) == PLSR_RESULT_QUEUED);

  471.     PlsrProcess();

  472.     status = TestGetStatus();

  473.     CHECK(status.state == PLSR_STATE_ACCEL);

  474.     CHECK(status.currentSegment == 1U);

  475.     CHECK(PlsrHwGetState(0U) == PLSR_HW_STATE_DIR_SETTLING);

  476. 

  477.     /* DIR 延时 10ms → PWM 启动（段1 起始速度 0，profile 升频后启动）。 */

  478.     for (ticks = 0; ticks < 9; ticks++)

  479.     {

  480.         PlsrProcess();

  481.     }

  482.     CHECK(PlsrHwGetState(0U) == PLSR_HW_STATE_RUNNING);

  483.     CHECK(PlsrHwTestGetPwmEnabled(0U) == 1U);

  484.     CHECK(PlsrCalculateTimerDivider(168000000UL, 75UL,

  485.                                     &initialPsc, &initialArr)

  486.           == PLSR_RESULT_OK);

  487.     CHECK(PlsrHwTestGetPsc(0U) == initialPsc);

  488.     CHECK(PlsrHwTestGetArr(0U) == initialArr);

  489. 

  490.     /* 加速完成 → 状态机进入 RUN。 */

  491.     for (ticks = 0; ticks < 500; ticks++)

  492.     {

  493.         PlsrProcess();

  494.         if (TestGetStatus().state == PLSR_STATE_RUN)

  495.         {

  496.             break;

  497.         }

  498.     }

  499.     status = TestGetStatus();

  500.     CHECK(status.state == PLSR_STATE_RUN);

  501.     CHECK(status.currentSegment == 1U);

  502. 

  503.     /* 段1 脉冲完成：100 次更新中断 → SEGMENT_COMPLETE → 段2 启动。 */

  504.     for (pulse = 0; pulse < 100; pulse++)

  505.     {

  506.         PlsrHwTestTriggerUpdate(0U);

  507.     }

  508.     CHECK(PlsrHwGetState(0U) == PLSR_HW_STATE_DONE);

  509.     PlsrProcess();

  510.     status = TestGetStatus();

  511.     CHECK(status.state == PLSR_STATE_ACCEL);

  512.     CHECK(status.currentSegment == 2U);

  513. 

  514.     /* 段2：DIR 延时 → PWM → 加速 → RUN。 */

  515.     for (ticks = 0; ticks < 600; ticks++)

  516.     {

  517.         PlsrProcess();

  518.         if (TestGetStatus().state == PLSR_STATE_RUN)

  519.         {

  520.             break;

  521.         }

  522.     }

  523.     status = TestGetStatus();

  524.     CHECK(status.state == PLSR_STATE_RUN);

  525.     CHECK(status.currentSegment == 2U);

  526. 

  527.     /* 段2 脉冲完成 → 任务结束。 */

  528.     for (pulse = 0; pulse < 200; pulse++)

  529.     {

  530.         PlsrHwTestTriggerUpdate(0U);

  531.     }

  532.     PlsrProcess();

  533.     status = TestGetStatus();

  534.     CHECK(status.state == PLSR_STATE_COMPLETED);

  535.     CHECK(status.done != 0U);

  536.     /* 终态转换后 HAL 回 IDLE（允许重新启动），脉冲已停止。 */

  537.     CHECK(PlsrHwIsPulseActive(0U) == 0U);

  538.     CHECK(PlsrHwTestGetPwmEnabled(0U) == 0U);

  539. }

  540. 

  541. static void TestEndToEndAbSegment(void)

  542. {

  543.     TEST_MEMORY memory;

  544.     PLSR_CALL call;

  545.     PLSR_STATUS status;

  546.     int quarter;

  547. 

  548.     TestResetEnvironment();

  549.     (void)memset(&memory, 0, sizeof(memory));

  550.     TestWriteDword(&memory, PLSR_DEVICE_D, TEST_S0_BASE, 1);

  551.     TestSetSegment(&memory, 1U, 1000U, -2);

  552. 

  553.     call = TestMakeCall(&memory);

  554.     call.sequence = 15UL;

  555.     call.outputModeOverride = PLSR_OUTPUT_AB;

  556.     CHECK(PlsrPostCall(&call) == PLSR_RESULT_QUEUED);

  557.     PlsrProcess();

  558.     status = TestGetStatus();

  559.     CHECK(status.state == PLSR_STATE_ACCEL);

  560.     CHECK(status.outputMode == PLSR_OUTPUT_AB);

  561.     CHECK(status.directionPoint == PLSR_DIRECTION_POINT_NONE);

  562.     CHECK(PlsrHwGetState(0U) == PLSR_HW_STATE_RUNNING);

  563.     CHECK(PlsrHwTestGetPwmEnabled(0U) != 0U);

  564.     CHECK(PlsrHwTestGetPwmEnabled(1U) != 0U);

  565. 

  566.     /* 负脉冲选择反向相序，完整两个周期后由同一事件链结束任务。 */

  567.     PlsrHwTestAdvanceAbQuarter(0U);

  568.     CHECK(PlsrHwTestGetAbPhaseA(0U) == 0U);

  569.     CHECK(PlsrHwTestGetAbPhaseB(0U) == 1U);

  570.     for (quarter = 1; quarter < 8; quarter++)

  571.     {

  572.         PlsrHwTestAdvanceAbQuarter(0U);

  573.     }

  574.     CHECK(PlsrHwGetEmittedPulses(0U) == 2);

  575.     CHECK(PlsrHwGetState(0U) == PLSR_HW_STATE_DONE);

  576.     PlsrProcess();

  577.     status = TestGetStatus();

  578.     CHECK(status.state == PLSR_STATE_COMPLETED);

  579.     CHECK(status.done != 0U);

  580.     CHECK(status.highResourceMask == 0U);

  581.     CHECK(PlsrHwTestGetPwmEnabled(0U) == 0U);

  582.     CHECK(PlsrHwTestGetPwmEnabled(1U) == 0U);

  583. }

  584. 

  585. static void TestStopStopsHardware(void)

  586. {

  587.     TEST_MEMORY memory;

  588.     PLSR_CALL call;

  589.     PLSR_COMMAND command;

  590.     PLSR_STATUS status;

  591.     int ticks;

  592. 

  593.     TestResetEnvironment();

  594.     (void)memset(&memory, 0, sizeof(memory));

  595.     TestWriteDword(&memory, PLSR_DEVICE_D, TEST_S0_BASE, 1);

  596.     TestSetSegment(&memory, 1U, 1000U, 10000);

  597. 

  598.     call = TestMakeCall(&memory);

  599.     call.sequence = 20UL;

  600.     CHECK(PlsrPostCall(&call) == PLSR_RESULT_QUEUED);

  601.     PlsrProcess();

  602.     for (ticks = 0; ticks < 10; ticks++)

  603.     {

  604.         PlsrProcess();

  605.     }

  606.     CHECK(PlsrHwIsPulseActive(0U) == 1U);

  607. 

  608.     /* STOP_IMMEDIATE：硬件立即停止。 */

  609.     command.sequence = 21UL;

  610.     command.axis = 0U;

  611.     command.opcode = PLSR_CMD_STOP_IMMEDIATE;

  612.     command.argument = 0;

  613.     CHECK(PlsrPostCommand(&command) == PLSR_RESULT_QUEUED);

  614.     PlsrProcess();

  615.     CHECK(PlsrHwIsPulseActive(0U) == 0U);

  616.     CHECK(PlsrHwGetState(0U) == PLSR_HW_STATE_IDLE);

  617. 

  618.     CHECK(PlsrPostEvent(0U, PLSR_EVENT_STOP_IMMEDIATE_DONE)

  619.           == PLSR_RESULT_OK);

  620.     PlsrProcess();

  621.     status = TestGetStatus();

  622.     CHECK(status.state == PLSR_STATE_STOPPED);

  623. }

  624. 

  625. int main(void)

  626. {

  627.     TestMapping();

  628.     TestDirDelaySequence();

  629.     TestZeroFrequencyWaits();

  630.     TestPulseCounting();

  631.     TestAbPhaseAndCounting();

  632.     TestTwoAbAxesIndependent();

  633.     TestStopAndInvalidArgs();

  634.     TestEndToEndTwoSegments();

  635.     TestEndToEndAbSegment();

  636.     TestStopStopsHardware();

  637. 

  638.     if (TestFailures != 0)

  639.     {

  640.         (void)printf("FAIL: %d of %d PLSR HAL checks failed\n",

  641.                      TestFailures,

  642.                      TestChecks);

  643.         return 1;

  644.     }

  645.     (void)printf("PASS: %d PLSR HAL checks\n", TestChecks);

  646.     return 0;

  647. }