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

441 lines
14 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 <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) == 168000000UL);

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

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

  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. 

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

  255.     {

  256.         PlsrHwTestTriggerUpdate(0U);

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

  258.     }

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

  260.     PlsrHwTestTriggerUpdate(0U);

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

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

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

  264. 

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

  266.     PlsrHwTestTriggerUpdate(0U);

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

  268. }

  269. 

  270. static void TestStopAndInvalidArgs(void)

  271. {

  272.     (void)PlsrHwInit();

  273.     PLSR_HW_START_PARAMS params;

  274. 

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

  276.     params.frequencyHz = 1000UL;

  277.     params.targetPulses = 100;

  278.     params.directionPoint = PLSR_HW_DIR_POINT_NONE;

  279.     params.directionPositive = 1U;

  280.     params.directionDelayMs = 0U;

  281. 

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

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

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

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

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

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

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

  289. 

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

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

  292.     params.targetPulses = 0;

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

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

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

  296. }

  297. 

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

  299. 

  300. static void TestEndToEndTwoSegments(void)

  301. {

  302.     TEST_MEMORY memory;

  303.     PLSR_CALL call;

  304.     PLSR_STATUS status;

  305.     int ticks;

  306.     int pulse;

  307. 

  308.     TestResetEnvironment();

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

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

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

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

  313. 

  314.     call = TestMakeCall(&memory);

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

  316.     PlsrProcess();

  317.     status = TestGetStatus();

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

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

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

  321. 

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

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

  324.     {

  325.         PlsrProcess();

  326.     }

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

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

  329. 

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

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

  332.     {

  333.         PlsrProcess();

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

  335.         {

  336.             break;

  337.         }

  338.     }

  339.     status = TestGetStatus();

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

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

  342. 

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

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

  345.     {

  346.         PlsrHwTestTriggerUpdate(0U);

  347.     }

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

  349.     PlsrProcess();

  350.     status = TestGetStatus();

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

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

  353. 

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

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

  356.     {

  357.         PlsrProcess();

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

  359.         {

  360.             break;

  361.         }

  362.     }

  363.     status = TestGetStatus();

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

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

  366. 

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

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

  369.     {

  370.         PlsrHwTestTriggerUpdate(0U);

  371.     }

  372.     PlsrProcess();

  373.     status = TestGetStatus();

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

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

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

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

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

  379. }

  380. 

  381. static void TestStopStopsHardware(void)

  382. {

  383.     TEST_MEMORY memory;

  384.     PLSR_CALL call;

  385.     PLSR_COMMAND command;

  386.     PLSR_STATUS status;

  387.     int ticks;

  388. 

  389.     TestResetEnvironment();

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

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

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

  393. 

  394.     call = TestMakeCall(&memory);

  395.     call.sequence = 20UL;

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

  397.     PlsrProcess();

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

  399.     {

  400.         PlsrProcess();

  401.     }

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

  403. 

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

  405.     command.sequence = 21UL;

  406.     command.axis = 0U;

  407.     command.opcode = PLSR_CMD_STOP_IMMEDIATE;

  408.     command.argument = 0;

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

  410.     PlsrProcess();

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

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

  413. 

  414.     CHECK(PlsrPostEvent(0U, PLSR_EVENT_STOP_IMMEDIATE_DONE)

  415.           == PLSR_RESULT_OK);

  416.     PlsrProcess();

  417.     status = TestGetStatus();

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

  419. }

  420. 

  421. int main(void)

  422. {

  423.     TestMapping();

  424.     TestDirDelaySequence();

  425.     TestZeroFrequencyWaits();

  426.     TestPulseCounting();

  427.     TestStopAndInvalidArgs();

  428.     TestEndToEndTwoSegments();

  429.     TestStopStopsHardware();

  430. 

  431.     if (TestFailures != 0)

  432.     {

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

  434.                      TestFailures,

  435.                      TestChecks);

  436.         return 1;

  437.     }

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

  439.     return 0;

  440. }