yuwenhao
/
Modbus-rtu
1
0
Fork 0
Koodi Ongelmat 0 Pull-pyynnöt 0 Julkaisut 0 Wiki Toiminta
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 Commitit
3 Branchit
138 MiB
 
 
 
 
 
 
Puu: b2e407d91c
Branchit Tagit
${ item.name }
Create branch ${ searchTerm }
from 'b2e407d91c'
${ noResults }
Modbus-rtu/PLSR/Test/test_plsr_path.c

683 rivejä
22 KiB
Raaka Blame Historia 

  1. #include "plc_device.h"

  2. #include "plsr_core.h"

  3. #include "plsr_job.h"

  4. #include "plsr_path.h"

  5. #include "plsr_persistence.h"

  6. #include <stdio.h>

  7. #include <string.h>

  8. 

  9. #define TEST_WORD_CAPACITY  (3000U)

  10. #define TEST_BIT_CAPACITY   (128U)

  11. 

  12. #define TEST_S0_BASE        (100U)

  13. #define TEST_S1_BASE        (200U)

  14. #define TEST_SEGMENT_STRIDE (10U)

  15. 

  16. /* 等待条件编码（信捷）：高8位条件、低8位来源。 */

  17. #define TEST_WAIT_CODE(condition, source) \

  18.     ((uint16_t)(((uint16_t)(condition) << 8U) | (uint16_t)(source)))

  19. 

  20. typedef struct

  21. {

  22.     uint16_t words[3][TEST_WORD_CAPACITY];

  23.     uint8_t bits[3][TEST_BIT_CAPACITY];

  24. } TEST_MEMORY;

  25. 

  26. static int TestFailures;

  27. static int TestChecks;

  28. 

  29. #define CHECK(condition)                                                     \

  30.     do                                                                       \

  31.     {                                                                        \

  32.         TestChecks++;                                                        \

  33.         if (!(condition))                                                    \

  34.         {                                                                    \

  35.             TestFailures++;                                                  \

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

  37.         }                                                                    \

  38.     } while (0)

  39. 

  40. static uint8_t TestValidateWords(void *context,

  41.                                  PLSR_DEVICE_TYPE device,

  42.                                  uint32_t firstAddress,

  43.                                  uint32_t wordCount)

  44. {

  45.     (void)context;

  46.     if ((device > PLSR_DEVICE_FD) || (wordCount == 0UL))

  47.     {

  48.         return 0U;

  49.     }

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

  51.                ? 1U

  52.                : 0U;

  53. }

  54. 

  55. static uint8_t TestReadWord(void *context,

  56.                             PLSR_DEVICE_TYPE device,

  57.                             uint32_t address,

  58.                             uint16_t *value)

  59. {

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

  61. 

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

  63.         || (address >= TEST_WORD_CAPACITY))

  64.     {

  65.         return 0U;

  66.     }

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

  68.     return 1U;

  69. }

  70. 

  71. static uint8_t TestReadBit(void *context,

  72.                            PLSR_DEVICE_TYPE device,

  73.                            uint32_t address,

  74.                            uint8_t *value)

  75. {

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

  77.     uint8_t index;

  78. 

  79.     if ((memory == NULL) || (value == NULL) || (device < PLSR_DEVICE_X)

  80.         || (device > PLSR_DEVICE_HM) || (address >= TEST_BIT_CAPACITY))

  81.     {

  82.         return 0U;

  83.     }

  84.     index = (uint8_t)(device - PLSR_DEVICE_X);

  85.     *value = memory->bits[index][address];

  86.     return 1U;

  87. }

  88. 

  89. static void TestWriteDword(TEST_MEMORY *memory,

  90.                            PLSR_DEVICE_TYPE device,

  91.                            uint32_t address,

  92.                            int32_t value)

  93. {

  94.     uint32_t raw = (uint32_t)value;

  95. 

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

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

  98. }

  99. 

  100. /* 写入一个段的数据块（S0 布局，每段 10 字）。 */

  101. static void TestSetSegment(TEST_MEMORY *memory,

  102.                            uint16_t number,

  103.                            uint32_t frequency,

  104.                            int32_t pulses,

  105.                            uint16_t waitCode,

  106.                            int32_t waitValue,

  107.                            uint16_t jumpSource,

  108.                            int32_t jumpValue)

  109. {

  110.     uint32_t base = TEST_S0_BASE + (uint32_t)number * TEST_SEGMENT_STRIDE;

  111. 

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

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

  114.     memory->words[PLSR_DEVICE_D][base + 4UL] = waitCode;

  115.     TestWriteDword(memory, PLSR_DEVICE_D, base + 5UL, waitValue);

  116.     memory->words[PLSR_DEVICE_D][base + 7UL] = (uint16_t)jumpSource;

  117.     TestWriteDword(memory, PLSR_DEVICE_D, base + 8UL, jumpValue);

  118. }

  119. 

  120. static void TestResetEnvironment(void)

  121. {

  122.     PlsrPersistenceTestResetStorage();

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

  124.     /* 默认 SFD + 配置方向端子（接线参数，测试用 Y4）。 */

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

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

  127. }

  128. 

  129. static PLSR_CALL TestMakeCall(TEST_MEMORY *memory)

  130. {

  131.     PLSR_CALL call;

  132. 

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

  134.     call.sequence = 10UL;

  135.     call.source.context = memory;

  136.     call.source.validateWords = TestValidateWords;

  137.     call.source.readWord = TestReadWord;

  138.     call.source.readBit = TestReadBit;

  139.     call.s0.device = PLSR_DEVICE_D;

  140.     call.s0.address = TEST_S0_BASE;

  141.     call.s1.device = PLSR_DEVICE_D;

  142.     call.s1.address = TEST_S1_BASE;

  143.     call.s2.type = PLSR_OPERAND_CONSTANT;

  144.     call.s2.constant = 1;

  145.     call.dAxis = 0U;

  146.     call.outputModeOverride = PLSR_OUTPUT_MODE_FROM_SFD;

  147.     return call;

  148. }

  149. 

  150. static PLSR_STATUS TestGetStatus(void)

  151. {

  152.     PLSR_STATUS status;

  153. 

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

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

  156.     return status;

  157. }

  158. 

  159. /* 当前段加速完成进入 RUN。 */

  160. static void TestAccelToRun(void)

  161. {

  162.     CHECK(PlsrPostEvent(0U, PLSR_EVENT_ACCEL_COMPLETE) == PLSR_RESULT_OK);

  163.     PlsrProcess();

  164.     CHECK(TestGetStatus().state == PLSR_STATE_RUN);

  165. }

  166. 

  167. /* 启动一个 N 段任务（全部 H00 完成条件、顺序跳转）。 */

  168. static void TestStartSequentialJob(TEST_MEMORY *memory,

  169.                                    uint16_t segmentCount,

  170.                                    uint32_t sequence)

  171. {

  172.     uint16_t segment;

  173. 

  174.     (void)memset(memory, 0, sizeof(*memory));

  175.     TestWriteDword(memory, PLSR_DEVICE_D, TEST_S0_BASE, segmentCount);

  176.     for (segment = 1U; segment <= segmentCount; segment++)

  177.     {

  178.         TestSetSegment(memory,

  179.                        segment,

  180.                        1000U + (uint32_t)segment * 1000U,

  181.                        (int32_t)(segment * 100),

  182.                        TEST_WAIT_CODE(0U, 0U),

  183.                        0,

  184.                        0U,

  185.                        0);

  186.     }

  187.     {

  188.         PLSR_CALL call = TestMakeCall(memory);

  189. 

  190.         call.sequence = sequence;

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

  192.     }

  193.     PlsrProcess();

  194.     CHECK(TestGetStatus().lastCommandResult == PLSR_RESULT_OK);

  195. }

  196. 

  197. static void TestSequentialSegments(void)

  198. {

  199.     TEST_MEMORY memory;

  200. 

  201.     TestResetEnvironment();

  202.     TestStartSequentialJob(&memory, 3U, 10UL);

  203.     CHECK(TestGetStatus().state == PLSR_STATE_ACCEL);

  204.     CHECK(TestGetStatus().currentSegment == 1U);

  205. 

  206.     TestAccelToRun();

  207.     CHECK(PlsrPostEvent(0U, PLSR_EVENT_SEGMENT_COMPLETE) == PLSR_RESULT_OK);

  208.     PlsrProcess();

  209.     CHECK(TestGetStatus().state == PLSR_STATE_ACCEL);

  210.     CHECK(TestGetStatus().currentSegment == 2U);

  211. 

  212.     TestAccelToRun();

  213.     CHECK(PlsrPostEvent(0U, PLSR_EVENT_SEGMENT_COMPLETE) == PLSR_RESULT_OK);

  214.     PlsrProcess();

  215.     CHECK(TestGetStatus().state == PLSR_STATE_ACCEL);

  216.     CHECK(TestGetStatus().currentSegment == 3U);

  217. 

  218.     TestAccelToRun();

  219.     CHECK(PlsrPostEvent(0U, PLSR_EVENT_SEGMENT_COMPLETE) == PLSR_RESULT_OK);

  220.     PlsrProcess();

  221.     CHECK(TestGetStatus().state == PLSR_STATE_COMPLETED);

  222.     CHECK(TestGetStatus().done != 0U);

  223. }

  224. 

  225. static void TestJumpToSpecifiedSegment(void)

  226. {

  227.     TEST_MEMORY memory;

  228. 

  229.     TestResetEnvironment();

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

  231.     TestWriteDword(&memory, PLSR_DEVICE_D, TEST_S0_BASE, 3);

  232.     TestSetSegment(&memory, 1U, 1000U, 100, TEST_WAIT_CODE(0U, 0U), 0, 0U, 3);

  233.     TestSetSegment(&memory, 2U, 2000U, 200, TEST_WAIT_CODE(0U, 0U), 0, 0U, 0);

  234.     TestSetSegment(&memory, 3U, 3000U, 300, TEST_WAIT_CODE(0U, 0U), 0, 0U, 0);

  235.     {

  236.         PLSR_CALL call = TestMakeCall(&memory);

  237. 

  238.         call.sequence = 20UL;

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

  240.     }

  241.     PlsrProcess();

  242.     CHECK(TestGetStatus().currentSegment == 1U);

  243. 

  244.     /* 段1 完成 → 跳到段3（跳过段2）。 */

  245.     TestAccelToRun();

  246.     CHECK(PlsrPostEvent(0U, PLSR_EVENT_SEGMENT_COMPLETE) == PLSR_RESULT_OK);

  247.     PlsrProcess();

  248.     CHECK(TestGetStatus().state == PLSR_STATE_ACCEL);

  249.     CHECK(TestGetStatus().currentSegment == 3U);

  250. 

  251.     /* 段3 完成 → 顺序下一段超出 → 任务结束。 */

  252.     TestAccelToRun();

  253.     CHECK(PlsrPostEvent(0U, PLSR_EVENT_SEGMENT_COMPLETE) == PLSR_RESULT_OK);

  254.     PlsrProcess();

  255.     CHECK(TestGetStatus().state == PLSR_STATE_COMPLETED);

  256. }

  257. 

  258. static void TestWaitTime(void)

  259. {

  260.     TEST_MEMORY memory;

  261.     int ticks;

  262. 

  263.     TestResetEnvironment();

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

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

  266.     TestSetSegment(&memory, 1U, 1000U, 100,

  267.                    TEST_WAIT_CODE(1U, 0U), 200, 0U, 0);

  268.     TestSetSegment(&memory, 2U, 2000U, 200, TEST_WAIT_CODE(0U, 0U), 0, 0U, 0);

  269.     {

  270.         PLSR_CALL call = TestMakeCall(&memory);

  271. 

  272.         call.sequence = 30UL;

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

  274.     }

  275.     PlsrProcess();

  276.     TestAccelToRun();

  277. 

  278.     /* 段1 完成 → 进入 WAIT（等 200ms）。 */

  279.     CHECK(PlsrPostEvent(0U, PLSR_EVENT_SEGMENT_COMPLETE) == PLSR_RESULT_OK);

  280.     PlsrProcess();

  281.     CHECK(TestGetStatus().state == PLSR_STATE_WAIT);

  282. 

  283.     /* 事件处理同轮已递减 1ms：198 个 tick 后仍在等待。 */

  284.     for (ticks = 0; ticks < 198; ticks++)

  285.     {

  286.         PlsrProcess();

  287.     }

  288.     CHECK(TestGetStatus().state == PLSR_STATE_WAIT);

  289.     CHECK(TestGetStatus().currentSegment == 1U);

  290. 

  291.     /* 第 200 个 tick：计时到，跳到段2。 */

  292.     PlsrProcess();

  293.     CHECK(TestGetStatus().state == PLSR_STATE_ACCEL);

  294.     CHECK(TestGetStatus().currentSegment == 2U);

  295. }

  296. 

  297. static void TestWaitSignal(void)

  298. {

  299.     TEST_MEMORY memory;

  300. 

  301.     TestResetEnvironment();

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

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

  304.     TestSetSegment(&memory, 1U, 1000U, 100,

  305.                    TEST_WAIT_CODE(2U, 5U), 10, 0U, 0);

  306.     TestSetSegment(&memory, 2U, 2000U, 200, TEST_WAIT_CODE(0U, 0U), 0, 0U, 0);

  307.     {

  308.         PLSR_CALL call = TestMakeCall(&memory);

  309. 

  310.         call.sequence = 40UL;

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

  312.     }

  313.     PlsrProcess();

  314.     TestAccelToRun();

  315. 

  316.     /* 段1 完成 → 等 M10（当前 OFF）。 */

  317.     CHECK(PlsrPostEvent(0U, PLSR_EVENT_SEGMENT_COMPLETE) == PLSR_RESULT_OK);

  318.     PlsrProcess();

  319.     CHECK(TestGetStatus().state == PLSR_STATE_WAIT);

  320. 

  321.     /* 信号仍 OFF：不跳转。 */

  322.     PlsrProcess();

  323.     PlsrProcess();

  324.     CHECK(TestGetStatus().state == PLSR_STATE_WAIT);

  325. 

  326.     /* 信号置 ON：tick 轮询到后跳段。 */

  327.     memory.bits[1U][10U] = 1U;   /* M10 */

  328.     PlsrProcess();

  329.     CHECK(TestGetStatus().state == PLSR_STATE_ACCEL);

  330.     CHECK(TestGetStatus().currentSegment == 2U);

  331. }

  332. 

  333. static void TestActTruncatesSegment(void)

  334. {

  335.     TEST_MEMORY memory;

  336.     int ticks;

  337. 

  338.     TestResetEnvironment();

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

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

  341.     TestSetSegment(&memory, 1U, 1000U, 100,

  342.                    TEST_WAIT_CODE(3U, 0U), 200, 0U, 0);

  343.     TestSetSegment(&memory, 2U, 2000U, 200, TEST_WAIT_CODE(0U, 0U), 0, 0U, 0);

  344.     {

  345.         PLSR_CALL call = TestMakeCall(&memory);

  346. 

  347.         call.sequence = 50UL;

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

  349.     }

  350.     PlsrProcess();

  351.     TestAccelToRun();

  352. 

  353.     /* 不注入 SEGMENT_COMPLETE：ACT 200ms 到时截断当前段。 */

  354.     for (ticks = 0; ticks < 200; ticks++)

  355.     {

  356.         PlsrProcess();

  357.     }

  358.     CHECK(TestGetStatus().state == PLSR_STATE_ACCEL);

  359.     CHECK(TestGetStatus().currentSegment == 2U);

  360. }

  361. 

  362. static void TestActPendingAfterSegmentDone(void)

  363. {

  364.     TEST_MEMORY memory;

  365.     int ticks;

  366. 

  367.     TestResetEnvironment();

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

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

  370.     TestSetSegment(&memory, 1U, 1000U, 100,

  371.                    TEST_WAIT_CODE(3U, 0U), 200, 0U, 0);

  372.     TestSetSegment(&memory, 2U, 2000U, 200, TEST_WAIT_CODE(0U, 0U), 0, 0U, 0);

  373.     {

  374.         PLSR_CALL call = TestMakeCall(&memory);

  375. 

  376.         call.sequence = 60UL;

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

  378.     }

  379.     PlsrProcess();

  380.     TestAccelToRun();

  381. 

  382.     /* 段脉冲先完成（ACT 还剩 199ms）→ 停在 ACT_PENDING（WAIT 状态）。 */

  383.     CHECK(PlsrPostEvent(0U, PLSR_EVENT_SEGMENT_COMPLETE) == PLSR_RESULT_OK);

  384.     PlsrProcess();

  385.     CHECK(TestGetStatus().state == PLSR_STATE_WAIT);

  386. 

  387.     /* ACT 到时 → 跳段2。 */

  388.     for (ticks = 0; ticks < 199; ticks++)

  389.     {

  390.         PlsrProcess();

  391.     }

  392.     CHECK(TestGetStatus().state == PLSR_STATE_ACCEL);

  393.     CHECK(TestGetStatus().currentSegment == 2U);

  394. }

  395. 

  396. static void TestExtEdgeTruncates(void)

  397. {

  398.     TEST_MEMORY memory;

  399.     int ticks;

  400. 

  401.     TestResetEnvironment();

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

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

  404.     TestSetSegment(&memory, 1U, 1000U, 100,

  405.                    TEST_WAIT_CODE(4U, 4U), 0, 0U, 0);

  406.     TestSetSegment(&memory, 2U, 2000U, 200, TEST_WAIT_CODE(0U, 0U), 0, 0U, 0);

  407.     /* X0 在任务开始前就有效：进入段时记录为已有电平，不算新边沿。 */

  408.     memory.bits[0U][0U] = 1U;

  409.     {

  410.         PLSR_CALL call = TestMakeCall(&memory);

  411. 

  412.         call.sequence = 70UL;

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

  414.     }

  415.     PlsrProcess();

  416.     TestAccelToRun();

  417. 

  418.     /* X0 持续 ON：没有新边沿，不应触发。 */

  419.     for (ticks = 0; ticks < 5; ticks++)

  420.     {

  421.         PlsrProcess();

  422.     }

  423.     CHECK(TestGetStatus().state == PLSR_STATE_RUN);

  424.     CHECK(TestGetStatus().currentSegment == 1U);

  425. 

  426.     /* 先拉低再拉高：新上升沿，截断当前段。 */

  427.     memory.bits[0U][0U] = 0U;

  428.     PlsrProcess();

  429.     memory.bits[0U][0U] = 1U;

  430.     PlsrProcess();

  431.     CHECK(TestGetStatus().state == PLSR_STATE_ACCEL);

  432.     CHECK(TestGetStatus().currentSegment == 2U);

  433. }

  434. 

  435. static void TestExtOrComplete(void)

  436. {

  437.     TEST_MEMORY memory;

  438. 

  439.     TestResetEnvironment();

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

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

  442.     TestSetSegment(&memory, 1U, 1000U, 100,

  443.                    TEST_WAIT_CODE(5U, 4U), 0, 0U, 0);

  444.     TestSetSegment(&memory, 2U, 2000U, 200, TEST_WAIT_CODE(0U, 0U), 0, 0U, 0);

  445.     {

  446.         PLSR_CALL call = TestMakeCall(&memory);

  447. 

  448.         call.sequence = 80UL;

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

  450.     }

  451.     PlsrProcess();

  452.     TestAccelToRun();

  453. 

  454.     /* 段脉冲先完成 → 正常跳段（EXT 或完成）。 */

  455.     CHECK(PlsrPostEvent(0U, PLSR_EVENT_SEGMENT_COMPLETE) == PLSR_RESULT_OK);

  456.     PlsrProcess();

  457.     CHECK(TestGetStatus().state == PLSR_STATE_ACCEL);

  458.     CHECK(TestGetStatus().currentSegment == 2U);

  459. }

  460. 

  461. static void TestDynamicJump(void)

  462. {

  463.     TEST_MEMORY memory;

  464. 

  465.     TestResetEnvironment();

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

  467.     TestWriteDword(&memory, PLSR_DEVICE_D, TEST_S0_BASE, 3);

  468.     TestSetSegment(&memory, 1U, 1000U, 100,

  469.                    TEST_WAIT_CODE(0U, 0U), 0, 0U, 3);

  470.     TestSetSegment(&memory, 2U, 2000U, 200, TEST_WAIT_CODE(0U, 0U), 0, 0U, 0);

  471.     /* 段3 跳转也来自 D300（初始 3 = 自跳转，运行期改非法值验证越界）。 */

  472.     TestSetSegment(&memory, 3U, 3000U, 300,

  473.                    TEST_WAIT_CODE(0U, 0U), 0, 1U, 300);

  474.     TestWriteDword(&memory, PLSR_DEVICE_D, 300U, 3);

  475.     {

  476.         PLSR_CALL call = TestMakeCall(&memory);

  477. 

  478.         call.sequence = 90UL;

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

  480.     }

  481.     PlsrProcess();

  482.     TestAccelToRun();

  483. 

  484.     /* 段1 完成：跳到段3。 */

  485.     CHECK(PlsrPostEvent(0U, PLSR_EVENT_SEGMENT_COMPLETE) == PLSR_RESULT_OK);

  486.     PlsrProcess();

  487.     CHECK(TestGetStatus().currentSegment == 3U);

  488. 

  489.     /* 段3 完成前把 D300 改成非法值 → 运行期错误 → ERROR。 */

  490.     TestAccelToRun();

  491.     TestWriteDword(&memory, PLSR_DEVICE_D, 300U, 99);

  492.     CHECK(PlsrPostEvent(0U, PLSR_EVENT_SEGMENT_COMPLETE) == PLSR_RESULT_OK);

  493.     PlsrProcess();

  494.     CHECK(TestGetStatus().state == PLSR_STATE_ERROR);

  495. }

  496. 

  497. static void TestAbsoluteZeroDisplacement(void)

  498. {

  499.     TEST_MEMORY memory;

  500.     PLSR_COMMAND command;

  501. 

  502.     TestResetEnvironment();

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

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

  505.     /* S1+0 = 1：绝对模式。 */

  506.     TestWriteDword(&memory, PLSR_DEVICE_D, TEST_S1_BASE, 1);

  507.     /* 段1 目标 0（=当前位置 0，零位移）；段2 目标 5000。 */

  508.     TestSetSegment(&memory, 1U, 1000U, 0,

  509.                    TEST_WAIT_CODE(0U, 0U), 0, 0U, 0);

  510.     TestSetSegment(&memory, 2U, 2000U, 5000,

  511.                    TEST_WAIT_CODE(0U, 0U), 0, 0U, 0);

  512. 

  513.     /* 绝对定位需要 positionValid：先 SET_POSITION(0)。 */

  514.     command.sequence = 91UL;

  515.     command.axis = 0U;

  516.     command.opcode = PLSR_CMD_SET_POSITION;

  517.     command.argument = 0;

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

  519.     PlsrProcess();

  520. 

  521.     {

  522.         PLSR_CALL call = TestMakeCall(&memory);

  523. 

  524.         call.sequence = 92UL;

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

  526.     }

  527.     PlsrProcess();

  528.     /* 起点段1 零位移：直接跳过，从段2 开始发脉冲。 */

  529.     CHECK(TestGetStatus().state == PLSR_STATE_ACCEL);

  530.     CHECK(TestGetStatus().currentSegment == 2U);

  531. }

  532. 

  533. static void TestZeroJumpBudgetYields(void)

  534. {

  535.     TEST_MEMORY memory;

  536.     int rounds;

  537. 

  538.     TestResetEnvironment();

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

  540.     TestWriteDword(&memory, PLSR_DEVICE_D, TEST_S0_BASE, 3);

  541.     /* 段1：零脉冲，跳到段2；段2：零脉冲，动态跳转（初始自跳转）；段3：正常段。 */

  542.     TestSetSegment(&memory, 1U, 1000U, 0,

  543.                    TEST_WAIT_CODE(0U, 0U), 0, 0U, 2);

  544.     TestSetSegment(&memory, 2U, 1000U, 0,

  545.                    TEST_WAIT_CODE(0U, 0U), 0, 1U, 300);

  546.     TestSetSegment(&memory, 3U, 1000U, 100,

  547.                    TEST_WAIT_CODE(0U, 0U), 0, 0U, 0);

  548.     TestWriteDword(&memory, PLSR_DEVICE_D, 300U, 2);

  549.     {

  550.         PLSR_CALL call = TestMakeCall(&memory);

  551. 

  552.         call.sequence = 100UL;

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

  554.     }

  555.     PlsrProcess();

  556. 

  557.     /* 每轮 100 次预算：零脉冲自循环链停在段2 并让出，任务不结束。 */

  558.     CHECK(TestGetStatus().state == PLSR_STATE_ACCEL);

  559.     CHECK(TestGetStatus().currentSegment == 2U);

  560.     CHECK(TestGetStatus().done == 0U);

  561.     for (rounds = 0; rounds < 3; rounds++)

  562.     {

  563.         PlsrProcess();

  564.     }

  565.     CHECK(TestGetStatus().state == PLSR_STATE_ACCEL);

  566.     CHECK(TestGetStatus().currentSegment == 2U);

  567.     CHECK(TestGetStatus().done == 0U);

  568. 

  569.     /* 运行中改动态跳转目标 → 链走向段3（有脉冲）→ 正常执行并完成。 */

  570.     TestWriteDword(&memory, PLSR_DEVICE_D, 300U, 3);

  571.     PlsrProcess();

  572.     CHECK(TestGetStatus().state == PLSR_STATE_ACCEL);

  573.     CHECK(TestGetStatus().currentSegment == 3U);

  574.     TestAccelToRun();

  575.     CHECK(PlsrPostEvent(0U, PLSR_EVENT_SEGMENT_COMPLETE) == PLSR_RESULT_OK);

  576.     PlsrProcess();

  577.     CHECK(TestGetStatus().state == PLSR_STATE_COMPLETED);

  578. }

  579. 

  580. static void TestSelfLoopInterruptedByStop(void)

  581. {

  582.     TEST_MEMORY memory;

  583.     PLSR_COMMAND command;

  584. 

  585.     TestResetEnvironment();

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

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

  588.     TestSetSegment(&memory, 1U, 1000U, 100,

  589.                    TEST_WAIT_CODE(0U, 0U), 0, 0U, 1);

  590.     {

  591.         PLSR_CALL call = TestMakeCall(&memory);

  592. 

  593.         call.sequence = 110UL;

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

  595.     }

  596.     PlsrProcess();

  597.     TestAccelToRun();

  598. 

  599.     /* 段1 完成 → 自跳转回段1。 */

  600.     CHECK(PlsrPostEvent(0U, PLSR_EVENT_SEGMENT_COMPLETE) == PLSR_RESULT_OK);

  601.     PlsrProcess();

  602.     CHECK(TestGetStatus().state == PLSR_STATE_ACCEL);

  603.     CHECK(TestGetStatus().currentSegment == 1U);

  604. 

  605.     /* STOP 可打断自循环。 */

  606.     command.sequence = 111UL;

  607.     command.axis = 0U;

  608.     command.opcode = PLSR_CMD_STOP_IMMEDIATE;

  609.     command.argument = 0;

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

  611.     PlsrProcess();

  612.     CHECK(PlsrPostEvent(0U, PLSR_EVENT_STOP_IMMEDIATE_DONE)

  613.           == PLSR_RESULT_OK);

  614.     PlsrProcess();

  615.     CHECK(TestGetStatus().state == PLSR_STATE_STOPPED);

  616.     CHECK(TestGetStatus().done == 0U);

  617. }

  618. 

  619. static void TestLastSegmentWaitTime(void)

  620. {

  621.     TEST_MEMORY memory;

  622.     int ticks;

  623. 

  624.     TestResetEnvironment();

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

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

  627.     TestSetSegment(&memory, 1U, 1000U, 100, TEST_WAIT_CODE(0U, 0U), 0, 0U, 0);

  628.     /* 最后一段用 WAIT 时间（信捷警告场景：验证不会卡死）。 */

  629.     TestSetSegment(&memory, 2U, 2000U, 200,

  630.                    TEST_WAIT_CODE(1U, 0U), 100, 0U, 0);

  631.     {

  632.         PLSR_CALL call = TestMakeCall(&memory);

  633. 

  634.         call.sequence = 120UL;

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

  636.     }

  637.     PlsrProcess();

  638.     TestAccelToRun();

  639.     CHECK(PlsrPostEvent(0U, PLSR_EVENT_SEGMENT_COMPLETE) == PLSR_RESULT_OK);

  640.     PlsrProcess();

  641.     TestAccelToRun();

  642. 

  643.     /* 段2（最后一段）完成 → 等待 100ms。 */

  644.     CHECK(PlsrPostEvent(0U, PLSR_EVENT_SEGMENT_COMPLETE) == PLSR_RESULT_OK);

  645.     PlsrProcess();

  646.     CHECK(TestGetStatus().state == PLSR_STATE_WAIT);

  647. 

  648.     /* 计时到 → 任务正常结束。 */

  649.     for (ticks = 0; ticks < 100; ticks++)

  650.     {

  651.         PlsrProcess();

  652.     }

  653.     CHECK(TestGetStatus().state == PLSR_STATE_COMPLETED);

  654.     CHECK(TestGetStatus().done != 0U);

  655. }

  656. 

  657. int main(void)

  658. {

  659.     TestSequentialSegments();

  660.     TestJumpToSpecifiedSegment();

  661.     TestWaitTime();

  662.     TestWaitSignal();

  663.     TestActTruncatesSegment();

  664.     TestActPendingAfterSegmentDone();

  665.     TestExtEdgeTruncates();

  666.     TestExtOrComplete();

  667.     TestDynamicJump();

  668.     TestAbsoluteZeroDisplacement();

  669.     TestZeroJumpBudgetYields();

  670.     TestSelfLoopInterruptedByStop();

  671.     TestLastSegmentWaitTime();

  672. 

  673.     if (TestFailures != 0)

  674.     {

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

  676.                      TestFailures,

  677.                      TestChecks);

  678.         return 1;

  679.     }

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

  681.     return 0;

  682. }