yuwenhao
/
Modbus-rtu
1
0
Vork 0
Code Kwesties 0 Pull-aanvragen 0 Publicaties 0 Wiki Activiteit
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.
41 Commits
3 Branches
138 MiB
 
 
 
 
 
 
Tree: fdbbe71aea
Branches Labels
${ item.name }
Maak branch ${ searchTerm }
van 'fdbbe71aea'
${ noResults }
Modbus-rtu/PLSR/Src/plsr_modbus_control.c

571 regels
20 KiB
Ruw Blame Geschiedenis 

  1. #include "plsr_modbus_control.h"

  2. #include "modbus_data_store.h"

  3. #include "plsr_address_map.h"

  4. #include "plsr_core.h"

  5. #include "plsr_job.h"

  6. #include "plsr_modbus_data.h"

  7. #include <stddef.h>

  8. #include <string.h>

  9. 

  10. #define PLSR_MODBUS_MAGIC_LOW             (0x504CU)

  11. #define PLSR_MODBUS_MAGIC_HIGH            (0x5352U)

  12. #define PLSR_MODBUS_CAPABILITIES          (0x0007U)

  13. #define PLSR_MODBUS_CALL_REQUEST_WORDS    (16UL)

  14. #define PLSR_MODBUS_CALL_RESPONSE_WORDS   (12UL)

  15. #define PLSR_MODBUS_COMMAND_REQUEST_WORDS (8UL)

  16. #define PLSR_MODBUS_COMMAND_RESPONSE_WORDS (8UL)

  17. #define PLSR_MODBUS_S0_HEADER_WORDS       (10UL)

  18. #define PLSR_MODBUS_S0_SEGMENT_WORDS      (10UL)

  19. #define PLSR_MODBUS_S1_WORDS              (4UL)

  20. #define PLSR_MODBUS_HASH_OFFSET           (2166136261UL)

  21. #define PLSR_MODBUS_HASH_PRIME            (16777619UL)

  22. 

  23. typedef struct

  24. {

  25.     PLSR_CALL call;

  26.     uint32_t fingerprint;

  27.     uint8_t valid;

  28. } PLSR_MODBUS_COMMITTED_CALL;

  29. 

  30. static uint16_t PlsrModbusBaseAddress;

  31. static uint8_t PlsrModbusEnabled;

  32. static uint32_t PlsrModbusLastCallRequestSequence;

  33. static uint32_t PlsrModbusLastCommandRequestSequence;

  34. static uint32_t PlsrModbusStatusGeneration[PLSR_AXIS_COUNT];

  35. static PLSR_MODBUS_COMMITTED_CALL PlsrModbusCommitted[PLSR_AXIS_COUNT];

  36. static uint16_t PlsrModbusStatusWords[PLSR_AXIS_COUNT]

  37.                                       [PLSR_MODBUS_AXIS_STATUS_WORDS];

  38. static const uint16_t PlsrModbusZeroWindow[PLSR_MODBUS_WINDOW_WORDS] = {0U};

  39. 

  40. static void PlsrModbusPutU32(uint16_t *words,

  41.                              uint32_t offset,

  42.                              uint32_t value)

  43. {

  44.     words[offset] = (uint16_t)(value & 0xFFFFUL);

  45.     words[offset + 1UL] = (uint16_t)(value >> 16U);

  46. }

  47. 

  48. static void PlsrModbusPutU64(uint16_t *words,

  49.                              uint32_t offset,

  50.                              uint64_t value)

  51. {

  52.     words[offset] = (uint16_t)(value & 0xFFFFULL);

  53.     words[offset + 1UL] = (uint16_t)((value >> 16U) & 0xFFFFULL);

  54.     words[offset + 2UL] = (uint16_t)((value >> 32U) & 0xFFFFULL);

  55.     words[offset + 3UL] = (uint16_t)(value >> 48U);

  56. }

  57. 

  58. static uint32_t PlsrModbusGetU32(const uint16_t *words, uint32_t offset)

  59. {

  60.     return ((uint32_t)words[offset + 1UL] << 16U) | words[offset];

  61. }

  62. 

  63. static uint64_t PlsrModbusGetU64(const uint16_t *words, uint32_t offset)

  64. {

  65.     return ((uint64_t)words[offset + 3UL] << 48U)

  66.            | ((uint64_t)words[offset + 2UL] << 32U)

  67.            | ((uint64_t)words[offset + 1UL] << 16U)

  68.            | words[offset];

  69. }

  70. 

  71. static uint8_t PlsrModbusReadWords(uint32_t offset,

  72.                                    uint16_t *words,

  73.                                    uint32_t wordCount)

  74. {

  75.     uint32_t index;

  76. 

  77.     if (words == NULL)

  78.     {

  79.         return 0U;

  80.     }

  81.     for (index = 0UL; index < wordCount; index++)

  82.     {

  83.         if (ModbusDataReadWord(MODBUS_DATA_DEVICE_D,

  84.                                (uint32_t)PlsrModbusBaseAddress + offset + index,

  85.                                &words[index]) == 0U)

  86.         {

  87.             return 0U;

  88.         }

  89.     }

  90.     return 1U;

  91. }

  92. 

  93. static uint8_t PlsrModbusRangesOverlap(uint32_t firstA,

  94.                                        uint32_t countA,

  95.                                        uint32_t firstB,

  96.                                        uint32_t countB)

  97. {

  98.     return ((firstA < (firstB + countB)) && (firstB < (firstA + countA)))

  99.                ? 1U

  100.                : 0U;

  101. }

  102. 

  103. static uint32_t PlsrModbusHashWord(uint32_t hash, uint16_t value)

  104. {

  105.     hash ^= (uint8_t)(value & 0x00FFU);

  106.     hash *= PLSR_MODBUS_HASH_PRIME;

  107.     hash ^= (uint8_t)(value >> 8U);

  108.     hash *= PLSR_MODBUS_HASH_PRIME;

  109.     return hash;

  110. }

  111. 

  112. static uint32_t PlsrModbusHashU32(uint32_t hash, uint32_t value)

  113. {

  114.     hash = PlsrModbusHashWord(hash, (uint16_t)(value & 0xFFFFUL));

  115.     return PlsrModbusHashWord(hash, (uint16_t)(value >> 16U));

  116. }

  117. 

  118. static PLSR_RESULT PlsrModbusFingerprintCall(const PLSR_CALL *call,

  119.                                               uint32_t *fingerprint)

  120. {

  121.     uint16_t word;

  122.     int32_t segmentCount;

  123.     uint32_t s0Words;

  124.     uint32_t index;

  125.     uint32_t hash = PLSR_MODBUS_HASH_OFFSET;

  126. 

  127.     if ((call == NULL) || (fingerprint == NULL)

  128.         || (call->source.readDword == NULL)

  129.         || (call->source.readWord == NULL)

  130.         || (call->source.validateWords == NULL))

  131.     {

  132.         return PLSR_RESULT_INVALID_ARGUMENT;

  133.     }

  134.     if (call->source.readDword(call->source.context,

  135.                                call->s0.device,

  136.                                call->s0.address,

  137.                                &segmentCount) == 0U)

  138.     {

  139.         return PLSR_RESULT_DATA_ACCESS;

  140.     }

  141.     if ((segmentCount < 1) || (segmentCount > (int32_t)PLSR_MAX_SEGMENTS))

  142.     {

  143.         return PLSR_RESULT_SEGMENT_OVERFLOW;

  144.     }

  145.     s0Words = PLSR_MODBUS_S0_HEADER_WORDS

  146.               + (uint32_t)segmentCount * PLSR_MODBUS_S0_SEGMENT_WORDS;

  147.     if ((call->source.validateWords(call->source.context,

  148.                                     call->s0.device,

  149.                                     call->s0.address,

  150.                                     s0Words) == 0U)

  151.         || (call->source.validateWords(call->source.context,

  152.                                        call->s1.device,

  153.                                        call->s1.address,

  154.                                        PLSR_MODBUS_S1_WORDS) == 0U))

  155.     {

  156.         return PLSR_RESULT_DATA_ACCESS;

  157.     }

  158.     if (((call->s0.device == PLSR_DEVICE_D)

  159.          && (PlsrModbusRangesOverlap(call->s0.address,

  160.                                      s0Words,

  161.                                      PlsrModbusBaseAddress,

  162.                                      PLSR_MODBUS_WINDOW_WORDS) != 0U))

  163.         || ((call->s1.device == PLSR_DEVICE_D)

  164.             && (PlsrModbusRangesOverlap(call->s1.address,

  165.                                         PLSR_MODBUS_S1_WORDS,

  166.                                         PlsrModbusBaseAddress,

  167.                                         PLSR_MODBUS_WINDOW_WORDS) != 0U)))

  168.     {

  169.         return PLSR_RESULT_BLOCK_OVERLAP;

  170.     }

  171. 

  172.     hash = PlsrModbusHashWord(hash, (uint16_t)call->s0.device);

  173.     hash = PlsrModbusHashU32(hash, call->s0.address);

  174.     for (index = 0UL; index < s0Words; index++)

  175.     {

  176.         if (call->source.readWord(call->source.context,

  177.                                   call->s0.device,

  178.                                   call->s0.address + index,

  179.                                   &word) == 0U)

  180.         {

  181.             return PLSR_RESULT_DATA_ACCESS;

  182.         }

  183.         hash = PlsrModbusHashWord(hash, word);

  184.     }

  185.     hash = PlsrModbusHashWord(hash, (uint16_t)call->s1.device);

  186.     hash = PlsrModbusHashU32(hash, call->s1.address);

  187.     for (index = 0UL; index < PLSR_MODBUS_S1_WORDS; index++)

  188.     {

  189.         if (call->source.readWord(call->source.context,

  190.                                   call->s1.device,

  191.                                   call->s1.address + index,

  192.                                   &word) == 0U)

  193.         {

  194.             return PLSR_RESULT_DATA_ACCESS;

  195.         }

  196.         hash = PlsrModbusHashWord(hash, word);

  197.     }

  198.     hash = PlsrModbusHashWord(hash, (uint16_t)call->s2.type);

  199.     hash = PlsrModbusHashWord(hash, (uint16_t)call->s2.data.device);

  200.     hash = PlsrModbusHashU32(hash, call->s2.data.address);

  201.     hash = PlsrModbusHashU32(hash, (uint32_t)call->s2.constant);

  202.     if (call->s2.type == PLSR_OPERAND_DATA)

  203.     {

  204.         for (index = 0UL; index < 2UL; index++)

  205.         {

  206.             if (call->source.readWord(call->source.context,

  207.                                       call->s2.data.device,

  208.                                       call->s2.data.address + index,

  209.                                       &word) == 0U)

  210.             {

  211.                 return PLSR_RESULT_DATA_ACCESS;

  212.             }

  213.             hash = PlsrModbusHashWord(hash, word);

  214.         }

  215.     }

  216.     hash = PlsrModbusHashWord(hash, call->dAxis);

  217.     hash = PlsrModbusHashWord(hash, call->outputModeOverride);

  218.     *fingerprint = hash;

  219.     return PLSR_RESULT_OK;

  220. }

  221. 

  222. static PLSR_RESULT PlsrModbusBuildCall(const uint16_t *request,

  223.                                         PLSR_CALL *call)

  224. {

  225.     uint16_t s2Type;

  226.     uint16_t outputMode;

  227. 

  228.     if ((request == NULL) || (call == NULL))

  229.     {

  230.         return PLSR_RESULT_INVALID_ARGUMENT;

  231.     }

  232.     s2Type = request[8UL];

  233.     outputMode = request[13UL];

  234.     if ((request[2UL] > (uint16_t)PLSR_DEVICE_FD)

  235.         || (request[5UL] > (uint16_t)PLSR_DEVICE_FD)

  236.         || (s2Type > (uint16_t)PLSR_OPERAND_DATA)

  237.         || ((s2Type == (uint16_t)PLSR_OPERAND_DATA)

  238.             && (request[9UL] > (uint16_t)PLSR_DEVICE_FD))

  239.         || (request[12UL] >= PLSR_AXIS_COUNT)

  240.         || ((outputMode > (uint16_t)PLSR_OUTPUT_CW_CCW)

  241.             && (outputMode != PLSR_OUTPUT_MODE_FROM_SFD)))

  242.     {

  243.         return PLSR_RESULT_INVALID_ARGUMENT;

  244.     }

  245. 

  246.     (void)memset(call, 0, sizeof(*call));

  247.     call->sequence = PlsrModbusGetU32(request, 0UL);

  248.     call->s0.device = (PLSR_DEVICE_TYPE)request[2UL];

  249.     call->s0.address = PlsrModbusGetU32(request, 3UL);

  250.     call->s1.device = (PLSR_DEVICE_TYPE)request[5UL];

  251.     call->s1.address = PlsrModbusGetU32(request, 6UL);

  252.     call->s2.type = (PLSR_OPERAND_TYPE)s2Type;

  253.     call->s2.data.device = (PLSR_DEVICE_TYPE)request[9UL];

  254.     call->s2.data.address = PlsrModbusGetU32(request, 10UL);

  255.     call->s2.constant = (int32_t)PlsrModbusGetU32(request, 10UL);

  256.     call->dAxis = (uint8_t)request[12UL];

  257.     call->outputModeOverride = (uint8_t)outputMode;

  258.     PlsrModbusDataSourceInit(&call->source);

  259.     return PLSR_RESULT_OK;

  260. }

  261. 

  262. static void PlsrModbusPublishCallResponse(uint32_t sequence,

  263.                                           uint16_t operation,

  264.                                           PLSR_RESULT result,

  265.                                           const PLSR_PARSE_DETAIL *detail,

  266.                                           uint8_t committed)

  267. {

  268.     uint16_t response[PLSR_MODBUS_CALL_RESPONSE_WORDS] = {0U};

  269. 

  270.     PlsrModbusPutU32(response, 0UL, sequence);

  271.     response[2UL] = operation;

  272.     response[3UL] = (uint16_t)result;

  273.     if (detail != NULL)

  274.     {

  275.         response[4UL] = (uint16_t)detail->result;

  276.         response[5UL] = (uint16_t)detail->block;

  277.         PlsrModbusPutU32(response, 6UL, detail->address);

  278.         PlsrModbusPutU32(response, 8UL, (uint32_t)detail->value);

  279.         response[10UL] = detail->segment;

  280.     }

  281.     response[11UL] = committed;

  282.     (void)ModbusDataWriteWords(MODBUS_DATA_DEVICE_D,

  283.                                (uint32_t)PlsrModbusBaseAddress

  284.                                    + PLSR_MODBUS_CALL_RESPONSE_OFFSET,

  285.                                response,

  286.                                PLSR_MODBUS_CALL_RESPONSE_WORDS);

  287. }

  288. 

  289. static void PlsrModbusHandleCallRequest(void)

  290. {

  291.     uint16_t request[PLSR_MODBUS_CALL_REQUEST_WORDS];

  292.     PLSR_CALL call;

  293.     PLSR_PARSE_DETAIL detail;

  294.     PLSR_RESULT result;

  295.     uint32_t sequence;

  296.     uint32_t fingerprint;

  297.     uint16_t operation;

  298.     uint8_t axis = 0U;

  299. 

  300.     if (PlsrModbusReadWords(PLSR_MODBUS_CALL_REQUEST_OFFSET,

  301.                             request,

  302.                             PLSR_MODBUS_CALL_REQUEST_WORDS) == 0U)

  303.     {

  304.         return;

  305.     }

  306.     sequence = PlsrModbusGetU32(request, 0UL);

  307.     if ((sequence == 0UL) || (sequence == PlsrModbusLastCallRequestSequence))

  308.     {

  309.         return;

  310.     }

  311.     PlsrModbusLastCallRequestSequence = sequence;

  312.     operation = request[14UL];

  313.     (void)memset(&detail, 0, sizeof(detail));

  314.     result = PlsrModbusBuildCall(request, &call);

  315.     if (result == PLSR_RESULT_OK)

  316.     {

  317.         axis = call.dAxis;

  318.     }

  319. 

  320.     if ((result == PLSR_RESULT_OK) && (operation == PLSR_MODBUS_CALL_COMMIT))

  321.     {

  322.         result = PlsrValidateCall(&call, &detail);

  323.         if (result == PLSR_RESULT_OK)

  324.         {

  325.             result = PlsrModbusFingerprintCall(&call, &fingerprint);

  326.         }

  327.         if (result == PLSR_RESULT_OK)

  328.         {

  329.             PlsrModbusCommitted[axis].call = call;

  330.             PlsrModbusCommitted[axis].fingerprint = fingerprint;

  331.             PlsrModbusCommitted[axis].valid = 1U;

  332.         }

  333.         else

  334.         {

  335.             PlsrModbusCommitted[axis].valid = 0U;

  336.         }

  337.     }

  338.     else if ((result == PLSR_RESULT_OK)

  339.              && (operation == PLSR_MODBUS_CALL_START))

  340.     {

  341.         if (PlsrModbusCommitted[axis].valid == 0U)

  342.         {

  343.             result = PLSR_RESULT_INVALID_STATE;

  344.         }

  345.         else

  346.         {

  347.             result = PlsrModbusFingerprintCall(

  348.                 &PlsrModbusCommitted[axis].call,

  349.                 &fingerprint);

  350.             if ((result == PLSR_RESULT_OK)

  351.                 && (fingerprint != PlsrModbusCommitted[axis].fingerprint))

  352.             {

  353.                 result = PLSR_RESULT_BUSY;

  354.             }

  355.             if (result == PLSR_RESULT_OK)

  356.             {

  357.                 result = PlsrValidateCall(&PlsrModbusCommitted[axis].call,

  358.                                           &detail);

  359.             }

  360.             if (result == PLSR_RESULT_OK)

  361.             {

  362.                 PlsrModbusCommitted[axis].call.sequence = sequence;

  363.                 result = PlsrPostCall(&PlsrModbusCommitted[axis].call);

  364.             }

  365.         }

  366.     }

  367.     else if (result == PLSR_RESULT_OK)

  368.     {

  369.         result = PLSR_RESULT_INVALID_ARGUMENT;

  370.     }

  371. 

  372.     PlsrModbusPublishCallResponse(

  373.         sequence,

  374.         operation,

  375.         result,

  376.         &detail,

  377.         (axis < PLSR_AXIS_COUNT) ? PlsrModbusCommitted[axis].valid : 0U);

  378. }

  379. 

  380. static void PlsrModbusPublishCommandResponse(uint32_t sequence,

  381.                                              uint16_t opcode,

  382.                                              uint16_t axis,

  383.                                              PLSR_RESULT result)

  384. {

  385.     uint16_t response[PLSR_MODBUS_COMMAND_RESPONSE_WORDS] = {0U};

  386. 

  387.     PlsrModbusPutU32(response, 0UL, sequence);

  388.     response[2UL] = opcode;

  389.     response[3UL] = axis;

  390.     response[4UL] = (uint16_t)result;

  391.     (void)ModbusDataWriteWords(MODBUS_DATA_DEVICE_D,

  392.                                (uint32_t)PlsrModbusBaseAddress

  393.                                    + PLSR_MODBUS_COMMAND_RESPONSE_OFFSET,

  394.                                response,

  395.                                PLSR_MODBUS_COMMAND_RESPONSE_WORDS);

  396. }

  397. 

  398. static void PlsrModbusHandleCommandRequest(void)

  399. {

  400.     uint16_t request[PLSR_MODBUS_COMMAND_REQUEST_WORDS];

  401.     PLSR_COMMAND command;

  402.     PLSR_RESULT result;

  403.     uint32_t sequence;

  404. 

  405.     if (PlsrModbusReadWords(PLSR_MODBUS_COMMAND_REQUEST_OFFSET,

  406.                             request,

  407.                             PLSR_MODBUS_COMMAND_REQUEST_WORDS) == 0U)

  408.     {

  409.         return;

  410.     }

  411.     sequence = PlsrModbusGetU32(request, 0UL);

  412.     if ((sequence == 0UL)

  413.         || (sequence == PlsrModbusLastCommandRequestSequence))

  414.     {

  415.         return;

  416.     }

  417.     PlsrModbusLastCommandRequestSequence = sequence;

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

  419.     if ((request[2UL] > (uint16_t)PLSR_CMD_SELF_TEST)

  420.         || (request[2UL] == (uint16_t)PLSR_CMD_START)

  421.         || (request[3UL] >= PLSR_AXIS_COUNT))

  422.     {

  423.         result = PLSR_RESULT_INVALID_ARGUMENT;

  424.     }

  425.     else

  426.     {

  427.         command.sequence = sequence;

  428.         command.opcode = (PLSR_COMMAND_OPCODE)request[2UL];

  429.         command.axis = (uint8_t)request[3UL];

  430.         command.argument = (int64_t)PlsrModbusGetU64(request, 4UL);

  431.         result = PlsrPostCommand(&command);

  432.     }

  433.     PlsrModbusPublishCommandResponse(sequence,

  434.                                      request[2UL],

  435.                                      request[3UL],

  436.                                      result);

  437. }

  438. 

  439. static void PlsrModbusPublishAxisStatus(uint8_t axis)

  440. {

  441.     PLSR_STATUS status;

  442.     uint16_t *words = PlsrModbusStatusWords[axis];

  443.     uint32_t flags = 0UL;

  444.     uint32_t generation;

  445. 

  446.     if (PlsrGetStatus(axis, &status) != PLSR_RESULT_OK)

  447.     {

  448.         return;

  449.     }

  450.     generation = PlsrModbusStatusGeneration[axis] + 2UL;

  451.     if (generation == 0UL)

  452.     {

  453.         generation = 2UL;

  454.     }

  455.     PlsrModbusStatusGeneration[axis] = generation;

  456.     (void)memset(words, 0, sizeof(PlsrModbusStatusWords[axis]));

  457.     if (status.busy != 0U) flags |= (1UL << 0U);

  458.     if (status.pulseActive != 0U) flags |= (1UL << 1U);

  459.     if (status.done != 0U) flags |= (1UL << 2U);

  460.     if (status.wait != 0U) flags |= (1UL << 3U);

  461.     if (status.directionPositive != 0U) flags |= (1UL << 4U);

  462.     if (status.positionValid != 0U) flags |= (1UL << 5U);

  463.     if (status.jobValid != 0U) flags |= (1UL << 6U);

  464.     if (status.speedClamped != 0U) flags |= (1UL << 7U);

  465.     if (status.positionOverflow != 0U) flags |= (1UL << 8U);

  466.     if (status.positiveLimitActive != 0U) flags |= (1UL << 9U);

  467.     if (status.negativeLimitActive != 0U) flags |= (1UL << 10U);

  468.     if (status.emergencyLatched != 0U) flags |= (1UL << 11U);

  469.     if (status.backlashActive != 0U) flags |= (1UL << 12U);

  470. 

  471.     PlsrModbusPutU32(words, 0UL, generation);

  472.     words[2UL] = (uint16_t)status.state;

  473.     PlsrModbusPutU32(words, 3UL, flags);

  474.     words[5UL] = (uint16_t)status.outputMode;

  475.     words[6UL] = (uint16_t)status.error;

  476.     words[7UL] = (uint16_t)status.stopReason;

  477.     words[8UL] = (uint16_t)status.lastCommandResult;

  478.     words[9UL] = status.s2Set;

  479.     PlsrModbusPutU32(words, 10UL, status.lastCommandSequence);

  480.     PlsrModbusPutU32(words, 12UL, status.illegalTransitionCount);

  481.     PlsrModbusPutU32(words, 14UL, status.pendingEvents);

  482.     PlsrModbusPutU64(words, 16UL, (uint64_t)status.logicalPosition);

  483.     PlsrModbusPutU64(words, 20UL, (uint64_t)status.taskPulses);

  484.     PlsrModbusPutU64(words, 24UL, (uint64_t)status.totalPulses);

  485.     PlsrModbusPutU64(words, 28UL, status.physicalPulses);

  486.     words[32UL] = status.segmentCount;

  487.     words[33UL] = status.startSegment;

  488.     words[34UL] = status.currentSegment;

  489.     words[35UL] = status.directionPoint;

  490.     words[36UL] = status.highResourceMask;

  491.     PlsrModbusPutU32(words, 38UL, status.currentFrequencyHz);

  492.     PlsrModbusPutU32(words, 40UL, status.targetFrequencyHz);

  493.     PlsrModbusPutU32(words, 42UL, status.liveFrequencyRejectCount);

  494.     words[44UL] = (uint16_t)status.lastLiveFrequencyResult;

  495.     PlsrModbusPutU32(words, 46UL, generation);

  496.     (void)ModbusDataWriteWords(

  497.         MODBUS_DATA_DEVICE_D,

  498.         (uint32_t)PlsrModbusBaseAddress + PLSR_MODBUS_AXIS_STATUS_OFFSET

  499.             + (uint32_t)axis * PLSR_MODBUS_AXIS_STATUS_WORDS,

  500.         words,

  501.         PLSR_MODBUS_AXIS_STATUS_WORDS);

  502. }

  503. 

  504. PLSR_RESULT PlsrModbusControlInit(uint16_t baseAddress)

  505. {

  506.     uint16_t header[8] = {0U};

  507. 

  508.     if (ModbusDataValidateWords(MODBUS_DATA_DEVICE_D,

  509.                                 baseAddress,

  510.                                 PLSR_MODBUS_WINDOW_WORDS) == 0U)

  511.     {

  512.         return PLSR_RESULT_DATA_ACCESS;

  513.     }

  514.     PlsrModbusBaseAddress = baseAddress;

  515.     PlsrModbusEnabled = 0U;

  516.     PlsrModbusLastCallRequestSequence = 0UL;

  517.     PlsrModbusLastCommandRequestSequence = 0UL;

  518.     (void)memset(PlsrModbusCommitted, 0, sizeof(PlsrModbusCommitted));

  519.     (void)memset(PlsrModbusStatusGeneration,

  520.                  0,

  521.                  sizeof(PlsrModbusStatusGeneration));

  522.     if (ModbusDataWriteWords(MODBUS_DATA_DEVICE_D,

  523.                              baseAddress,

  524.                              PlsrModbusZeroWindow,

  525.                              PLSR_MODBUS_WINDOW_WORDS) == 0U)

  526.     {

  527.         return PLSR_RESULT_DATA_ACCESS;

  528.     }

  529.     header[0UL] = PLSR_MODBUS_MAGIC_LOW;

  530.     header[1UL] = PLSR_MODBUS_MAGIC_HIGH;

  531.     header[2UL] = PLSR_MODBUS_PROTOCOL_VERSION;

  532.     header[3UL] = (uint16_t)PLSR_MODBUS_WINDOW_WORDS;

  533.     header[4UL] = PLSR_MODBUS_CAPABILITIES;

  534.     if (ModbusDataWriteWords(MODBUS_DATA_DEVICE_D,

  535.                              baseAddress,

  536.                              header,

  537.                              8UL) == 0U)

  538.     {

  539.         return PLSR_RESULT_DATA_ACCESS;

  540.     }

  541.     PlsrModbusEnabled = 1U;

  542.     PlsrModbusControlPoll();

  543.     return PLSR_RESULT_OK;

  544. }

  545. 

  546. void PlsrModbusControlPoll(void)

  547. {

  548.     uint8_t axis;

  549. 

  550.     if (PlsrModbusEnabled == 0U)

  551.     {

  552.         return;

  553.     }

  554.     PlsrModbusHandleCallRequest();

  555.     PlsrModbusHandleCommandRequest();

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

  557.     {

  558.         PlsrModbusPublishAxisStatus(axis);

  559.     }

  560. }

  561. 

  562. uint8_t PlsrModbusControlIsEnabled(void)

  563. {

  564.     return PlsrModbusEnabled;

  565. }

  566. 

  567. uint16_t PlsrModbusControlGetBaseAddress(void)

  568. {

  569.     return PlsrModbusBaseAddress;

  570. }