yuwenhao
/
Modbus-rtu
1
0
Förgrening 0
Kod Ärenden 0 Pull-förfrågningar 0 Släpp 0 Wiki Aktiviteter
Du kan inte välja fler än 25 ämnen Ämnen måste starta med en bokstav eller siffra, kan innehålla bindestreck ('-') och vara max 35 tecken långa.
40 Incheckningar
3 Grenar
138 MiB
 
 
 
 
 
 
Träd: 7750e43045
Grenar Taggar
${ item.name }
Skapa branchen ${ searchTerm }
från '7750e43045'
${ noResults }
Modbus-rtu/PLSR/Src/plsr_self_test.c

344 rader
12 KiB
Rå Blame Historik 

  1. #include "plsr_self_test.h"

  2. #include "plc_device.h"

  3. #include "plsr_core.h"

  4. #include "plsr_job.h"

  5. #include <string.h>

  6. 

  7. /* 上电自测（验证后可删除）：

  8.  * - AB 模式使用 Q0(A)/Q1(B)，其余用出厂默认参数（K1）

  9.  * - 任务：3 段完整 AB 周期（H00 完成，顺序衔接）：

  10.  *   段1：2000Hz / +1000 周期（A 超前 B）

  11.  *   段2：5000Hz / +6000 周期（A 超前 B）

  12.  *   段3：1000Hz / -500 周期（B 超前 A，验证反向）

  13.  * 数据源为静态数组，仅自测使用（正式 D 设备适配器见 Modbus 阶段）。 */

  14. 

  15. #define SELF_TEST_WORD_CAPACITY     (192U)

  16. #define SELF_TEST_S0_BASE           (10U)

  17. #define SELF_TEST_S1_BASE           (60U)

  18. #define SELF_TEST_DIR_POINT         (4U)

  19. #define SELF_TEST_SFD_AXIS_STRIDE   (130U)

  20. #define SELF_TEST_SFD_SET_OFFSET    (50U)

  21. 

  22. static uint16_t SelfTestWords[3][SELF_TEST_WORD_CAPACITY];

  23. 

  24. static uint8_t SelfTestValidateWords(void *context,

  25.                                      PLSR_DEVICE_TYPE device,

  26.                                      uint32_t firstAddress,

  27.                                      uint32_t wordCount)

  28. {

  29.     (void)context;

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

  31.     {

  32.         return 0U;

  33.     }

  34.     return (((uint64_t)firstAddress + wordCount)

  35.             <= SELF_TEST_WORD_CAPACITY)

  36.                ? 1U

  37.                : 0U;

  38. }

  39. 

  40. static uint8_t SelfTestReadWord(void *context,

  41.                                 PLSR_DEVICE_TYPE device,

  42.                                 uint32_t address,

  43.                                 uint16_t *value)

  44. {

  45.     (void)context;

  46.     if ((device > PLSR_DEVICE_FD) || (value == NULL)

  47.         || (address >= SELF_TEST_WORD_CAPACITY))

  48.     {

  49.         return 0U;

  50.     }

  51.     *value = SelfTestWords[device][address];

  52.     return 1U;

  53. }

  54. 

  55. static uint8_t SelfTestReadBit(void *context,

  56.                                PLSR_DEVICE_TYPE device,

  57.                                uint32_t address,

  58.                                uint8_t *value)

  59. {

  60.     (void)context;

  61.     (void)device;

  62.     (void)address;

  63.     *value = 0U;

  64.     return 1U;

  65. }

  66. 

  67. static void SelfTestWriteDword(PLSR_DEVICE_TYPE device,

  68.                                uint32_t address,

  69.                                uint32_t value)

  70. {

  71.     SelfTestWords[device][address] = (uint16_t)(value & 0xFFFFUL);

  72.     SelfTestWords[device][address + 1UL] = (uint16_t)(value >> 16U);

  73. }

  74. 

  75. static void SelfTestWriteSfdDword(uint16_t address, uint32_t value)

  76. {

  77.     (void)PlcDeviceWriteSfd(address, (uint16_t)(value & 0xFFFFUL));

  78.     (void)PlcDeviceWriteSfd((uint16_t)(address + 1U),

  79.                             (uint16_t)(value >> 16U));

  80. }

  81. 

  82. PLSR_RESULT PlsrSelfTestQueue(void)

  83. {

  84.     PLSR_CALL call;

  85. 

  86.     (void)memset(SelfTestWords, 0, sizeof(SelfTestWords));

  87. 

  88.     /* 方向端子 Y4（PULSE/DIR 模式必需，接线参数）。 */

  89.     (void)PlcDeviceWriteSfd(906U, SELF_TEST_DIR_POINT);

  90.     (void)PlcDeviceWriteSfd(912U, 0U);

  91.     (void)PlcDeviceWriteSfd(915U, 0xFFFFU);

  92. 

  93.     /* S0：3 段，H00 完成，顺序跳转。 */

  94.     SelfTestWriteDword(PLSR_DEVICE_D, SELF_TEST_S0_BASE, 3U);

  95.     SelfTestWriteDword(PLSR_DEVICE_D, SELF_TEST_S0_BASE + 10U, 2000UL);

  96.     SelfTestWriteDword(PLSR_DEVICE_D, SELF_TEST_S0_BASE + 12U, 1000UL);

  97.     SelfTestWriteDword(PLSR_DEVICE_D, SELF_TEST_S0_BASE + 20U, 5000UL);

  98.     SelfTestWriteDword(PLSR_DEVICE_D, SELF_TEST_S0_BASE + 22U, 6000UL);

  99.     SelfTestWriteDword(PLSR_DEVICE_D, SELF_TEST_S0_BASE + 30U, 1000UL);

  100.     SelfTestWriteDword(PLSR_DEVICE_D,

  101.                        SELF_TEST_S0_BASE + 32U,

  102.                        (uint32_t)(int32_t)-500);

  103. 

  104.     /* S1：相对模式，起始段 0（=段1）。 */

  105.     SelfTestWriteDword(PLSR_DEVICE_D, SELF_TEST_S1_BASE, 0U);

  106. 

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

  108.     call.sequence = 0xA5A5UL;

  109.     call.source.context = NULL;

  110.     call.source.validateWords = SelfTestValidateWords;

  111.     call.source.readWord = SelfTestReadWord;

  112.     call.source.readBit = SelfTestReadBit;

  113.     call.s0.device = PLSR_DEVICE_D;

  114.     call.s0.address = SELF_TEST_S0_BASE;

  115.     call.s1.device = PLSR_DEVICE_D;

  116.     call.s1.address = SELF_TEST_S1_BASE;

  117.     call.s2.type = PLSR_OPERAND_CONSTANT;

  118.     call.s2.constant = 1;

  119.     call.dAxis = 0U;

  120.     call.outputModeOverride = PLSR_OUTPUT_AB;

  121.     return PlsrPostCall(&call);

  122. }

  123. 

  124. PLSR_RESULT PlsrEquivalentSelfTestQueue(void)

  125. {

  126.     PLSR_CALL call;

  127. 

  128.     (void)memset(SelfTestWords, 0, sizeof(SelfTestWords));

  129. 

  130.     /* SFD900 Bit10~8=001（1um当量）；3脉冲/2单位。 */

  131.     (void)PlcDeviceWriteSfd(900U, (1U << 8U));

  132.     SelfTestWriteSfdDword(902U, 3UL);

  133.     SelfTestWriteSfdDword(904U, 2UL);

  134.     (void)PlcDeviceWriteSfd(906U, SELF_TEST_DIR_POINT);

  135.     (void)PlcDeviceWriteSfd(907U, 10U);

  136.     (void)PlcDeviceWriteSfd(912U, 0U);

  137.     (void)PlcDeviceWriteSfd(915U, 0xFFFFU);

  138.     /* 当量换算后物理最高速度=90000Hz，不超过硬件100kHz。 */

  139.     SelfTestWriteSfdDword(956U, 60000UL);

  140. 

  141.     /* 板端可观察版本：两段各1001工程单位。

  142.      * 3脉冲/2单位带余数换算后分别输出1501、1502脉冲，累计3003脉冲；

  143.      * 1500Hz附近持续约2s，避免原3脉冲自检在逻辑分析仪启动前已经结束。 */

  144.     SelfTestWriteDword(PLSR_DEVICE_D, SELF_TEST_S0_BASE, 2U);

  145.     SelfTestWriteDword(PLSR_DEVICE_D, SELF_TEST_S0_BASE + 10U, 1000UL);

  146.     SelfTestWriteDword(PLSR_DEVICE_D, SELF_TEST_S0_BASE + 12U, 1001UL);

  147.     SelfTestWriteDword(PLSR_DEVICE_D, SELF_TEST_S0_BASE + 20U, 1000UL);

  148.     SelfTestWriteDword(PLSR_DEVICE_D, SELF_TEST_S0_BASE + 22U, 1001UL);

  149.     SelfTestWriteDword(PLSR_DEVICE_D, SELF_TEST_S1_BASE, 0U);

  150. 

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

  152.     call.sequence = 0xA5A6UL;

  153.     call.source.context = NULL;

  154.     call.source.validateWords = SelfTestValidateWords;

  155.     call.source.readWord = SelfTestReadWord;

  156.     call.source.readBit = SelfTestReadBit;

  157.     call.s0.device = PLSR_DEVICE_D;

  158.     call.s0.address = SELF_TEST_S0_BASE;

  159.     call.s1.device = PLSR_DEVICE_D;

  160.     call.s1.address = SELF_TEST_S1_BASE;

  161.     call.s2.type = PLSR_OPERAND_CONSTANT;

  162.     call.s2.constant = 1;

  163.     call.dAxis = 0U;

  164.     call.outputModeOverride = PLSR_OUTPUT_PULSE_DIR;

  165.     return PlsrPostCall(&call);

  166. }

  167. 

  168. PLSR_RESULT PlsrProtectionSelfTestQueue(void)

  169. {

  170.     PLSR_CALL call;

  171.     PLSR_COMMAND command;

  172.     PLSR_RESULT result;

  173. 

  174.     (void)memset(SelfTestWords, 0, sizeof(SelfTestWords));

  175. 

  176.     /* Pulse unit, soft limits enabled, 1 pulse per position unit. */

  177.     (void)PlcDeviceWriteSfd(900U, (1U << 2U));

  178.     SelfTestWriteSfdDword(902U, 1UL);

  179.     SelfTestWriteSfdDword(904U, 1UL);

  180.     (void)PlcDeviceWriteSfd(906U, SELF_TEST_DIR_POINT);

  181.     (void)PlcDeviceWriteSfd(907U, 10U);

  182.     (void)PlcDeviceWriteSfd(912U, 0U);

  183.     (void)PlcDeviceWriteSfd(915U, 0xFFFFU);

  184.     SelfTestWriteSfdDword(930U, 500UL);

  185.     SelfTestWriteSfdDword(932U, (uint32_t)(int32_t)-500);

  186. 

  187.     /* K1: 1000Hz, 100ms acceleration/deceleration, 1ms refresh. */

  188.     SelfTestWriteSfdDword(950U, 1000UL);

  189.     (void)PlcDeviceWriteSfd(952U, 100U);

  190.     (void)PlcDeviceWriteSfd(953U, 100U);

  191.     (void)PlcDeviceWriteSfd(954U, 0U);

  192.     (void)PlcDeviceWriteSfd(955U, 0U);

  193.     SelfTestWriteSfdDword(956U, 100000UL);

  194.     SelfTestWriteSfdDword(958U, 1000UL);

  195.     SelfTestWriteSfdDword(960U, 0UL);

  196.     (void)PlcDeviceWriteSfd(962U, 50U);

  197.     (void)PlcDeviceWriteSfd(963U, 0U);

  198.     (void)PlcDeviceWriteSfd(964U, 0U);

  199.     SelfTestWriteSfdDword(966U, 2000UL);

  200.     SelfTestWriteSfdDword(968U, 200UL);

  201. 

  202.     /* One relative segment requests +10000 pulses; +500 must stop it. */

  203.     SelfTestWriteDword(PLSR_DEVICE_D, SELF_TEST_S0_BASE, 1U);

  204.     SelfTestWriteDword(PLSR_DEVICE_D,

  205.                        SELF_TEST_S0_BASE + 10U,

  206.                        1000UL);

  207.     SelfTestWriteDword(PLSR_DEVICE_D,

  208.                        SELF_TEST_S0_BASE + 12U,

  209.                        10000UL);

  210.     SelfTestWriteDword(PLSR_DEVICE_D, SELF_TEST_S1_BASE, 0U);

  211. 

  212.     (void)memset(&command, 0, sizeof(command));

  213.     command.sequence = 0xA5A7UL;

  214.     command.axis = 0U;

  215.     command.opcode = PLSR_CMD_SET_POSITION;

  216.     command.argument = 0;

  217.     result = PlsrPostCommand(&command);

  218.     if (result != PLSR_RESULT_QUEUED)

  219.     {

  220.         return result;

  221.     }

  222. 

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

  224.     call.sequence = 0xA5A8UL;

  225.     call.source.context = NULL;

  226.     call.source.validateWords = SelfTestValidateWords;

  227.     call.source.readWord = SelfTestReadWord;

  228.     call.source.readBit = SelfTestReadBit;

  229.     call.s0.device = PLSR_DEVICE_D;

  230.     call.s0.address = SELF_TEST_S0_BASE;

  231.     call.s1.device = PLSR_DEVICE_D;

  232.     call.s1.address = SELF_TEST_S1_BASE;

  233.     call.s2.type = PLSR_OPERAND_CONSTANT;

  234.     call.s2.constant = 1;

  235.     call.dAxis = 0U;

  236.     call.outputModeOverride = PLSR_OUTPUT_PULSE_DIR;

  237.     return PlsrPostCall(&call);

  238. }

  239. 

  240. PLSR_RESULT PlsrFourAxisSelfTestQueue(void)

  241. {

  242.     static const uint16_t s0Base[PLSR_AXIS_COUNT] =

  243.     {

  244.         10U, 40U, 70U, 100U

  245.     };

  246.     static const uint16_t s1Base[PLSR_AXIS_COUNT] =

  247.     {

  248.         160U, 164U, 168U, 172U

  249.     };

  250.     static const uint32_t frequencyHz[PLSR_AXIS_COUNT] =

  251.     {

  252.         1000UL, 2000UL, 3000UL, 4000UL

  253.     };

  254.     static const int32_t pulseCount[PLSR_AXIS_COUNT] =

  255.     {

  256.         1000, 2000, 3000, 4000

  257.     };

  258.     PLSR_CALL call;

  259.     PLSR_COMMAND command;

  260.     PLSR_RESULT result;

  261.     uint16_t commonBase;

  262.     uint16_t setBase;

  263.     uint8_t axis;

  264. 

  265.     (void)memset(SelfTestWords, 0, sizeof(SelfTestWords));

  266. 

  267.     for (axis = 0U; axis < PLSR_AXIS_COUNT; axis++)

  268.     {

  269.         commonBase = (uint16_t)(900U

  270.                                 + (uint16_t)axis

  271.                                       * SELF_TEST_SFD_AXIS_STRIDE);

  272.         setBase = (uint16_t)(commonBase + SELF_TEST_SFD_SET_OFFSET);

  273. 

  274.         /* Pulse unit, PULSE/DIR, no limit input, Q4..Q7 as DIR. */

  275.         (void)PlcDeviceWriteSfd(commonBase, 0U);

  276.         SelfTestWriteSfdDword((uint16_t)(commonBase + 2U), 1UL);

  277.         SelfTestWriteSfdDword((uint16_t)(commonBase + 4U), 1UL);

  278.         (void)PlcDeviceWriteSfd((uint16_t)(commonBase + 6U),

  279.                                 (uint16_t)(SELF_TEST_DIR_POINT + axis));

  280.         (void)PlcDeviceWriteSfd((uint16_t)(commonBase + 7U), 10U);

  281.         (void)PlcDeviceWriteSfd((uint16_t)(commonBase + 12U), 0U);

  282.         (void)PlcDeviceWriteSfd((uint16_t)(commonBase + 15U), 0xFFFFU);

  283. 

  284.         /* K1 has no ramp so all four channels keep an exact fixed rate. */

  285.         SelfTestWriteSfdDword(setBase, frequencyHz[axis]);

  286.         (void)PlcDeviceWriteSfd((uint16_t)(setBase + 2U), 0U);

  287.         (void)PlcDeviceWriteSfd((uint16_t)(setBase + 3U), 0U);

  288.         (void)PlcDeviceWriteSfd((uint16_t)(setBase + 4U), 0U);

  289.         (void)PlcDeviceWriteSfd((uint16_t)(setBase + 5U), 0U);

  290.         SelfTestWriteSfdDword((uint16_t)(setBase + 6U), 100000UL);

  291.         SelfTestWriteSfdDword((uint16_t)(setBase + 8U),

  292.                               frequencyHz[axis]);

  293.         SelfTestWriteSfdDword((uint16_t)(setBase + 10U), 0UL);

  294.         (void)PlcDeviceWriteSfd((uint16_t)(setBase + 12U), 50U);

  295.         (void)PlcDeviceWriteSfd((uint16_t)(setBase + 13U), 0U);

  296.         (void)PlcDeviceWriteSfd((uint16_t)(setBase + 14U), 0U);

  297.         SelfTestWriteSfdDword((uint16_t)(setBase + 16U), 2000UL);

  298.         SelfTestWriteSfdDword((uint16_t)(setBase + 18U), 200UL);

  299. 

  300.         SelfTestWriteDword(PLSR_DEVICE_D, s0Base[axis], 1U);

  301.         SelfTestWriteDword(PLSR_DEVICE_D,

  302.                            (uint32_t)s0Base[axis] + 10UL,

  303.                            frequencyHz[axis]);

  304.         SelfTestWriteDword(PLSR_DEVICE_D,

  305.                            (uint32_t)s0Base[axis] + 12UL,

  306.                            (uint32_t)pulseCount[axis]);

  307.         SelfTestWriteDword(PLSR_DEVICE_D, s1Base[axis], 0U);

  308. 

  309.         /* Make the board-test result independent of a previously restored

  310.          * Backup SRAM position. */

  311.         (void)memset(&command, 0, sizeof(command));

  312.         command.sequence = 0xA500UL + axis;

  313.         command.axis = axis;

  314.         command.opcode = PLSR_CMD_SET_POSITION;

  315.         command.argument = 0;

  316.         result = PlsrPostCommand(&command);

  317.         if (result != PLSR_RESULT_QUEUED)

  318.         {

  319.             return result;

  320.         }

  321. 

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

  323.         call.sequence = 0xA600UL + axis;

  324.         call.source.context = NULL;

  325.         call.source.validateWords = SelfTestValidateWords;

  326.         call.source.readWord = SelfTestReadWord;

  327.         call.source.readBit = SelfTestReadBit;

  328.         call.s0.device = PLSR_DEVICE_D;

  329.         call.s0.address = s0Base[axis];

  330.         call.s1.device = PLSR_DEVICE_D;

  331.         call.s1.address = s1Base[axis];

  332.         call.s2.type = PLSR_OPERAND_CONSTANT;

  333.         call.s2.constant = 1;

  334.         call.dAxis = axis;

  335.         call.outputModeOverride = PLSR_OUTPUT_PULSE_DIR;

  336.         result = PlsrPostCall(&call);

  337.         if (result != PLSR_RESULT_QUEUED)

  338.         {

  339.             return result;

  340.         }

  341.     }

  342.     return PLSR_RESULT_QUEUED;

  343. }