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.
29 Комити
3 Гране
138 MiB
 
 
 
 
 
 
Дрво: 9296f55657
Гране Ознаке
${ item.name }
Create branch ${ searchTerm }
from '9296f55657'
${ noResults }
Modbus-rtu/PLSR/Src/plsr_core.c

1162 lines
35 KiB
Датотека Blame Историја 

  1. #include "plsr_core.h"

  2. #include "plc_device.h"

  3. #include "plsr_address_map.h"

  4. #include "plsr_resource.h"

  5. #include <string.h>

  6. 

  7. #ifndef PLSR_HOST_TEST

  8. #include "stm32f4xx.h"

  9. #include "ucos_ii.h"

  10. #endif

  11. 

  12. typedef struct

  13. {

  14.     PLSR_STATE state;

  15.     PLSR_OUTPUT_MODE outputMode;

  16.     PLSR_ERROR error;

  17.     PLSR_STOP_REASON stopReason;

  18.     PLSR_STATE pendingTerminal;

  19.     PLSR_RESOURCE_LEASE lease;

  20.     PLSR_JOB_SNAPSHOT job;

  21.     PLSR_PARSE_DETAIL parseDetail;

  22.     volatile uint32_t pendingEvents;

  23.     uint32_t lastCommandSequence;

  24.     PLSR_RESULT lastCommandResult;

  25.     uint32_t illegalTransitionCount;

  26.     int64_t logicalPosition;

  27.     int64_t totalPulses;

  28.     uint8_t hasLastCommand;

  29.     uint8_t done;

  30.     uint8_t directionPositive;

  31.     uint8_t immediateStopPending;

  32.     uint8_t positionValid;

  33.     uint8_t jobValid;

  34. } PLSR_AXIS;

  35. 

  36. typedef struct

  37. {

  38.     PLSR_COMMAND command;

  39.     PLSR_START_REQUEST start;

  40.     PLSR_CALL call;

  41.     uint32_t ticket;

  42.     uint8_t hasStart;

  43.     uint8_t hasCall;

  44.     uint8_t occupied;

  45. } PLSR_COMMAND_SLOT;

  46. 

  47. static PLSR_AXIS PlsrAxes[PLSR_AXIS_COUNT];

  48. static PLSR_COMMAND_SLOT PlsrCommandQueue[PLSR_COMMAND_QUEUE_DEPTH];

  49. static uint32_t PlsrNextTicket;

  50. static uint8_t PlsrInitialized;

  51. static PLSR_JOB_SNAPSHOT PlsrJobScratch;

  52. 

  53. static uint32_t PlsrCoreEnterCritical(void)

  54. {

  55. #ifdef PLSR_HOST_TEST

  56.     return 0UL;

  57. #else

  58.     uint32_t interruptState = __get_PRIMASK();

  59.     __disable_irq();

  60.     __DMB();

  61.     return interruptState;

  62. #endif

  63. }

  64. 

  65. static void PlsrCoreExitCritical(uint32_t interruptState)

  66. {

  67. #ifdef PLSR_HOST_TEST

  68.     (void)interruptState;

  69. #else

  70.     __DMB();

  71.     if (interruptState == 0UL)

  72.     {

  73.         __enable_irq();

  74.     }

  75. #endif

  76. }

  77. 

  78. static uint8_t PlsrStateIsBusy(PLSR_STATE state)

  79. {

  80.     return ((state == PLSR_STATE_ACCEL) || (state == PLSR_STATE_RUN)

  81.             || (state == PLSR_STATE_DECEL) || (state == PLSR_STATE_WAIT)

  82.             || (state == PLSR_STATE_PAUSED))

  83.                ? 1U

  84.                : 0U;

  85. }

  86. 

  87. static uint8_t PlsrStateIsPulseActive(PLSR_STATE state)

  88. {

  89.     return ((state == PLSR_STATE_ACCEL) || (state == PLSR_STATE_RUN)

  90.             || (state == PLSR_STATE_DECEL))

  91.                ? 1U

  92.                : 0U;

  93. }

  94. 

  95. static void PlsrPublishAxis(uint8_t axis)

  96. {

  97.     PLSR_AXIS *axisObject = &PlsrAxes[axis];

  98.     uint8_t compatibleRun;

  99. 

  100.     compatibleRun = (uint8_t)((PlsrStateIsPulseActive(axisObject->state) != 0U)

  101.                               || (axisObject->state == PLSR_STATE_WAIT));

  102.     (void)PlcDevicePublishSm(axis,

  103.                              compatibleRun,

  104.                              axisObject->directionPositive);

  105. }

  106. 

  107. static void PlsrSetStopReason(PLSR_AXIS *axis,

  108.                               PLSR_STOP_REASON stopReason)

  109. {

  110.     if (stopReason > axis->stopReason)

  111.     {

  112.         axis->stopReason = stopReason;

  113.     }

  114. }

  115. 

  116. static uint8_t PlsrTransitionIsAllowed(PLSR_STATE current,

  117.                                        PLSR_STATE target)

  118. {

  119.     if (current == target)

  120.     {

  121.         return 1U;

  122.     }

  123.     if (target == PLSR_STATE_ERROR)

  124.     {

  125.         return 1U;

  126.     }

  127. 

  128.     switch (current)

  129.     {

  130.         case PLSR_STATE_UNINITIALIZED:

  131.             return (target == PLSR_STATE_IDLE) ? 1U : 0U;

  132. 

  133.         case PLSR_STATE_IDLE:

  134.         case PLSR_STATE_COMPLETED:

  135.         case PLSR_STATE_STOPPED:

  136.             return ((target == PLSR_STATE_ACCEL)

  137.                     || (target == PLSR_STATE_WAIT)

  138.                     || (target == PLSR_STATE_COMPLETED))

  139.                        ? 1U

  140.                        : 0U;

  141. 

  142.         case PLSR_STATE_ACCEL:

  143.         case PLSR_STATE_RUN:

  144.             return ((target == PLSR_STATE_RUN)

  145.                     || (target == PLSR_STATE_DECEL)

  146.                     || (target == PLSR_STATE_WAIT)

  147.                     || (target == PLSR_STATE_COMPLETED)

  148.                     || (target == PLSR_STATE_STOPPED))

  149.                        ? 1U

  150.                        : 0U;

  151. 

  152.         case PLSR_STATE_DECEL:

  153.             return ((target == PLSR_STATE_RUN)

  154.                     || (target == PLSR_STATE_WAIT)

  155.                     || (target == PLSR_STATE_PAUSED)

  156.                     || (target == PLSR_STATE_COMPLETED)

  157.                     || (target == PLSR_STATE_STOPPED))

  158.                        ? 1U

  159.                        : 0U;

  160. 

  161.         case PLSR_STATE_WAIT:

  162.             return ((target == PLSR_STATE_ACCEL)

  163.                     || (target == PLSR_STATE_RUN)

  164.                     || (target == PLSR_STATE_PAUSED)

  165.                     || (target == PLSR_STATE_COMPLETED)

  166.                     || (target == PLSR_STATE_STOPPED))

  167.                        ? 1U

  168.                        : 0U;

  169. 

  170.         case PLSR_STATE_PAUSED:

  171.             return ((target == PLSR_STATE_ACCEL)

  172.                     || (target == PLSR_STATE_RUN)

  173.                     || (target == PLSR_STATE_STOPPED))

  174.                        ? 1U

  175.                        : 0U;

  176. 

  177.         case PLSR_STATE_ERROR:

  178.             return (target == PLSR_STATE_IDLE) ? 1U : 0U;

  179. 

  180.         default:

  181.             return 0U;

  182.     }

  183. }

  184. 

  185. PLSR_RESULT PlsrStateTransition(uint8_t axis,

  186.                                 PLSR_STATE target,

  187.                                 PLSR_TRANSITION_REASON reason)

  188. {

  189.     PLSR_AXIS *axisObject;

  190. 

  191.     (void)reason;

  192.     if (axis >= PLSR_AXIS_COUNT)

  193.     {

  194.         return PLSR_RESULT_INVALID_AXIS;

  195.     }

  196.     if ((uint32_t)target > (uint32_t)PLSR_STATE_ERROR)

  197.     {

  198.         return PLSR_RESULT_INVALID_ARGUMENT;

  199.     }

  200. 

  201.     axisObject = &PlsrAxes[axis];

  202.     if (PlsrTransitionIsAllowed(axisObject->state, target) == 0U)

  203.     {

  204.         axisObject->illegalTransitionCount++;

  205.         axisObject->error = PLSR_ERROR_ILLEGAL_TRANSITION;

  206.         axisObject->stopReason = PLSR_STOP_REASON_FAULT;

  207.         axisObject->done = 0U;

  208.         axisObject->state = PLSR_STATE_ERROR;

  209.         axisObject->pendingTerminal = PLSR_STATE_UNINITIALIZED;

  210.         axisObject->immediateStopPending = 0U;

  211.         PlsrResourceRelease(&axisObject->lease);

  212.         PlsrPublishAxis(axis);

  213.         return PLSR_RESULT_INVALID_STATE;

  214.     }

  215. 

  216.     axisObject->state = target;

  217.     if (target == PLSR_STATE_COMPLETED)

  218.     {

  219.         axisObject->done = 1U;

  220.     }

  221.     if ((target == PLSR_STATE_COMPLETED) || (target == PLSR_STATE_STOPPED)

  222.         || (target == PLSR_STATE_ERROR))

  223.     {

  224.         axisObject->pendingTerminal = PLSR_STATE_UNINITIALIZED;

  225.         axisObject->immediateStopPending = 0U;

  226.         PlsrResourceRelease(&axisObject->lease);

  227.     }

  228.     PlsrPublishAxis(axis);

  229.     return PLSR_RESULT_OK;

  230. }

  231. 

  232. static uint8_t PlsrCommandPriority(PLSR_COMMAND_OPCODE opcode)

  233. {

  234.     switch (opcode)

  235.     {

  236.         case PLSR_CMD_STOP_IMMEDIATE:

  237.             return 0U;

  238.         case PLSR_CMD_STOP_DECEL:

  239.             return 1U;

  240.         case PLSR_CMD_PAUSE:

  241.             return 2U;

  242.         case PLSR_CMD_RESUME:

  243.             return 3U;

  244.         default:

  245.             return 4U;

  246.     }

  247. }

  248. 

  249. static PLSR_RESULT PlsrQueueCommand(const PLSR_COMMAND *command,

  250.                                     const PLSR_START_REQUEST *start,

  251.                                     const PLSR_CALL *call)

  252. {

  253.     uint32_t interruptState;

  254.     uint8_t freeSlot = PLSR_COMMAND_QUEUE_DEPTH;

  255.     uint8_t index;

  256. 

  257.     interruptState = PlsrCoreEnterCritical();

  258.     if ((PlsrAxes[command->axis].hasLastCommand != 0U)

  259.         && (PlsrAxes[command->axis].lastCommandSequence == command->sequence))

  260.     {

  261.         PLSR_RESULT result = PlsrAxes[command->axis].lastCommandResult;

  262.         PlsrCoreExitCritical(interruptState);

  263.         return result;

  264.     }

  265. 

  266.     for (index = 0U; index < PLSR_COMMAND_QUEUE_DEPTH; index++)

  267.     {

  268.         if (PlsrCommandQueue[index].occupied != 0U)

  269.         {

  270.             if ((PlsrCommandQueue[index].command.axis == command->axis)

  271.                 && (PlsrCommandQueue[index].command.sequence

  272.                     == command->sequence))

  273.             {

  274.                 PlsrCoreExitCritical(interruptState);

  275.                 return PLSR_RESULT_QUEUED;

  276.             }

  277.         }

  278.         else if (freeSlot == PLSR_COMMAND_QUEUE_DEPTH)

  279.         {

  280.             freeSlot = index;

  281.         }

  282.     }

  283. 

  284.     if (freeSlot == PLSR_COMMAND_QUEUE_DEPTH)

  285.     {

  286.         PlsrCoreExitCritical(interruptState);

  287.         return PLSR_RESULT_QUEUE_FULL;

  288.     }

  289. 

  290.     PlsrCommandQueue[freeSlot].command = *command;

  291.     if (start != NULL)

  292.     {

  293.         PlsrCommandQueue[freeSlot].start = *start;

  294.         PlsrCommandQueue[freeSlot].hasStart = 1U;

  295.     }

  296.     else

  297.     {

  298.         (void)memset(&PlsrCommandQueue[freeSlot].start,

  299.                      0,

  300.                      sizeof(PlsrCommandQueue[freeSlot].start));

  301.         PlsrCommandQueue[freeSlot].hasStart = 0U;

  302.     }

  303.     if (call != NULL)

  304.     {

  305.         PlsrCommandQueue[freeSlot].call = *call;

  306.         PlsrCommandQueue[freeSlot].hasCall = 1U;

  307.     }

  308.     else

  309.     {

  310.         (void)memset(&PlsrCommandQueue[freeSlot].call,

  311.                      0,

  312.                      sizeof(PlsrCommandQueue[freeSlot].call));

  313.         PlsrCommandQueue[freeSlot].hasCall = 0U;

  314.     }

  315.     PlsrCommandQueue[freeSlot].ticket = PlsrNextTicket++;

  316.     PlsrCommandQueue[freeSlot].occupied = 1U;

  317.     PlsrCoreExitCritical(interruptState);

  318.     return PLSR_RESULT_QUEUED;

  319. }

  320. 

  321. static uint8_t PlsrPopHighestPriorityCommand(PLSR_COMMAND_SLOT *slot)

  322. {

  323.     uint32_t interruptState;

  324.     uint32_t selectedTicket = 0UL;

  325.     uint8_t selectedPriority = 0xFFU;

  326.     uint8_t selected = PLSR_COMMAND_QUEUE_DEPTH;

  327.     uint8_t index;

  328.     uint8_t priority;

  329. 

  330.     interruptState = PlsrCoreEnterCritical();

  331.     for (index = 0U; index < PLSR_COMMAND_QUEUE_DEPTH; index++)

  332.     {

  333.         if (PlsrCommandQueue[index].occupied == 0U)

  334.         {

  335.             continue;

  336.         }

  337.         priority = PlsrCommandPriority(PlsrCommandQueue[index].command.opcode);

  338.         if ((selected == PLSR_COMMAND_QUEUE_DEPTH)

  339.             || (priority < selectedPriority)

  340.             || ((priority == selectedPriority)

  341.                 && ((int32_t)(PlsrCommandQueue[index].ticket

  342.                               - selectedTicket)

  343.                     < 0)))

  344.         {

  345.             selected = index;

  346.             selectedPriority = priority;

  347.             selectedTicket = PlsrCommandQueue[index].ticket;

  348.         }

  349.     }

  350. 

  351.     if (selected == PLSR_COMMAND_QUEUE_DEPTH)

  352.     {

  353.         PlsrCoreExitCritical(interruptState);

  354.         return 0U;

  355.     }

  356. 

  357.     *slot = PlsrCommandQueue[selected];

  358.     PlsrCommandQueue[selected].occupied = 0U;

  359.     PlsrCoreExitCritical(interruptState);

  360.     return 1U;

  361. }

  362. 

  363. PLSR_RESULT PlsrPostStart(const PLSR_START_REQUEST *request)

  364. {

  365.     PLSR_COMMAND command;

  366. 

  367.     if (request == NULL)

  368.     {

  369.         return PLSR_RESULT_INVALID_ARGUMENT;

  370.     }

  371.     if (request->axis >= PLSR_AXIS_COUNT)

  372.     {

  373.         return PLSR_RESULT_INVALID_AXIS;

  374.     }

  375.     if (PlsrInitialized == 0U)

  376.     {

  377.         return PLSR_RESULT_INVALID_STATE;

  378.     }

  379. 

  380.     command.sequence = request->sequence;

  381.     command.axis = request->axis;

  382.     command.opcode = PLSR_CMD_START;

  383.     command.argument = 0;

  384.     return PlsrQueueCommand(&command, request, NULL);

  385. }

  386. 

  387. PLSR_RESULT PlsrPostCall(const PLSR_CALL *call)

  388. {

  389.     PLSR_COMMAND command;

  390. 

  391.     if (call == NULL)

  392.     {

  393.         return PLSR_RESULT_INVALID_ARGUMENT;

  394.     }

  395.     if (call->dAxis >= PLSR_AXIS_COUNT)

  396.     {

  397.         return PLSR_RESULT_INVALID_AXIS;

  398.     }

  399.     if (PlsrInitialized == 0U)

  400.     {

  401.         return PLSR_RESULT_INVALID_STATE;

  402.     }

  403.     command.sequence = call->sequence;

  404.     command.axis = call->dAxis;

  405.     command.opcode = PLSR_CMD_START;

  406.     command.argument = 0;

  407.     return PlsrQueueCommand(&command, NULL, call);

  408. }

  409. 

  410. PLSR_RESULT PlsrPostCommand(const PLSR_COMMAND *command)

  411. {

  412.     if (command == NULL)

  413.     {

  414.         return PLSR_RESULT_INVALID_ARGUMENT;

  415.     }

  416.     if (command->axis >= PLSR_AXIS_COUNT)

  417.     {

  418.         return PLSR_RESULT_INVALID_AXIS;

  419.     }

  420.     if (((uint32_t)command->opcode > (uint32_t)PLSR_CMD_SELF_TEST)

  421.         || (command->opcode == PLSR_CMD_START))

  422.     {

  423.         return PLSR_RESULT_INVALID_ARGUMENT;

  424.     }

  425.     if (PlsrInitialized == 0U)

  426.     {

  427.         return PLSR_RESULT_INVALID_STATE;

  428.     }

  429.     return PlsrQueueCommand(command, NULL, NULL);

  430. }

  431. 

  432. PLSR_RESULT PlsrPostEvent(uint8_t axis, uint32_t eventMask)

  433. {

  434.     uint32_t interruptState;

  435. 

  436.     if (axis >= PLSR_AXIS_COUNT)

  437.     {

  438.         return PLSR_RESULT_INVALID_AXIS;

  439.     }

  440.     if ((eventMask == 0UL) || ((eventMask & ~PLSR_EVENT_ALL_MASK) != 0UL))

  441.     {

  442.         return PLSR_RESULT_INVALID_ARGUMENT;

  443.     }

  444. 

  445.     interruptState = PlsrCoreEnterCritical();

  446.     PlsrAxes[axis].pendingEvents |= eventMask;

  447.     PlsrCoreExitCritical(interruptState);

  448.     return PLSR_RESULT_OK;

  449. }

  450. 

  451. static uint32_t PlsrTakeEvents(uint8_t axis, uint32_t mask)

  452. {

  453.     uint32_t interruptState;

  454.     uint32_t events;

  455. 

  456.     interruptState = PlsrCoreEnterCritical();

  457.     events = PlsrAxes[axis].pendingEvents & mask;

  458.     PlsrAxes[axis].pendingEvents &= ~events;

  459.     PlsrCoreExitCritical(interruptState);

  460.     return events;

  461. }

  462. 

  463. static uint8_t PlsrAnyAxisBusy(void)

  464. {

  465.     uint8_t axis;

  466. 

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

  468.     {

  469.         if (PlsrStateIsBusy(PlsrAxes[axis].state) != 0U)

  470.         {

  471.             return 1U;

  472.         }

  473.     }

  474.     return 0U;

  475. }

  476. 

  477. static PLSR_RESULT PlsrStartAxis(PLSR_AXIS *axisObject,

  478.                                  const PLSR_START_REQUEST *start)

  479. {

  480.     PLSR_RESOURCE_REQUEST resourceRequest;

  481.     PLSR_RESULT result;

  482. 

  483.     if ((axisObject->state != PLSR_STATE_IDLE)

  484.         && (axisObject->state != PLSR_STATE_COMPLETED)

  485.         && (axisObject->state != PLSR_STATE_STOPPED))

  486.     {

  487.         return PLSR_RESULT_INVALID_STATE;

  488.     }

  489. 

  490.     resourceRequest.ownerAxis = start->axis;

  491.     resourceRequest.outputMode = start->outputMode;

  492.     resourceRequest.dAxis = start->axis;

  493.     resourceRequest.directionPoint = start->directionPoint;

  494.     result = PlsrResourceReserve(&resourceRequest, &axisObject->lease);

  495.     if (result != PLSR_RESULT_OK)

  496.     {

  497.         axisObject->error = (result == PLSR_RESULT_RESOURCE_CONFLICT)

  498.                                 ? PLSR_ERROR_RESOURCE_CONFLICT

  499.                                 : PLSR_ERROR_INVALID_RESOURCE;

  500.         return result;

  501.     }

  502. 

  503.     axisObject->outputMode = start->outputMode;

  504.     axisObject->directionPositive = (start->directionPositive != 0U) ? 1U : 0U;

  505.     axisObject->error = PLSR_ERROR_NONE;

  506.     axisObject->stopReason = PLSR_STOP_REASON_NONE;

  507.     axisObject->pendingTerminal = PLSR_STATE_UNINITIALIZED;

  508.     axisObject->immediateStopPending = 0U;

  509.     axisObject->done = 0U;

  510.     axisObject->jobValid = 0U;

  511.     result = PlsrStateTransition(start->axis,

  512.                                  PLSR_STATE_ACCEL,

  513.                                  PLSR_TRANSITION_START);

  514.     if (result != PLSR_RESULT_OK)

  515.     {

  516.         PlsrResourceRelease(&axisObject->lease);

  517.     }

  518.     return result;

  519. }

  520. 

  521. static PLSR_RESULT PlsrStartCall(PLSR_AXIS *axisObject,

  522.                                  const PLSR_CALL *call)

  523. {

  524.     PLSR_RESOURCE_REQUEST resourceRequest;

  525.     PLSR_PARSE_CONTEXT parseContext;

  526.     PLSR_RESULT result;

  527. 

  528.     if ((axisObject->state != PLSR_STATE_IDLE)

  529.         && (axisObject->state != PLSR_STATE_COMPLETED)

  530.         && (axisObject->state != PLSR_STATE_STOPPED))

  531.     {

  532.         return PLSR_RESULT_INVALID_STATE;

  533.     }

  534. 

  535.     parseContext.logicalPosition = axisObject->logicalPosition;

  536.     parseContext.positionValid = axisObject->positionValid;

  537.     result = PlsrBuildJobSnapshot(call,

  538.                                   &parseContext,

  539.                                   &PlsrJobScratch,

  540.                                   &axisObject->parseDetail);

  541.     if (result != PLSR_RESULT_OK)

  542.     {

  543.         return result;

  544.     }

  545. 

  546.     resourceRequest.ownerAxis = call->dAxis;

  547.     resourceRequest.outputMode =

  548.         (PLSR_OUTPUT_MODE)PlsrJobScratch.outputMode;

  549.     resourceRequest.dAxis = call->dAxis;

  550.     resourceRequest.directionPoint = PlsrJobScratch.directionPoint;

  551.     result = PlsrResourceReserve(&resourceRequest, &axisObject->lease);

  552.     if (result != PLSR_RESULT_OK)

  553.     {

  554.         axisObject->error = (result == PLSR_RESULT_RESOURCE_CONFLICT)

  555.                                 ? PLSR_ERROR_RESOURCE_CONFLICT

  556.                                 : PLSR_ERROR_INVALID_RESOURCE;

  557.         axisObject->parseDetail.result = result;

  558.         axisObject->parseDetail.block = PLSR_PARSE_BLOCK_OUTPUT;

  559.         return result;

  560.     }

  561. 

  562.     axisObject->job = PlsrJobScratch;

  563.     axisObject->jobValid = 1U;

  564.     axisObject->outputMode = (PLSR_OUTPUT_MODE)axisObject->job.outputMode;

  565.     axisObject->directionPositive = axisObject->job.initialDirectionPositive;

  566.     axisObject->error = PLSR_ERROR_NONE;

  567.     axisObject->stopReason = PLSR_STOP_REASON_NONE;

  568.     axisObject->pendingTerminal = PLSR_STATE_UNINITIALIZED;

  569.     axisObject->immediateStopPending = 0U;

  570.     axisObject->done = 0U;

  571.     result = PlsrStateTransition(call->dAxis,

  572.                                  PLSR_STATE_ACCEL,

  573.                                  PLSR_TRANSITION_START);

  574.     if (result != PLSR_RESULT_OK)

  575.     {

  576.         axisObject->jobValid = 0U;

  577.         PlsrResourceRelease(&axisObject->lease);

  578.     }

  579.     return result;

  580. }

  581. 

  582. static PLSR_RESULT PlsrStopImmediate(uint8_t axis)

  583. {

  584.     PLSR_AXIS *axisObject = &PlsrAxes[axis];

  585. 

  586.     if ((axisObject->state == PLSR_STATE_IDLE)

  587.         || (axisObject->state == PLSR_STATE_COMPLETED)

  588.         || (axisObject->state == PLSR_STATE_STOPPED))

  589.     {

  590.         return PLSR_RESULT_OK;

  591.     }

  592.     if (axisObject->state == PLSR_STATE_ERROR)

  593.     {

  594.         return PLSR_RESULT_INVALID_STATE;

  595.     }

  596.     if (axisObject->immediateStopPending != 0U)

  597.     {

  598.         return PLSR_RESULT_OK;

  599.     }

  600. 

  601.     PlsrSetStopReason(axisObject, PLSR_STOP_REASON_STOP_IMMEDIATE);

  602.     axisObject->pendingTerminal = PLSR_STATE_STOPPED;

  603.     if ((axisObject->state == PLSR_STATE_WAIT)

  604.         || (axisObject->state == PLSR_STATE_PAUSED))

  605.     {

  606.         return PlsrStateTransition(axis,

  607.                                    PLSR_STATE_STOPPED,

  608.                                    PLSR_TRANSITION_STOP);

  609.     }

  610. 

  611.     axisObject->immediateStopPending = 1U;

  612.     return PLSR_RESULT_OK;

  613. }

  614. 

  615. static PLSR_RESULT PlsrStopDecel(uint8_t axis)

  616. {

  617.     PLSR_AXIS *axisObject = &PlsrAxes[axis];

  618. 

  619.     if ((axisObject->state == PLSR_STATE_IDLE)

  620.         || (axisObject->state == PLSR_STATE_COMPLETED)

  621.         || (axisObject->state == PLSR_STATE_STOPPED))

  622.     {

  623.         return PLSR_RESULT_OK;

  624.     }

  625.     if (axisObject->state == PLSR_STATE_ERROR)

  626.     {

  627.         return PLSR_RESULT_INVALID_STATE;

  628.     }

  629.     if (axisObject->stopReason >= PLSR_STOP_REASON_STOP_IMMEDIATE)

  630.     {

  631.         return PLSR_RESULT_OK;

  632.     }

  633. 

  634.     PlsrSetStopReason(axisObject, PLSR_STOP_REASON_STOP_DECEL);

  635.     axisObject->pendingTerminal = PLSR_STATE_STOPPED;

  636.     if ((axisObject->state == PLSR_STATE_WAIT)

  637.         || (axisObject->state == PLSR_STATE_PAUSED))

  638.     {

  639.         return PlsrStateTransition(axis,

  640.                                    PLSR_STATE_STOPPED,

  641.                                    PLSR_TRANSITION_STOP);

  642.     }

  643.     if (axisObject->state == PLSR_STATE_DECEL)

  644.     {

  645.         return PLSR_RESULT_OK;

  646.     }

  647.     return PlsrStateTransition(axis,

  648.                                PLSR_STATE_DECEL,

  649.                                PLSR_TRANSITION_DECEL_REQUEST);

  650. }

  651. 

  652. static PLSR_RESULT PlsrPause(uint8_t axis)

  653. {

  654.     PLSR_AXIS *axisObject = &PlsrAxes[axis];

  655. 

  656.     if (axisObject->state == PLSR_STATE_PAUSED)

  657.     {

  658.         return PLSR_RESULT_OK;

  659.     }

  660.     if (axisObject->stopReason >= PLSR_STOP_REASON_STOP_DECEL)

  661.     {

  662.         return PLSR_RESULT_BUSY;

  663.     }

  664.     if (axisObject->state == PLSR_STATE_WAIT)

  665.     {

  666.         PlsrSetStopReason(axisObject, PLSR_STOP_REASON_PAUSE);

  667.         return PlsrStateTransition(axis,

  668.                                    PLSR_STATE_PAUSED,

  669.                                    PLSR_TRANSITION_DECEL_COMPLETE);

  670.     }

  671.     if ((axisObject->state != PLSR_STATE_ACCEL)

  672.         && (axisObject->state != PLSR_STATE_RUN)

  673.         && (axisObject->state != PLSR_STATE_DECEL))

  674.     {

  675.         return PLSR_RESULT_INVALID_STATE;

  676.     }

  677. 

  678.     PlsrSetStopReason(axisObject, PLSR_STOP_REASON_PAUSE);

  679.     axisObject->pendingTerminal = PLSR_STATE_PAUSED;

  680.     if (axisObject->state == PLSR_STATE_DECEL)

  681.     {

  682.         return PLSR_RESULT_OK;

  683.     }

  684.     return PlsrStateTransition(axis,

  685.                                PLSR_STATE_DECEL,

  686.                                PLSR_TRANSITION_DECEL_REQUEST);

  687. }

  688. 

  689. static PLSR_RESULT PlsrExecuteCommand(const PLSR_COMMAND_SLOT *slot)

  690. {

  691.     PLSR_AXIS *axisObject = &PlsrAxes[slot->command.axis];

  692.     PLC_DEVICE_RESULT deviceResult;

  693.     PLSR_RESULT result;

  694. 

  695.     switch (slot->command.opcode)

  696.     {

  697.         case PLSR_CMD_START:

  698.             if (slot->hasCall != 0U)

  699.             {

  700.                 result = PlsrStartCall(axisObject, &slot->call);

  701.             }

  702.             else

  703.             {

  704.                 result = (slot->hasStart != 0U)

  705.                              ? PlsrStartAxis(axisObject, &slot->start)

  706.                              : PLSR_RESULT_INVALID_ARGUMENT;

  707.             }

  708.             break;

  709. 

  710.         case PLSR_CMD_STOP_DECEL:

  711.             result = PlsrStopDecel(slot->command.axis);

  712.             break;

  713. 

  714.         case PLSR_CMD_STOP_IMMEDIATE:

  715.             result = PlsrStopImmediate(slot->command.axis);

  716.             break;

  717. 

  718.         case PLSR_CMD_PAUSE:

  719.             result = PlsrPause(slot->command.axis);

  720.             break;

  721. 

  722.         case PLSR_CMD_RESUME:

  723.             if (axisObject->state != PLSR_STATE_PAUSED)

  724.             {

  725.                 result = PLSR_RESULT_INVALID_STATE;

  726.             }

  727.             else

  728.             {

  729.                 axisObject->stopReason = PLSR_STOP_REASON_NONE;

  730.                 axisObject->pendingTerminal = PLSR_STATE_UNINITIALIZED;

  731.                 result = PlsrStateTransition(slot->command.axis,

  732.                                              PLSR_STATE_ACCEL,

  733.                                              PLSR_TRANSITION_WAIT_COMPLETE);

  734.             }

  735.             break;

  736. 

  737.         case PLSR_CMD_SET_POSITION:

  738.             if (PlsrStateIsBusy(axisObject->state) != 0U)

  739.             {

  740.                 result = PLSR_RESULT_BUSY;

  741.             }

  742.             else

  743.             {

  744.                 axisObject->logicalPosition = slot->command.argument;

  745.                 axisObject->positionValid = 1U;

  746.                 (void)PlcDevicePublishHsdPair(

  747.                     (uint16_t)(slot->command.axis

  748.                                * PLSR_HSD_RUNTIME_AXIS_COUNT),

  749.                     axisObject->logicalPosition);

  750.                 result = PLSR_RESULT_OK;

  751.             }

  752.             break;

  753. 

  754.         case PLSR_CMD_CLEAR_POSITION:

  755.             if (PlsrStateIsBusy(axisObject->state) != 0U)

  756.             {

  757.                 result = PLSR_RESULT_BUSY;

  758.             }

  759.             else

  760.             {

  761.                 axisObject->logicalPosition = 0;

  762.                 axisObject->positionValid = 1U;

  763.                 (void)PlcDevicePublishHsdPair(

  764.                     (uint16_t)(slot->command.axis

  765.                                * PLSR_HSD_RUNTIME_AXIS_COUNT),

  766.                     0);

  767.                 result = PLSR_RESULT_OK;

  768.             }

  769.             break;

  770. 

  771.         case PLSR_CMD_CLEAR_TOTAL:

  772.             if (PlsrStateIsBusy(axisObject->state) != 0U)

  773.             {

  774.                 result = PLSR_RESULT_BUSY;

  775.             }

  776.             else

  777.             {

  778.                 axisObject->totalPulses = 0;

  779.                 result = PLSR_RESULT_OK;

  780.             }

  781.             break;

  782. 

  783.         case PLSR_CMD_SAVE_CONFIG:

  784.             if (PlsrAnyAxisBusy() != 0U)

  785.             {

  786.                 result = PLSR_RESULT_BUSY;

  787.             }

  788.             else

  789.             {

  790.                 deviceResult = PlcDeviceSaveSfd();

  791.                 result = (deviceResult == PLC_DEVICE_OK)

  792.                              ? PLSR_RESULT_OK

  793.                              : PLSR_RESULT_PERSISTENCE_ERROR;

  794.             }

  795.             break;

  796. 

  797.         case PLSR_CMD_LOAD_CONFIG:

  798.             if (PlsrAnyAxisBusy() != 0U)

  799.             {

  800.                 result = PLSR_RESULT_BUSY;

  801.             }

  802.             else

  803.             {

  804.                 deviceResult = PlcDeviceLoadSfd();

  805.                 result = (deviceResult == PLC_DEVICE_OK)

  806.                              ? PLSR_RESULT_OK

  807.                              : PLSR_RESULT_PERSISTENCE_ERROR;

  808.             }

  809.             break;

  810. 

  811.         case PLSR_CMD_RESET_ERROR:

  812.             if (axisObject->state != PLSR_STATE_ERROR)

  813.             {

  814.                 result = PLSR_RESULT_INVALID_STATE;

  815.             }

  816.             else

  817.             {

  818.                 axisObject->error = PLSR_ERROR_NONE;

  819.                 axisObject->stopReason = PLSR_STOP_REASON_NONE;

  820.                 axisObject->done = 0U;

  821.                 result = PlsrStateTransition(slot->command.axis,

  822.                                              PLSR_STATE_IDLE,

  823.                                              PLSR_TRANSITION_RESET_ERROR);

  824.             }

  825.             break;

  826. 

  827.         case PLSR_CMD_SELF_TEST:

  828.             result = ((PlsrAnyAxisBusy() == 0U)

  829.                       && (PlsrResourceCheckInvariant() != 0U))

  830.                          ? PLSR_RESULT_OK

  831.                          : PLSR_RESULT_BUSY;

  832.             break;

  833. 

  834.         default:

  835.             result = PLSR_RESULT_INVALID_ARGUMENT;

  836.             break;

  837.     }

  838. 

  839.     axisObject->lastCommandSequence = slot->command.sequence;

  840.     axisObject->lastCommandResult = result;

  841.     axisObject->hasLastCommand = 1U;

  842.     PlsrPublishAxis(slot->command.axis);

  843.     return result;

  844. }

  845. 

  846. static void PlsrProcessCriticalEvents(uint8_t axis, uint32_t events)

  847. {

  848.     PLSR_AXIS *axisObject = &PlsrAxes[axis];

  849. 

  850.     if ((events & PLSR_EVENT_SOFTWARE_EMERGENCY) != 0UL)

  851.     {

  852.         if (PlsrStateIsBusy(axisObject->state) != 0U)

  853.         {

  854.             PlsrSetStopReason(axisObject,

  855.                               PLSR_STOP_REASON_SOFTWARE_EMERGENCY);

  856.             axisObject->done = 0U;

  857.             (void)PlsrStateTransition(axis,

  858.                                       PLSR_STATE_STOPPED,

  859.                                       PLSR_TRANSITION_STOP);

  860.         }

  861.         return;

  862.     }

  863. 

  864.     if ((events & PLSR_EVENT_LIMIT_POSITIVE) != 0UL)

  865.     {

  866.         if ((axisObject->directionPositive != 0U)

  867.             && (PlsrStateIsBusy(axisObject->state) != 0U))

  868.         {

  869.             axisObject->error = PLSR_ERROR_LIMIT_POSITIVE;

  870.             PlsrSetStopReason(axisObject,

  871.                               PLSR_STOP_REASON_LIMIT_POSITIVE);

  872.             axisObject->pendingTerminal = PLSR_STATE_STOPPED;

  873.             if ((axisObject->state == PLSR_STATE_WAIT)

  874.                 || (axisObject->state == PLSR_STATE_PAUSED))

  875.             {

  876.                 (void)PlsrStateTransition(axis,

  877.                                           PLSR_STATE_STOPPED,

  878.                                           PLSR_TRANSITION_STOP);

  879.             }

  880.             else if (axisObject->state != PLSR_STATE_DECEL)

  881.             {

  882.                 (void)PlsrStateTransition(axis,

  883.                                           PLSR_STATE_DECEL,

  884.                                           PLSR_TRANSITION_DECEL_REQUEST);

  885.             }

  886.         }

  887.         return;

  888.     }

  889. 

  890.     if ((events & PLSR_EVENT_LIMIT_NEGATIVE) != 0UL)

  891.     {

  892.         if ((axisObject->directionPositive == 0U)

  893.             && (PlsrStateIsBusy(axisObject->state) != 0U))

  894.         {

  895.             axisObject->error = PLSR_ERROR_LIMIT_NEGATIVE;

  896.             PlsrSetStopReason(axisObject,

  897.                               PLSR_STOP_REASON_LIMIT_NEGATIVE);

  898.             axisObject->pendingTerminal = PLSR_STATE_STOPPED;

  899.             if ((axisObject->state == PLSR_STATE_WAIT)

  900.                 || (axisObject->state == PLSR_STATE_PAUSED))

  901.             {

  902.                 (void)PlsrStateTransition(axis,

  903.                                           PLSR_STATE_STOPPED,

  904.                                           PLSR_TRANSITION_STOP);

  905.             }

  906.             else if (axisObject->state != PLSR_STATE_DECEL)

  907.             {

  908.                 (void)PlsrStateTransition(axis,

  909.                                           PLSR_STATE_DECEL,

  910.                                           PLSR_TRANSITION_DECEL_REQUEST);

  911.             }

  912.         }

  913.         return;

  914.     }

  915. 

  916.     if ((events & (PLSR_EVENT_TIMER_FAULT | PLSR_EVENT_COUNTER_FAULT)) != 0UL)

  917.     {

  918.         axisObject->error = ((events & PLSR_EVENT_TIMER_FAULT) != 0UL)

  919.                                 ? PLSR_ERROR_TIMER_FAULT

  920.                                 : PLSR_ERROR_COUNTER_FAULT;

  921.         PlsrSetStopReason(axisObject, PLSR_STOP_REASON_FAULT);

  922.         axisObject->done = 0U;

  923.         (void)PlsrStateTransition(axis,

  924.                                   PLSR_STATE_ERROR,

  925.                                   PLSR_TRANSITION_FAULT);

  926.     }

  927. }

  928. 

  929. static void PlsrProcessNormalEvents(uint8_t axis, uint32_t events)

  930. {

  931.     PLSR_AXIS *axisObject = &PlsrAxes[axis];

  932. 

  933.     if (((events & PLSR_EVENT_STOP_IMMEDIATE_DONE) != 0UL)

  934.         && (axisObject->immediateStopPending != 0U))

  935.     {

  936.         (void)PlsrStateTransition(axis,

  937.                                   PLSR_STATE_STOPPED,

  938.                                   PLSR_TRANSITION_STOP);

  939.         return;

  940.     }

  941. 

  942.     if (((events & PLSR_EVENT_ACCEL_COMPLETE) != 0UL)

  943.         && (axisObject->state == PLSR_STATE_ACCEL)

  944.         && (axisObject->immediateStopPending == 0U))

  945.     {

  946.         (void)PlsrStateTransition(axis,

  947.                                   PLSR_STATE_RUN,

  948.                                   PLSR_TRANSITION_ACCEL_COMPLETE);

  949.     }

  950. 

  951.     if (((events & PLSR_EVENT_DECEL_COMPLETE) != 0UL)

  952.         && (axisObject->state == PLSR_STATE_DECEL))

  953.     {

  954.         if (axisObject->pendingTerminal == PLSR_STATE_PAUSED)

  955.         {

  956.             (void)PlsrStateTransition(axis,

  957.                                       PLSR_STATE_PAUSED,

  958.                                       PLSR_TRANSITION_DECEL_COMPLETE);

  959.         }

  960.         else if (axisObject->pendingTerminal == PLSR_STATE_STOPPED)

  961.         {

  962.             (void)PlsrStateTransition(axis,

  963.                                       PLSR_STATE_STOPPED,

  964.                                       PLSR_TRANSITION_DECEL_COMPLETE);

  965.         }

  966.         else

  967.         {

  968.             (void)PlsrStateTransition(axis,

  969.                                       PLSR_STATE_RUN,

  970.                                       PLSR_TRANSITION_DECEL_COMPLETE);

  971.         }

  972.     }

  973. 

  974.     if (((events & PLSR_EVENT_WAIT_BEGIN) != 0UL)

  975.         && ((axisObject->state == PLSR_STATE_ACCEL)

  976.             || (axisObject->state == PLSR_STATE_RUN)))

  977.     {

  978.         (void)PlsrStateTransition(axis,

  979.                                   PLSR_STATE_WAIT,

  980.                                   PLSR_TRANSITION_WAIT_BEGIN);

  981.     }

  982. 

  983.     if (((events & PLSR_EVENT_WAIT_COMPLETE) != 0UL)

  984.         && (axisObject->state == PLSR_STATE_WAIT))

  985.     {

  986.         (void)PlsrStateTransition(axis,

  987.                                   PLSR_STATE_ACCEL,

  988.                                   PLSR_TRANSITION_WAIT_COMPLETE);

  989.     }

  990. 

  991.     if (((events & PLSR_EVENT_JOB_COMPLETE) != 0UL)

  992.         && (PlsrStateIsBusy(axisObject->state) != 0U)

  993.         && (axisObject->pendingTerminal == PLSR_STATE_UNINITIALIZED)

  994.         && (axisObject->immediateStopPending == 0U))

  995.     {

  996.         axisObject->stopReason = PLSR_STOP_REASON_NORMAL_COMPLETE;

  997.         (void)PlsrStateTransition(axis,

  998.                                   PLSR_STATE_COMPLETED,

  999.                                   PLSR_TRANSITION_JOB_COMPLETE);

  1000.     }

  1001. }

  1002. 

  1003. PLSR_RESULT PlsrInit(void)

  1004. {

  1005.     int64_t restoredPosition;

  1006.     uint8_t axis;

  1007. 

  1008.     (void)memset(PlsrAxes, 0, sizeof(PlsrAxes));

  1009.     (void)memset(PlsrCommandQueue, 0, sizeof(PlsrCommandQueue));

  1010.     PlsrNextTicket = 0UL;

  1011.     PlsrResourceInit();

  1012.     PlsrInitialized = 1U;

  1013. 

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

  1015.     {

  1016.         PlsrAxes[axis].state = PLSR_STATE_UNINITIALIZED;

  1017.         PlsrAxes[axis].pendingTerminal = PLSR_STATE_UNINITIALIZED;

  1018.         PlsrAxes[axis].lease.directionPoint = PLSR_DIRECTION_POINT_NONE;

  1019.         if ((PlcDeviceGetLastHsdLoadResult() == PLSR_PERSISTENCE_OK)

  1020.             && (PlcDeviceReadHsdPair(

  1021.                     (uint16_t)(axis * PLSR_HSD_RUNTIME_AXIS_COUNT),

  1022.                     &restoredPosition)

  1023.                 == PLC_DEVICE_OK))

  1024.         {

  1025.             PlsrAxes[axis].logicalPosition = restoredPosition;

  1026.             PlsrAxes[axis].positionValid = 1U;

  1027.         }

  1028.         if (PlsrStateTransition(axis,

  1029.                                 PLSR_STATE_IDLE,

  1030.                                 PLSR_TRANSITION_INITIALIZED)

  1031.             != PLSR_RESULT_OK)

  1032.         {

  1033.             return PLSR_RESULT_INTERNAL_ERROR;

  1034.         }

  1035.     }

  1036.     return PLSR_RESULT_OK;

  1037. }

  1038. 

  1039. void PlsrProcess(void)

  1040. {

  1041.     PLSR_COMMAND_SLOT slot;

  1042.     uint32_t events;

  1043.     uint8_t processedCommands = 0U;

  1044.     uint8_t axis;

  1045. 

  1046.     if (PlsrInitialized == 0U)

  1047.     {

  1048.         return;

  1049.     }

  1050. 

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

  1052.     {

  1053.         events = PlsrTakeEvents(axis, PLSR_EVENT_CRITICAL_MASK);

  1054.         if (events != 0UL)

  1055.         {

  1056.             PlsrProcessCriticalEvents(axis, events);

  1057.         }

  1058.     }

  1059. 

  1060.     while ((processedCommands < PLSR_COMMAND_QUEUE_DEPTH)

  1061.            && (PlsrPopHighestPriorityCommand(&slot) != 0U))

  1062.     {

  1063.         (void)PlsrExecuteCommand(&slot);

  1064.         processedCommands++;

  1065.     }

  1066. 

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

  1068.     {

  1069.         events = PlsrTakeEvents(axis,

  1070.                                 PLSR_EVENT_ALL_MASK

  1071.                                     & ~PLSR_EVENT_CRITICAL_MASK);

  1072.         if (events != 0UL)

  1073.         {

  1074.             PlsrProcessNormalEvents(axis, events);

  1075.         }

  1076.     }

  1077. }

  1078. 

  1079. void PlsrTask(void *argument)

  1080. {

  1081.     (void)argument;

  1082. #ifdef PLSR_HOST_TEST

  1083.     PlsrProcess();

  1084. #else

  1085.     while (1)

  1086.     {

  1087.         PlsrProcess();

  1088.         OSTimeDly(1U);

  1089.     }

  1090. #endif

  1091. }

  1092. 

  1093. PLSR_RESULT PlsrGetStatus(uint8_t axis, PLSR_STATUS *status)

  1094. {

  1095.     PLSR_AXIS *axisObject;

  1096.     uint32_t interruptState;

  1097. 

  1098.     if (axis >= PLSR_AXIS_COUNT)

  1099.     {

  1100.         return PLSR_RESULT_INVALID_AXIS;

  1101.     }

  1102.     if (status == NULL)

  1103.     {

  1104.         return PLSR_RESULT_INVALID_ARGUMENT;

  1105.     }

  1106. 

  1107.     interruptState = PlsrCoreEnterCritical();

  1108.     axisObject = &PlsrAxes[axis];

  1109.     status->state = axisObject->state;

  1110.     status->outputMode = axisObject->outputMode;

  1111.     status->error = axisObject->error;

  1112.     status->stopReason = axisObject->stopReason;

  1113.     status->lastCommandResult = axisObject->lastCommandResult;

  1114.     status->lastCommandSequence = axisObject->lastCommandSequence;

  1115.     status->illegalTransitionCount = axisObject->illegalTransitionCount;

  1116.     status->pendingEvents = axisObject->pendingEvents;

  1117.     status->logicalPosition = axisObject->logicalPosition;

  1118.     status->totalPulses = axisObject->totalPulses;

  1119.     status->busy = PlsrStateIsBusy(axisObject->state);

  1120.     status->pulseActive = PlsrStateIsPulseActive(axisObject->state);

  1121.     status->done = axisObject->done;

  1122.     status->wait = (axisObject->state == PLSR_STATE_WAIT) ? 1U : 0U;

  1123.     status->directionPositive = axisObject->directionPositive;

  1124.     status->highResourceMask = axisObject->lease.highMask;

  1125.     status->directionPoint = (axisObject->lease.valid != 0U)

  1126.                                  ? axisObject->lease.directionPoint

  1127.                                  : PLSR_DIRECTION_POINT_NONE;

  1128.     status->positionValid = axisObject->positionValid;

  1129.     status->jobValid = axisObject->jobValid;

  1130.     status->s2Set = (axisObject->jobValid != 0U) ? axisObject->job.s2Set : 0U;

  1131.     status->speedClamped = (axisObject->jobValid != 0U)

  1132.                                ? axisObject->job.speedClamped

  1133.                                : 0U;

  1134.     status->segmentCount = (axisObject->jobValid != 0U)

  1135.                                ? axisObject->job.segmentCount

  1136.                                : 0U;

  1137.     status->startSegment = (axisObject->jobValid != 0U)

  1138.                                ? axisObject->job.startSegment

  1139.                                : 0U;

  1140.     PlsrCoreExitCritical(interruptState);

  1141.     return PLSR_RESULT_OK;

  1142. }

  1143. 

  1144. PLSR_RESULT PlsrGetLastParseDetail(uint8_t axis,

  1145.                                    PLSR_PARSE_DETAIL *detail)

  1146. {

  1147.     uint32_t interruptState;

  1148. 

  1149.     if (axis >= PLSR_AXIS_COUNT)

  1150.     {

  1151.         return PLSR_RESULT_INVALID_AXIS;

  1152.     }

  1153.     if (detail == NULL)

  1154.     {

  1155.         return PLSR_RESULT_INVALID_ARGUMENT;

  1156.     }

  1157.     interruptState = PlsrCoreEnterCritical();

  1158.     *detail = PlsrAxes[axis].parseDetail;

  1159.     PlsrCoreExitCritical(interruptState);

  1160.     return PLSR_RESULT_OK;

  1161. }