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.
37 Ревизии
3 Клонове
138 MiB
 
 
 
 
 
 
ИН на ревизия: 0b7990bc99
Клонове Маркери
${ item.name }
Create branch ${ searchTerm }
от '0b7990bc99'
${ noResults }
Modbus-rtu/PLSR/Test/test_plsr_hal.c

738 lines
25 KiB
Директен файл Blame История 

  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 "plsr_self_test.h"

  7. #include <stdio.h>

  8. #include <string.h>

  9. 

  10. #define TEST_WORD_CAPACITY  (3000U)

  11. #define TEST_S0_BASE        (100U)

  12. #define TEST_S1_BASE        (200U)

  13. 

  14. typedef struct

  15. {

  16.     uint16_t words[3][TEST_WORD_CAPACITY];

  17. } TEST_MEMORY;

  18. 

  19. static int TestFailures;

  20. static int TestChecks;

  21. 

  22. #define CHECK(condition)                                                     \

  23.     do                                                                       \

  24.     {                                                                        \

  25.         TestChecks++;                                                        \

  26.         if (!(condition))                                                    \

  27.         {                                                                    \

  28.             TestFailures++;                                                  \

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

  30.         }                                                                    \

  31.     } while (0)

  32. 

  33. static uint8_t TestValidateWords(void *context,

  34.                                  PLSR_DEVICE_TYPE device,

  35.                                  uint32_t firstAddress,

  36.                                  uint32_t wordCount)

  37. {

  38.     (void)context;

  39.     (void)device;

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

  41.                ? 1U

  42.                : 0U;

  43. }

  44. 

  45. static uint8_t TestReadWord(void *context,

  46.                             PLSR_DEVICE_TYPE device,

  47.                             uint32_t address,

  48.                             uint16_t *value)

  49. {

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

  51. 

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

  53.         || (address >= TEST_WORD_CAPACITY))

  54.     {

  55.         return 0U;

  56.     }

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

  58.     return 1U;

  59. }

  60. 

  61. static uint8_t TestReadBit(void *context,

  62.                            PLSR_DEVICE_TYPE device,

  63.                            uint32_t address,

  64.                            uint8_t *value)

  65. {

  66.     (void)context;

  67.     (void)device;

  68.     (void)address;

  69.     *value = 0U;

  70.     return 1U;

  71. }

  72. 

  73. static void TestWriteDword(TEST_MEMORY *memory,

  74.                            PLSR_DEVICE_TYPE device,

  75.                            uint32_t address,

  76.                            int32_t value)

  77. {

  78.     uint32_t raw = (uint32_t)value;

  79. 

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

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

  82. }

  83. 

  84. static void TestSetSegment(TEST_MEMORY *memory,

  85.                            uint16_t number,

  86.                            uint32_t frequency,

  87.                            int32_t pulses)

  88. {

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

  90. 

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

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

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

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

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

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

  97. }

  98. 

  99. static void TestResetEnvironment(void)

  100. {

  101.     PlsrPersistenceTestResetStorage();

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

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

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

  105. }

  106. 

  107. static PLSR_CALL TestMakeCall(TEST_MEMORY *memory)

  108. {

  109.     PLSR_CALL call;

  110. 

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

  112.     call.sequence = 10UL;

  113.     call.source.context = memory;

  114.     call.source.validateWords = TestValidateWords;

  115.     call.source.readWord = TestReadWord;

  116.     call.source.readBit = TestReadBit;

  117.     call.s0.device = PLSR_DEVICE_D;

  118.     call.s0.address = TEST_S0_BASE;

  119.     call.s1.device = PLSR_DEVICE_D;

  120.     call.s1.address = TEST_S1_BASE;

  121.     call.s2.type = PLSR_OPERAND_CONSTANT;

  122.     call.s2.constant = 1;

  123.     call.dAxis = 0U;

  124.     call.outputModeOverride = PLSR_OUTPUT_MODE_FROM_SFD;

  125.     return call;

  126. }

  127. 

  128. static PLSR_STATUS TestGetStatus(void)

  129. {

  130.     PLSR_STATUS status;

  131. 

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

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

  134.     return status;

  135. }

  136. 

  137. /* ---- HAL 单测 ---- */

  138. 

  139. static void TestMapping(void)

  140. {

  141.     (void)PlsrHwInit();

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

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

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

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

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

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

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

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

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

  151. }

  152. 

  153. static void TestDirDelaySequence(void)

  154. {

  155.     (void)PlsrHwInit();

  156.     PLSR_HW_START_PARAMS params;

  157.     uint16_t psc;

  158.     uint16_t arr;

  159.     int ticks;

  160. 

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

  162.     params.frequencyHz = 1000UL;

  163.     params.targetPulses = 100;

  164.     params.directionPoint = 4U;

  165.     params.directionPositive = 1U;

  166.     params.directionDelayMs = 10U;

  167. 

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

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

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

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

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

  173. 

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

  175.     {

  176.         PlsrHwTick(0U);

  177.     }

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

  179. 

  180.     PlsrHwTick(0U);

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

  182. 

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

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

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

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

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

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

  189.           == PLSR_RESULT_OK);

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

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

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

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

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

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

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

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

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

  199. 

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

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

  202.     params.targetPulses = 50;

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

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

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

  206. 

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

  208.     params.directionPositive = 0U;

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

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

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

  212. }

  213. 

  214. static void TestZeroFrequencyWaits(void)

  215. {

  216.     (void)PlsrHwInit();

  217.     PLSR_HW_START_PARAMS params;

  218. 

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

  220.     params.frequencyHz = 0UL;

  221.     params.targetPulses = 50;

  222.     params.directionPoint = PLSR_HW_DIR_POINT_NONE;

  223.     params.directionPositive = 1U;

  224.     params.directionDelayMs = 0U;

  225. 

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

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

  228.     PlsrHwTick(0U);

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

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

  231. 

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

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

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

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

  236. }

  237. 

  238. static void TestPulseCounting(void)

  239. {

  240.     (void)PlsrHwInit();

  241.     PLSR_HW_START_PARAMS params;

  242.     int pulse;

  243. 

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

  245.     params.frequencyHz = 1000UL;

  246.     params.targetPulses = 5;

  247.     params.directionPoint = PLSR_HW_DIR_POINT_NONE;

  248.     params.directionPositive = 1U;

  249.     params.directionDelayMs = 0U;

  250. 

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

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

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

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

  255. 

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

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

  258.     PlsrHwOnTimerUpdate(0U);

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

  260. 

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

  262.     {

  263.         PlsrHwTestTriggerUpdate(0U);

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

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

  266.     }

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

  268.     PlsrHwTestTriggerUpdate(0U);

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

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

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

  272. 

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

  274.     PlsrHwTestTriggerUpdate(0U);

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

  276. }

  277. 

  278. static void TestAbPhaseAndCounting(void)

  279. {

  280.     PLSR_HW_START_PARAMS params;

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

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

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

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

  285.     uint32_t oldArr;

  286.     uint32_t oldBasePsc;

  287.     uint32_t oldPairPsc;

  288.     uint32_t newPeriod;

  289.     int quarter;

  290. 

  291.     (void)PlsrHwInit();

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

  293.     params.frequencyHz = 1000UL;

  294.     params.targetPulses = 4;

  295.     params.outputMode = PLSR_OUTPUT_AB;

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

  297.     params.directionPositive = 1U;

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

  299. 

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

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

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

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

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

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

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

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

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

  309.     CHECK((PlsrHwTestGetPsc(0U) + 1UL)

  310.           == 2UL * (PlsrHwTestGetPsc(1U) + 1UL));

  311.     CHECK(PlsrHwTestGetArr(0U) == PlsrHwTestGetArr(1U));

  312.     CHECK(PlsrHwTestGetCcr(0U) == PlsrHwTestGetCcr(1U));

  313.     CHECK(PlsrHwTestGetCcr(0U)

  314.           == (PlsrHwTestGetArr(0U) + 1UL) / 2UL);

  315.     /* 两相从精确 00 边界起步；CC1IF 会在开中断前再次清除。 */

  316.     CHECK(PlsrHwTestGetCnt(0U)

  317.           == ((PlsrHwTestGetArr(0U) + 1UL) * 3UL) / 4UL);

  318.     CHECK(PlsrHwTestGetCnt(1U) == PlsrHwTestGetCcr(1U));

  319. 

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

  321.     PlsrHwTestTriggerUpdate(0U);

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

  323. 

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

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

  326.     {

  327.         PlsrHwTestAdvanceAbQuarter(0U);

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

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

  330.     }

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

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

  333. 

  334.     /* 运行中调频先排队，不能让相差 1/4 周期的两路各自加载 ARR。 */

  335.     oldArr = PlsrHwTestGetArr(0U);

  336.     oldBasePsc = PlsrHwTestGetPsc(0U);

  337.     oldPairPsc = PlsrHwTestGetPsc(1U);

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

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

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

  341.     {

  342.         PlsrHwTestAdvanceAbQuarter(0U);

  343.     }

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

  345.     CHECK(PlsrHwTestGetArr(0U) == oldArr);

  346.     CHECK(PlsrHwTestGetPsc(0U) == oldBasePsc);

  347.     CHECK(PlsrHwTestGetPsc(1U) == oldPairPsc);

  348. 

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

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

  351.     CHECK(PlsrHwTestGetArr(0U) == oldArr);

  352.     CHECK(PlsrHwTestGetArr(1U) == oldArr);

  353.     CHECK(PlsrHwTestGetPsc(0U) == oldBasePsc);

  354.     CHECK(PlsrHwTestGetPsc(1U) == oldPairPsc);

  355. 

  356.     for (quarter = 0; quarter < 3; quarter++)

  357.     {

  358.         PlsrHwTestAdvanceAbQuarter(0U);

  359.         CHECK(PlsrHwTestGetArr(0U) == oldArr);

  360.         CHECK(PlsrHwTestGetArr(1U) == oldArr);

  361.         CHECK(PlsrHwTestGetPsc(0U) == oldBasePsc);

  362.         CHECK(PlsrHwTestGetPsc(1U) == oldPairPsc);

  363.     }

  364.     /* 回到 00 后，两路同时装载新频率并从精确 90° 位置重启。 */

  365.     PlsrHwTestAdvanceAbQuarter(0U);

  366.     CHECK(PlsrHwGetEmittedPulses(0U) == 3);

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

  368.     CHECK((PlsrHwTestGetArr(0U) != oldArr)

  369.           || (PlsrHwTestGetPsc(0U) != oldBasePsc));

  370.     CHECK((PlsrHwTestGetPsc(0U) + 1UL)

  371.           == 2UL * (PlsrHwTestGetPsc(1U) + 1UL));

  372.     CHECK(PlsrHwTestGetArr(0U) == PlsrHwTestGetArr(1U));

  373.     newPeriod = PlsrHwTestGetArr(0U) + 1UL;

  374.     CHECK(PlsrHwTestGetCnt(0U) == (newPeriod * 3UL) / 4UL);

  375.     CHECK(PlsrHwTestGetCnt(1U) == newPeriod / 2UL);

  376. 

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

  378.     {

  379.         PlsrHwTestAdvanceAbQuarter(0U);

  380.     }

  381.     CHECK(PlsrHwGetEmittedPulses(0U) == 4);

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

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

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

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

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

  387. 

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

  389.     params.targetPulses = 1;

  390.     params.directionPositive = 0U;

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

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

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

  394.     {

  395.         PlsrHwTestAdvanceAbQuarter(0U);

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

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

  398.     }

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

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

  401. 

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

  403.     params.targetPulses = 10;

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

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

  406.     PlsrHwTestAdvanceAbQuarter(0U);

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

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

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

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

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

  412. }

  413. 

  414. static void TestTwoAbAxesIndependent(void)

  415. {

  416.     PLSR_HW_START_PARAMS params;

  417.     int quarter;

  418. 

  419.     (void)PlsrHwInit();

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

  421.     params.frequencyHz = 1000UL;

  422.     params.targetPulses = 1;

  423.     params.outputMode = PLSR_OUTPUT_AB;

  424.     params.directionPoint = PLSR_HW_DIR_POINT_NONE;

  425.     params.directionPositive = 1U;

  426. 

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

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

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

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

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

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

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

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

  435. 

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

  437.     {

  438.         PlsrHwTestAdvanceAbQuarter(0U);

  439.     }

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

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

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

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

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

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

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

  447. 

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

  449.     {

  450.         PlsrHwTestAdvanceAbQuarter(2U);

  451.     }

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

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

  454. }

  455. 

  456. static void TestAbFrequencyLimits(void)

  457. {

  458.     PLSR_HW_START_PARAMS params;

  459.     int quarter;

  460. 

  461.     (void)PlsrHwInit();

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

  463.     params.frequencyHz = 1UL;

  464.     params.targetPulses = 100;

  465.     params.outputMode = PLSR_OUTPUT_AB;

  466.     params.directionPoint = PLSR_HW_DIR_POINT_NONE;

  467.     params.directionPositive = 1U;

  468. 

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

  470.     CHECK(PlsrHwSetFrequency(0U, 1UL) == PLSR_RESULT_OK);

  471.     CHECK(PlsrHwTestGetArr(0U) == PlsrHwTestGetArr(1U));

  472.     CHECK((PlsrHwTestGetPsc(0U) + 1UL)

  473.           == 2UL * (PlsrHwTestGetPsc(1U) + 1UL));

  474.     CHECK(PlsrHwTestGetArr(0U) <= 65535UL);

  475. 

  476.     CHECK(PlsrHwSetFrequency(0U, 100000UL) == PLSR_RESULT_OK);

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

  478.     {

  479.         PlsrHwTestAdvanceAbQuarter(0U);

  480.     }

  481.     CHECK(PlsrHwTestGetArr(0U) == PlsrHwTestGetArr(1U));

  482.     CHECK((PlsrHwTestGetPsc(0U) + 1UL)

  483.           == 2UL * (PlsrHwTestGetPsc(1U) + 1UL));

  484.     CHECK(PlsrHwTestGetArr(0U) >= 3UL);

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

  486. }

  487. 

  488. static void TestStopAndInvalidArgs(void)

  489. {

  490.     (void)PlsrHwInit();

  491.     PLSR_HW_START_PARAMS params;

  492. 

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

  494.     params.frequencyHz = 1000UL;

  495.     params.targetPulses = 100;

  496.     params.directionPoint = PLSR_HW_DIR_POINT_NONE;

  497.     params.directionPositive = 1U;

  498.     params.directionDelayMs = 0U;

  499. 

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

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

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

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

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

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

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

  507. 

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

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

  510.     params.targetPulses = 0;

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

  512.     params.targetPulses = 1;

  513.     params.outputMode = PLSR_OUTPUT_CW_CCW;

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

  515.     params.outputMode = (PLSR_OUTPUT_MODE)99;

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

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

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

  519. }

  520. 

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

  522. 

  523. static void TestEndToEndTwoSegments(void)

  524. {

  525.     TEST_MEMORY memory;

  526.     PLSR_CALL call;

  527.     PLSR_STATUS status;

  528.     uint16_t initialPsc;

  529.     uint16_t initialArr;

  530.     int ticks;

  531.     int pulse;

  532. 

  533.     TestResetEnvironment();

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

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

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

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

  538. 

  539.     call = TestMakeCall(&memory);

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

  541.     PlsrProcess();

  542.     status = TestGetStatus();

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

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

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

  546. 

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

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

  549.     {

  550.         PlsrProcess();

  551.     }

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

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

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

  555.                                     &initialPsc, &initialArr)

  556.           == PLSR_RESULT_OK);

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

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

  559. 

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

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

  562.     {

  563.         PlsrProcess();

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

  565.         {

  566.             break;

  567.         }

  568.     }

  569.     status = TestGetStatus();

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

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

  572. 

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

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

  575.     {

  576.         PlsrHwTestTriggerUpdate(0U);

  577.     }

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

  579.     PlsrProcess();

  580.     status = TestGetStatus();

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

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

  583. 

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

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

  586.     {

  587.         PlsrProcess();

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

  589.         {

  590.             break;

  591.         }

  592.     }

  593.     status = TestGetStatus();

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

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

  596. 

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

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

  599.     {

  600.         PlsrHwTestTriggerUpdate(0U);

  601.     }

  602.     PlsrProcess();

  603.     status = TestGetStatus();

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

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

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

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

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

  609. }

  610. 

  611. static void TestEndToEndAbSegment(void)

  612. {

  613.     TEST_MEMORY memory;

  614.     PLSR_CALL call;

  615.     PLSR_STATUS status;

  616.     int quarter;

  617. 

  618.     TestResetEnvironment();

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

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

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

  622. 

  623.     call = TestMakeCall(&memory);

  624.     call.sequence = 15UL;

  625.     call.outputModeOverride = PLSR_OUTPUT_AB;

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

  627.     PlsrProcess();

  628.     status = TestGetStatus();

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

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

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

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

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

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

  635. 

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

  637.     PlsrHwTestAdvanceAbQuarter(0U);

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

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

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

  641.     {

  642.         PlsrHwTestAdvanceAbQuarter(0U);

  643.     }

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

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

  646.     PlsrProcess();

  647.     status = TestGetStatus();

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

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

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

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

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

  653. }

  654. 

  655. static void TestProductionSelfTestStartsAb(void)

  656. {

  657.     PLSR_STATUS status;

  658. 

  659.     TestResetEnvironment();

  660.     CHECK(PlsrSelfTestQueue() == PLSR_RESULT_QUEUED);

  661.     PlsrProcess();

  662.     status = TestGetStatus();

  663.     CHECK(status.lastCommandResult == PLSR_RESULT_OK);

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

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

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

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

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

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

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

  671. }

  672. 

  673. static void TestStopStopsHardware(void)

  674. {

  675.     TEST_MEMORY memory;

  676.     PLSR_CALL call;

  677.     PLSR_COMMAND command;

  678.     PLSR_STATUS status;

  679.     int ticks;

  680. 

  681.     TestResetEnvironment();

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

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

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

  685. 

  686.     call = TestMakeCall(&memory);

  687.     call.sequence = 20UL;

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

  689.     PlsrProcess();

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

  691.     {

  692.         PlsrProcess();

  693.     }

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

  695. 

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

  697.     command.sequence = 21UL;

  698.     command.axis = 0U;

  699.     command.opcode = PLSR_CMD_STOP_IMMEDIATE;

  700.     command.argument = 0;

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

  702.     PlsrProcess();

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

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

  705. 

  706.     CHECK(PlsrPostEvent(0U, PLSR_EVENT_STOP_IMMEDIATE_DONE)

  707.           == PLSR_RESULT_OK);

  708.     PlsrProcess();

  709.     status = TestGetStatus();

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

  711. }

  712. 

  713. int main(void)

  714. {

  715.     TestMapping();

  716.     TestDirDelaySequence();

  717.     TestZeroFrequencyWaits();

  718.     TestPulseCounting();

  719.     TestAbPhaseAndCounting();

  720.     TestTwoAbAxesIndependent();

  721.     TestAbFrequencyLimits();

  722.     TestStopAndInvalidArgs();

  723.     TestEndToEndTwoSegments();

  724.     TestEndToEndAbSegment();

  725.     TestProductionSelfTestStartsAb();

  726.     TestStopStopsHardware();

  727. 

  728.     if (TestFailures != 0)

  729.     {

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

  731.                      TestFailures,

  732.                      TestChecks);

  733.         return 1;

  734.     }

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

  736.     return 0;

  737. }