yuwenhao
/
Modbus-rtu
1
0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki 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.
31 Commits
3 Branches
138 MiB
 
 
 
 
 
 
Tree: ec430e357c
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'ec430e357c'
${ noResults }
Modbus-rtu/PLSR/Src/plsr_core.c

1329 lines
41 KiB
Raw Blame History 

  1. #include "plsr_core.h"

  2. #include "plc_device.h"

  3. #include "plsr_address_map.h"

  4. #include "plsr_path.h"

  5. #include "plsr_resource.h"

  6. #include <string.h>

  7. 

  8. #ifndef PLSR_HOST_TEST

  9. #include "stm32f4xx.h"

  10. #include "ucos_ii.h"

  11. #endif

  12. 

  13. typedef struct

  14. {

  15.     PLSR_STATE state;

  16.     PLSR_OUTPUT_MODE outputMode;

  17.     PLSR_ERROR error;

  18.     PLSR_STOP_REASON stopReason;

  19.     PLSR_STATE pendingTerminal;

  20.     PLSR_RESOURCE_LEASE lease;

  21.     PLSR_JOB_SNAPSHOT job;

  22.     PLSR_PARSE_DETAIL parseDetail;

  23.     volatile uint32_t pendingEvents;

  24.     uint32_t lastCommandSequence;

  25.     PLSR_RESULT lastCommandResult;

  26.     uint32_t illegalTransitionCount;

  27.     int64_t logicalPosition;

  28.     int64_t totalPulses;

  29.     PLSR_PATH_CONTEXT path;

  30.     uint8_t hasLastCommand;

  31.     uint8_t done;

  32.     uint8_t directionPositive;

  33.     uint8_t immediateStopPending;

  34.     uint8_t positionValid;

  35.     uint8_t jobValid;

  36.     uint8_t positionOverflow;

  37. } PLSR_AXIS;

  38. 

  39. typedef struct

  40. {

  41.     PLSR_COMMAND command;

  42.     PLSR_START_REQUEST start;

  43.     PLSR_CALL call;

  44.     uint32_t ticket;

  45.     uint8_t hasStart;

  46.     uint8_t hasCall;

  47.     uint8_t occupied;

  48. } PLSR_COMMAND_SLOT;

  49. 

  50. static PLSR_AXIS PlsrAxes[PLSR_AXIS_COUNT];

  51. static PLSR_COMMAND_SLOT PlsrCommandQueue[PLSR_COMMAND_QUEUE_DEPTH];

  52. static uint32_t PlsrNextTicket;

  53. static uint8_t PlsrInitialized;

  54. static PLSR_JOB_SNAPSHOT PlsrJobScratch;

  55. 

  56. static uint32_t PlsrCoreEnterCritical(void)

  57. {

  58. #ifdef PLSR_HOST_TEST

  59.     return 0UL;

  60. #else

  61.     uint32_t interruptState = __get_PRIMASK();

  62.     __disable_irq();

  63.     __DMB();

  64.     return interruptState;

  65. #endif

  66. }

  67. 

  68. static void PlsrCoreExitCritical(uint32_t interruptState)

  69. {

  70. #ifdef PLSR_HOST_TEST

  71.     (void)interruptState;

  72. #else

  73.     __DMB();

  74.     if (interruptState == 0UL)

  75.     {

  76.         __enable_irq();

  77.     }

  78. #endif

  79. }

  80. 

  81. static uint8_t PlsrStateIsBusy(PLSR_STATE state)

  82. {

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

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

  85.             || (state == PLSR_STATE_PAUSED))

  86.                ? 1U

  87.                : 0U;

  88. }

  89. 

  90. static uint8_t PlsrStateIsPulseActive(PLSR_STATE state)

  91. {

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

  93.             || (state == PLSR_STATE_DECEL))

  94.                ? 1U

  95.                : 0U;

  96. }

  97. 

  98. static void PlsrPublishAxis(uint8_t axis)

  99. {

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

  101.     uint8_t compatibleRun;

  102. 

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

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

  105.     (void)PlcDevicePublishSm(axis,

  106.                              compatibleRun,

  107.                              axisObject->directionPositive);

  108. }

  109. 

  110. static void PlsrSetStopReason(PLSR_AXIS *axis,

  111.                               PLSR_STOP_REASON stopReason)

  112. {

  113.     if (stopReason > axis->stopReason)

  114.     {

  115.         axis->stopReason = stopReason;

  116.     }

  117. }

  118. 

  119. /* 将 64 位逻辑位置发布为 HSD 的 32 位兼容值：

  120.  * 超出 INT32 范围时回绕（与信捷 32 位寄存器一致）并置溢出诊断标志。 */

  121. static void PlsrPublishPosition(uint8_t axis, PLSR_AXIS *axisObject)

  122. {

  123.     int32_t compatValue;

  124. 

  125.     if ((axisObject->logicalPosition > INT32_MAX)

  126.         || (axisObject->logicalPosition < INT32_MIN))

  127.     {

  128.         axisObject->positionOverflow = 1U;

  129.     }

  130.     compatValue = (int32_t)(uint32_t)axisObject->logicalPosition;

  131.     (void)PlcDevicePublishHsdDword(

  132.         (uint16_t)((uint16_t)axis * PLSR_HSD_RUNTIME_AXIS_COUNT),

  133.         compatValue);

  134. }

  135. 

  136. static uint8_t PlsrTransitionIsAllowed(PLSR_STATE current,

  137.                                        PLSR_STATE target)

  138. {

  139.     if (current == target)

  140.     {

  141.         return 1U;

  142.     }

  143.     if (target == PLSR_STATE_ERROR)

  144.     {

  145.         return 1U;

  146.     }

  147. 

  148.     switch (current)

  149.     {

  150.         case PLSR_STATE_UNINITIALIZED:

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

  152. 

  153.         case PLSR_STATE_IDLE:

  154.         case PLSR_STATE_COMPLETED:

  155.         case PLSR_STATE_STOPPED:

  156.             return ((target == PLSR_STATE_ACCEL)

  157.                     || (target == PLSR_STATE_WAIT)

  158.                     || (target == PLSR_STATE_COMPLETED))

  159.                        ? 1U

  160.                        : 0U;

  161. 

  162.         case PLSR_STATE_ACCEL:

  163.         case PLSR_STATE_RUN:

  164.             return ((target == PLSR_STATE_ACCEL)

  165.                     || (target == PLSR_STATE_RUN)

  166.                     || (target == PLSR_STATE_DECEL)

  167.                     || (target == PLSR_STATE_WAIT)

  168.                     || (target == PLSR_STATE_COMPLETED)

  169.                     || (target == PLSR_STATE_STOPPED))

  170.                        ? 1U

  171.                        : 0U;

  172. 

  173.         case PLSR_STATE_DECEL:

  174.             return ((target == PLSR_STATE_ACCEL)

  175.                     || (target == PLSR_STATE_RUN)

  176.                     || (target == PLSR_STATE_WAIT)

  177.                     || (target == PLSR_STATE_PAUSED)

  178.                     || (target == PLSR_STATE_COMPLETED)

  179.                     || (target == PLSR_STATE_STOPPED))

  180.                        ? 1U

  181.                        : 0U;

  182. 

  183.         case PLSR_STATE_WAIT:

  184.             return ((target == PLSR_STATE_ACCEL)

  185.                     || (target == PLSR_STATE_RUN)

  186.                     || (target == PLSR_STATE_PAUSED)

  187.                     || (target == PLSR_STATE_COMPLETED)

  188.                     || (target == PLSR_STATE_STOPPED))

  189.                        ? 1U

  190.                        : 0U;

  191. 

  192.         case PLSR_STATE_PAUSED:

  193.             return ((target == PLSR_STATE_ACCEL)

  194.                     || (target == PLSR_STATE_RUN)

  195.                     || (target == PLSR_STATE_STOPPED))

  196.                        ? 1U

  197.                        : 0U;

  198. 

  199.         case PLSR_STATE_ERROR:

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

  201. 

  202.         default:

  203.             return 0U;

  204.     }

  205. }

  206. 

  207. PLSR_RESULT PlsrStateTransition(uint8_t axis,

  208.                                 PLSR_STATE target,

  209.                                 PLSR_TRANSITION_REASON reason)

  210. {

  211.     PLSR_AXIS *axisObject;

  212. 

  213.     (void)reason;

  214.     if (axis >= PLSR_AXIS_COUNT)

  215.     {

  216.         return PLSR_RESULT_INVALID_AXIS;

  217.     }

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

  219.     {

  220.         return PLSR_RESULT_INVALID_ARGUMENT;

  221.     }

  222. 

  223.     axisObject = &PlsrAxes[axis];

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

  225.     {

  226.         axisObject->illegalTransitionCount++;

  227.         axisObject->error = PLSR_ERROR_ILLEGAL_TRANSITION;

  228.         axisObject->stopReason = PLSR_STOP_REASON_FAULT;

  229.         axisObject->done = 0U;

  230.         axisObject->state = PLSR_STATE_ERROR;

  231.         axisObject->pendingTerminal = PLSR_STATE_UNINITIALIZED;

  232.         axisObject->immediateStopPending = 0U;

  233.         PlsrResourceRelease(&axisObject->lease);

  234.         PlsrPublishAxis(axis);

  235.         return PLSR_RESULT_INVALID_STATE;

  236.     }

  237. 

  238.     axisObject->state = target;

  239.     if (target == PLSR_STATE_COMPLETED)

  240.     {

  241.         axisObject->done = 1U;

  242.     }

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

  244.         || (target == PLSR_STATE_ERROR))

  245.     {

  246.         axisObject->pendingTerminal = PLSR_STATE_UNINITIALIZED;

  247.         axisObject->immediateStopPending = 0U;

  248.         PlsrPathTerminate(&axisObject->path);

  249.         PlsrResourceRelease(&axisObject->lease);

  250.         /* 运动已结束：记录 lastBusy=0，保证掉电后恢复时位置仍可信。 */

  251.         (void)PlcDeviceSetHsdCheckpointMeta(axisObject->positionValid, 0U);

  252.         (void)PlcDeviceCheckpointHsd();

  253.     }

  254.     PlsrPublishAxis(axis);

  255.     return PLSR_RESULT_OK;

  256. }

  257. 

  258. static uint8_t PlsrCommandPriority(PLSR_COMMAND_OPCODE opcode)

  259. {

  260.     switch (opcode)

  261.     {

  262.         case PLSR_CMD_STOP_IMMEDIATE:

  263.             return 0U;

  264.         case PLSR_CMD_STOP_DECEL:

  265.             return 1U;

  266.         case PLSR_CMD_PAUSE:

  267.             return 2U;

  268.         case PLSR_CMD_RESUME:

  269.             return 3U;

  270.         default:

  271.             return 4U;

  272.     }

  273. }

  274. 

  275. static PLSR_RESULT PlsrQueueCommand(const PLSR_COMMAND *command,

  276.                                     const PLSR_START_REQUEST *start,

  277.                                     const PLSR_CALL *call)

  278. {

  279.     uint32_t interruptState;

  280.     uint8_t freeSlot = PLSR_COMMAND_QUEUE_DEPTH;

  281.     uint8_t index;

  282. 

  283.     interruptState = PlsrCoreEnterCritical();

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

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

  286.     {

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

  288.         PlsrCoreExitCritical(interruptState);

  289.         return result;

  290.     }

  291. 

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

  293.     {

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

  295.         {

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

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

  298.                     == command->sequence))

  299.             {

  300.                 PlsrCoreExitCritical(interruptState);

  301.                 return PLSR_RESULT_QUEUED;

  302.             }

  303.         }

  304.         else if (freeSlot == PLSR_COMMAND_QUEUE_DEPTH)

  305.         {

  306.             freeSlot = index;

  307.         }

  308.     }

  309. 

  310.     if (freeSlot == PLSR_COMMAND_QUEUE_DEPTH)

  311.     {

  312.         PlsrCoreExitCritical(interruptState);

  313.         return PLSR_RESULT_QUEUE_FULL;

  314.     }

  315. 

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

  317.     if (start != NULL)

  318.     {

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

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

  321.     }

  322.     else

  323.     {

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

  325.                      0,

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

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

  328.     }

  329.     if (call != NULL)

  330.     {

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

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

  333.     }

  334.     else

  335.     {

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

  337.                      0,

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

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

  340.     }

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

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

  343.     PlsrCoreExitCritical(interruptState);

  344.     return PLSR_RESULT_QUEUED;

  345. }

  346. 

  347. static uint8_t PlsrPopHighestPriorityCommand(PLSR_COMMAND_SLOT *slot)

  348. {

  349.     uint32_t interruptState;

  350.     uint32_t selectedTicket = 0UL;

  351.     uint8_t selectedPriority = 0xFFU;

  352.     uint8_t selected = PLSR_COMMAND_QUEUE_DEPTH;

  353.     uint8_t index;

  354.     uint8_t priority;

  355. 

  356.     interruptState = PlsrCoreEnterCritical();

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

  358.     {

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

  360.         {

  361.             continue;

  362.         }

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

  364.         if ((selected == PLSR_COMMAND_QUEUE_DEPTH)

  365.             || (priority < selectedPriority)

  366.             || ((priority == selectedPriority)

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

  368.                               - selectedTicket)

  369.                     < 0)))

  370.         {

  371.             selected = index;

  372.             selectedPriority = priority;

  373.             selectedTicket = PlsrCommandQueue[index].ticket;

  374.         }

  375.     }

  376. 

  377.     if (selected == PLSR_COMMAND_QUEUE_DEPTH)

  378.     {

  379.         PlsrCoreExitCritical(interruptState);

  380.         return 0U;

  381.     }

  382. 

  383.     *slot = PlsrCommandQueue[selected];

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

  385.     PlsrCoreExitCritical(interruptState);

  386.     return 1U;

  387. }

  388. 

  389. #ifdef PLSR_HOST_TEST

  390. PLSR_RESULT PlsrPostStart(const PLSR_START_REQUEST *request)

  391. {

  392.     PLSR_COMMAND command;

  393. 

  394.     if (request == NULL)

  395.     {

  396.         return PLSR_RESULT_INVALID_ARGUMENT;

  397.     }

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

  399.     {

  400.         return PLSR_RESULT_INVALID_AXIS;

  401.     }

  402.     if (PlsrInitialized == 0U)

  403.     {

  404.         return PLSR_RESULT_INVALID_STATE;

  405.     }

  406. 

  407.     command.sequence = request->sequence;

  408.     command.axis = request->axis;

  409.     command.opcode = PLSR_CMD_START;

  410.     command.argument = 0;

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

  412. }

  413. #endif /* PLSR_HOST_TEST */

  414. 

  415. PLSR_RESULT PlsrPostCall(const PLSR_CALL *call)

  416. {

  417.     PLSR_COMMAND command;

  418. 

  419.     if (call == NULL)

  420.     {

  421.         return PLSR_RESULT_INVALID_ARGUMENT;

  422.     }

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

  424.     {

  425.         return PLSR_RESULT_INVALID_AXIS;

  426.     }

  427.     if (PlsrInitialized == 0U)

  428.     {

  429.         return PLSR_RESULT_INVALID_STATE;

  430.     }

  431.     command.sequence = call->sequence;

  432.     command.axis = call->dAxis;

  433.     command.opcode = PLSR_CMD_START;

  434.     command.argument = 0;

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

  436. }

  437. 

  438. PLSR_RESULT PlsrPostCommand(const PLSR_COMMAND *command)

  439. {

  440.     if (command == NULL)

  441.     {

  442.         return PLSR_RESULT_INVALID_ARGUMENT;

  443.     }

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

  445.     {

  446.         return PLSR_RESULT_INVALID_AXIS;

  447.     }

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

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

  450.     {

  451.         return PLSR_RESULT_INVALID_ARGUMENT;

  452.     }

  453.     if (PlsrInitialized == 0U)

  454.     {

  455.         return PLSR_RESULT_INVALID_STATE;

  456.     }

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

  458. }

  459. 

  460. PLSR_RESULT PlsrPostEvent(uint8_t axis, uint32_t eventMask)

  461. {

  462.     uint32_t interruptState;

  463. 

  464.     if (axis >= PLSR_AXIS_COUNT)

  465.     {

  466.         return PLSR_RESULT_INVALID_AXIS;

  467.     }

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

  469.     {

  470.         return PLSR_RESULT_INVALID_ARGUMENT;

  471.     }

  472. 

  473.     interruptState = PlsrCoreEnterCritical();

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

  475.     PlsrCoreExitCritical(interruptState);

  476.     return PLSR_RESULT_OK;

  477. }

  478. 

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

  480. {

  481.     uint32_t interruptState;

  482.     uint32_t events;

  483. 

  484.     interruptState = PlsrCoreEnterCritical();

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

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

  487.     PlsrCoreExitCritical(interruptState);

  488.     return events;

  489. }

  490. 

  491. static uint8_t PlsrAnyAxisBusy(void)

  492. {

  493.     uint8_t axis;

  494. 

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

  496.     {

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

  498.         {

  499.             return 1U;

  500.         }

  501.     }

  502.     return 0U;

  503. }

  504. 

  505. static PLSR_RESULT PlsrStartAxis(PLSR_AXIS *axisObject,

  506.                                  const PLSR_START_REQUEST *start)

  507. {

  508.     PLSR_RESOURCE_REQUEST resourceRequest;

  509.     PLSR_RESULT result;

  510. 

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

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

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

  514.     {

  515.         return PLSR_RESULT_INVALID_STATE;

  516.     }

  517. 

  518.     resourceRequest.ownerAxis = start->axis;

  519.     resourceRequest.outputMode = start->outputMode;

  520.     resourceRequest.dAxis = start->axis;

  521.     resourceRequest.directionPoint = start->directionPoint;

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

  523.     if (result != PLSR_RESULT_OK)

  524.     {

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

  526.                                 ? PLSR_ERROR_RESOURCE_CONFLICT

  527.                                 : PLSR_ERROR_INVALID_RESOURCE;

  528.         return result;

  529.     }

  530. 

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

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

  533.     axisObject->error = PLSR_ERROR_NONE;

  534.     axisObject->stopReason = PLSR_STOP_REASON_NONE;

  535.     axisObject->pendingTerminal = PLSR_STATE_UNINITIALIZED;

  536.     axisObject->immediateStopPending = 0U;

  537.     axisObject->done = 0U;

  538.     axisObject->jobValid = 0U;

  539.     result = PlsrStateTransition(start->axis,

  540.                                  PLSR_STATE_ACCEL,

  541.                                  PLSR_TRANSITION_START);

  542.     if (result != PLSR_RESULT_OK)

  543.     {

  544.         PlsrResourceRelease(&axisObject->lease);

  545.     }

  546.     else

  547.     {

  548.         /* 运动开始：掉电恢复时据此判定"断电时在运动中"。 */

  549.         (void)PlcDeviceSetHsdCheckpointMeta(axisObject->positionValid, 1U);

  550.         (void)PlcDeviceCheckpointHsd();

  551.     }

  552.     return result;

  553. }

  554. 

  555. static PLSR_RESULT PlsrStartCall(PLSR_AXIS *axisObject,

  556.                                  const PLSR_CALL *call)

  557. {

  558.     PLSR_RESOURCE_REQUEST resourceRequest;

  559.     PLSR_PARSE_CONTEXT parseContext;

  560.     PLSR_RESULT result;

  561. 

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

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

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

  565.     {

  566.         return PLSR_RESULT_INVALID_STATE;

  567.     }

  568. 

  569.     parseContext.logicalPosition = axisObject->logicalPosition;

  570.     parseContext.positionValid = axisObject->positionValid;

  571.     result = PlsrBuildJobSnapshot(call,

  572.                                   &parseContext,

  573.                                   &PlsrJobScratch,

  574.                                   &axisObject->parseDetail);

  575.     if (result != PLSR_RESULT_OK)

  576.     {

  577.         return result;

  578.     }

  579. 

  580.     resourceRequest.ownerAxis = call->dAxis;

  581.     resourceRequest.outputMode =

  582.         (PLSR_OUTPUT_MODE)PlsrJobScratch.outputMode;

  583.     resourceRequest.dAxis = call->dAxis;

  584.     resourceRequest.directionPoint = PlsrJobScratch.directionPoint;

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

  586.     if (result != PLSR_RESULT_OK)

  587.     {

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

  589.                                 ? PLSR_ERROR_RESOURCE_CONFLICT

  590.                                 : PLSR_ERROR_INVALID_RESOURCE;

  591.         axisObject->parseDetail.result = result;

  592.         axisObject->parseDetail.block = PLSR_PARSE_BLOCK_OUTPUT;

  593.         return result;

  594.     }

  595. 

  596.     axisObject->job = PlsrJobScratch;

  597.     axisObject->jobValid = 1U;

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

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

  600.     axisObject->error = PLSR_ERROR_NONE;

  601.     axisObject->stopReason = PLSR_STOP_REASON_NONE;

  602.     axisObject->pendingTerminal = PLSR_STATE_UNINITIALIZED;

  603.     axisObject->immediateStopPending = 0U;

  604.     axisObject->done = 0U;

  605.     PlsrPathBegin(&axisObject->path,

  606.                   &axisObject->job,

  607.                   axisObject->logicalPosition);

  608.     if (axisObject->path.jobEnded != 0U)

  609.     {

  610.         /* 起点就是零脉冲且跳转链已结束（任务无实际脉冲）。 */

  611.         axisObject->stopReason = PLSR_STOP_REASON_NORMAL_COMPLETE;

  612.         (void)PlsrStateTransition(call->dAxis,

  613.                                   PLSR_STATE_COMPLETED,

  614.                                   PLSR_TRANSITION_JOB_COMPLETE);

  615.         axisObject->jobValid = 0U;

  616.         return PLSR_RESULT_OK;

  617.     }

  618.     result = PlsrStateTransition(call->dAxis,

  619.                                  PLSR_STATE_ACCEL,

  620.                                  PLSR_TRANSITION_START);

  621.     if (result != PLSR_RESULT_OK)

  622.     {

  623.         axisObject->jobValid = 0U;

  624.         PlsrResourceRelease(&axisObject->lease);

  625.     }

  626.     else

  627.     {

  628.         /* 运动开始：掉电恢复时据此判定"断电时在运动中"。 */

  629.         (void)PlcDeviceSetHsdCheckpointMeta(axisObject->positionValid, 1U);

  630.         (void)PlcDeviceCheckpointHsd();

  631.     }

  632.     return result;

  633. }

  634. 

  635. static PLSR_RESULT PlsrStopImmediate(uint8_t axis)

  636. {

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

  638. 

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

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

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

  642.     {

  643.         return PLSR_RESULT_OK;

  644.     }

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

  646.     {

  647.         return PLSR_RESULT_INVALID_STATE;

  648.     }

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

  650.     {

  651.         return PLSR_RESULT_OK;

  652.     }

  653. 

  654.     PlsrSetStopReason(axisObject, PLSR_STOP_REASON_STOP_IMMEDIATE);

  655.     axisObject->pendingTerminal = PLSR_STATE_STOPPED;

  656.     PlsrPathTerminate(&axisObject->path);

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

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

  659.     {

  660.         return PlsrStateTransition(axis,

  661.                                    PLSR_STATE_STOPPED,

  662.                                    PLSR_TRANSITION_STOP);

  663.     }

  664. 

  665.     axisObject->immediateStopPending = 1U;

  666.     return PLSR_RESULT_OK;

  667. }

  668. 

  669. static PLSR_RESULT PlsrStopDecel(uint8_t axis)

  670. {

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

  672. 

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

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

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

  676.     {

  677.         return PLSR_RESULT_OK;

  678.     }

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

  680.     {

  681.         return PLSR_RESULT_INVALID_STATE;

  682.     }

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

  684.     {

  685.         return PLSR_RESULT_OK;

  686.     }

  687. 

  688.     PlsrSetStopReason(axisObject, PLSR_STOP_REASON_STOP_DECEL);

  689.     axisObject->pendingTerminal = PLSR_STATE_STOPPED;

  690.     PlsrPathTerminate(&axisObject->path);

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

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

  693.     {

  694.         return PlsrStateTransition(axis,

  695.                                    PLSR_STATE_STOPPED,

  696.                                    PLSR_TRANSITION_STOP);

  697.     }

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

  699.     {

  700.         return PLSR_RESULT_OK;

  701.     }

  702.     return PlsrStateTransition(axis,

  703.                                PLSR_STATE_DECEL,

  704.                                PLSR_TRANSITION_DECEL_REQUEST);

  705. }

  706. 

  707. static PLSR_RESULT PlsrPause(uint8_t axis)

  708. {

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

  710. 

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

  712.     {

  713.         return PLSR_RESULT_OK;

  714.     }

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

  716.     {

  717.         return PLSR_RESULT_BUSY;

  718.     }

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

  720.     {

  721.         PlsrSetStopReason(axisObject, PLSR_STOP_REASON_PAUSE);

  722.         PlsrPathTerminate(&axisObject->path);

  723.         return PlsrStateTransition(axis,

  724.                                    PLSR_STATE_PAUSED,

  725.                                    PLSR_TRANSITION_DECEL_COMPLETE);

  726.     }

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

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

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

  730.     {

  731.         return PLSR_RESULT_INVALID_STATE;

  732.     }

  733. 

  734.     PlsrSetStopReason(axisObject, PLSR_STOP_REASON_PAUSE);

  735.     axisObject->pendingTerminal = PLSR_STATE_PAUSED;

  736.     PlsrPathTerminate(&axisObject->path);

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

  738.     {

  739.         return PLSR_RESULT_OK;

  740.     }

  741.     return PlsrStateTransition(axis,

  742.                                PLSR_STATE_DECEL,

  743.                                PLSR_TRANSITION_DECEL_REQUEST);

  744. }

  745. 

  746. static PLSR_RESULT PlsrExecuteCommand(const PLSR_COMMAND_SLOT *slot)

  747. {

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

  749.     PLC_DEVICE_RESULT deviceResult;

  750.     PLSR_RESULT result;

  751. 

  752.     switch (slot->command.opcode)

  753.     {

  754.         case PLSR_CMD_START:

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

  756.             {

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

  758.             }

  759.             else

  760.             {

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

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

  763.                              : PLSR_RESULT_INVALID_ARGUMENT;

  764.             }

  765.             break;

  766. 

  767.         case PLSR_CMD_STOP_DECEL:

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

  769.             break;

  770. 

  771.         case PLSR_CMD_STOP_IMMEDIATE:

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

  773.             break;

  774. 

  775.         case PLSR_CMD_PAUSE:

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

  777.             break;

  778. 

  779.         case PLSR_CMD_RESUME:

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

  781.             {

  782.                 result = PLSR_RESULT_INVALID_STATE;

  783.             }

  784.             else

  785.             {

  786.                 axisObject->stopReason = PLSR_STOP_REASON_NONE;

  787.                 axisObject->pendingTerminal = PLSR_STATE_UNINITIALIZED;

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

  789.                                              PLSR_STATE_ACCEL,

  790.                                              PLSR_TRANSITION_WAIT_COMPLETE);

  791.             }

  792.             break;

  793. 

  794.         case PLSR_CMD_SET_POSITION:

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

  796.             {

  797.                 result = PLSR_RESULT_BUSY;

  798.             }

  799.             else

  800.             {

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

  802.                 axisObject->positionValid = 1U;

  803.                 axisObject->positionOverflow = 0U;

  804.                 PlsrPublishPosition(slot->command.axis, axisObject);

  805.                 (void)PlcDeviceSetHsdCheckpointMeta(1U, 0U);

  806.                 (void)PlcDeviceCheckpointHsd();

  807.                 result = PLSR_RESULT_OK;

  808.             }

  809.             break;

  810. 

  811.         case PLSR_CMD_CLEAR_POSITION:

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

  813.             {

  814.                 result = PLSR_RESULT_BUSY;

  815.             }

  816.             else

  817.             {

  818.                 axisObject->logicalPosition = 0;

  819.                 axisObject->positionValid = 1U;

  820.                 axisObject->positionOverflow = 0U;

  821.                 PlsrPublishPosition(slot->command.axis, axisObject);

  822.                 (void)PlcDeviceSetHsdCheckpointMeta(1U, 0U);

  823.                 (void)PlcDeviceCheckpointHsd();

  824.                 result = PLSR_RESULT_OK;

  825.             }

  826.             break;

  827. 

  828.         case PLSR_CMD_CLEAR_TOTAL:

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

  830.             {

  831.                 result = PLSR_RESULT_BUSY;

  832.             }

  833.             else

  834.             {

  835.                 axisObject->totalPulses = 0;

  836.                 result = PLSR_RESULT_OK;

  837.             }

  838.             break;

  839. 

  840.         case PLSR_CMD_SAVE_CONFIG:

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

  842.             {

  843.                 result = PLSR_RESULT_BUSY;

  844.             }

  845.             else

  846.             {

  847.                 deviceResult = PlcDeviceSaveSfd();

  848.                 result = (deviceResult == PLC_DEVICE_OK)

  849.                              ? PLSR_RESULT_OK

  850.                              : PLSR_RESULT_PERSISTENCE_ERROR;

  851.             }

  852.             break;

  853. 

  854.         case PLSR_CMD_LOAD_CONFIG:

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

  856.             {

  857.                 result = PLSR_RESULT_BUSY;

  858.             }

  859.             else

  860.             {

  861.                 deviceResult = PlcDeviceLoadSfd();

  862.                 result = (deviceResult == PLC_DEVICE_OK)

  863.                              ? PLSR_RESULT_OK

  864.                              : PLSR_RESULT_PERSISTENCE_ERROR;

  865.             }

  866.             break;

  867. 

  868.         case PLSR_CMD_RESET_ERROR:

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

  870.             {

  871.                 result = PLSR_RESULT_INVALID_STATE;

  872.             }

  873.             else

  874.             {

  875.                 axisObject->error = PLSR_ERROR_NONE;

  876.                 axisObject->stopReason = PLSR_STOP_REASON_NONE;

  877.                 axisObject->done = 0U;

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

  879.                                              PLSR_STATE_IDLE,

  880.                                              PLSR_TRANSITION_RESET_ERROR);

  881.             }

  882.             break;

  883. 

  884.         case PLSR_CMD_SELF_TEST:

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

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

  887.                          ? PLSR_RESULT_OK

  888.                          : PLSR_RESULT_BUSY;

  889.             break;

  890. 

  891.         default:

  892.             result = PLSR_RESULT_INVALID_ARGUMENT;

  893.             break;

  894.     }

  895. 

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

  897.     axisObject->lastCommandResult = result;

  898.     axisObject->hasLastCommand = 1U;

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

  900.     return result;

  901. }

  902. 

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

  904. {

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

  906. 

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

  908.     {

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

  910.         {

  911.             PlsrSetStopReason(axisObject,

  912.                               PLSR_STOP_REASON_SOFTWARE_EMERGENCY);

  913.             axisObject->done = 0U;

  914.             PlsrPathTerminate(&axisObject->path);

  915.             (void)PlsrStateTransition(axis,

  916.                                       PLSR_STATE_STOPPED,

  917.                                       PLSR_TRANSITION_STOP);

  918.         }

  919.         return;

  920.     }

  921. 

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

  923.     {

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

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

  926.         {

  927.             axisObject->error = PLSR_ERROR_LIMIT_POSITIVE;

  928.             PlsrSetStopReason(axisObject,

  929.                               PLSR_STOP_REASON_LIMIT_POSITIVE);

  930.             axisObject->pendingTerminal = PLSR_STATE_STOPPED;

  931.             PlsrPathTerminate(&axisObject->path);

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

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

  934.             {

  935.                 (void)PlsrStateTransition(axis,

  936.                                           PLSR_STATE_STOPPED,

  937.                                           PLSR_TRANSITION_STOP);

  938.             }

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

  940.             {

  941.                 (void)PlsrStateTransition(axis,

  942.                                           PLSR_STATE_DECEL,

  943.                                           PLSR_TRANSITION_DECEL_REQUEST);

  944.             }

  945.         }

  946.         return;

  947.     }

  948. 

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

  950.     {

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

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

  953.         {

  954.             axisObject->error = PLSR_ERROR_LIMIT_NEGATIVE;

  955.             PlsrSetStopReason(axisObject,

  956.                               PLSR_STOP_REASON_LIMIT_NEGATIVE);

  957.             axisObject->pendingTerminal = PLSR_STATE_STOPPED;

  958.             PlsrPathTerminate(&axisObject->path);

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

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

  961.             {

  962.                 (void)PlsrStateTransition(axis,

  963.                                           PLSR_STATE_STOPPED,

  964.                                           PLSR_TRANSITION_STOP);

  965.             }

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

  967.             {

  968.                 (void)PlsrStateTransition(axis,

  969.                                           PLSR_STATE_DECEL,

  970.                                           PLSR_TRANSITION_DECEL_REQUEST);

  971.             }

  972.         }

  973.         return;

  974.     }

  975. 

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

  977.     {

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

  979.                                 ? PLSR_ERROR_TIMER_FAULT

  980.                                 : PLSR_ERROR_COUNTER_FAULT;

  981.         PlsrSetStopReason(axisObject, PLSR_STOP_REASON_FAULT);

  982.         axisObject->done = 0U;

  983.         PlsrPathTerminate(&axisObject->path);

  984.         (void)PlsrStateTransition(axis,

  985.                                   PLSR_STATE_ERROR,

  986.                                   PLSR_TRANSITION_FAULT);

  987.     }

  988. }

  989. 

  990. /* 应用路径执行器的动作：段间推进、进入等待、结束、让出、错误。 */

  991. static void PlsrApplyPathAction(uint8_t axis, PLSR_PATH_ACTION action)

  992. {

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

  994. 

  995.     switch (action)

  996.     {

  997.         case PLSR_PATH_ACTION_NEXT_SEGMENT:

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

  999.             {

  1000.                 (void)PlsrStateTransition(axis,

  1001.                                           PLSR_STATE_ACCEL,

  1002.                                           PLSR_TRANSITION_WAIT_COMPLETE);

  1003.             }

  1004.             else if ((axisObject->state == PLSR_STATE_ACCEL)

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

  1006.                      || (axisObject->state == PLSR_STATE_DECEL))

  1007.             {

  1008.                 (void)PlsrStateTransition(axis,

  1009.                                           PLSR_STATE_ACCEL,

  1010.                                           PLSR_TRANSITION_START);

  1011.             }

  1012.             break;

  1013. 

  1014.         case PLSR_PATH_ACTION_ENTER_WAIT:

  1015.             if ((axisObject->state == PLSR_STATE_ACCEL)

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

  1017.             {

  1018.                 (void)PlsrStateTransition(axis,

  1019.                                           PLSR_STATE_WAIT,

  1020.                                           PLSR_TRANSITION_WAIT_BEGIN);

  1021.             }

  1022.             break;

  1023. 

  1024.         case PLSR_PATH_ACTION_JOB_COMPLETE:

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

  1026.             {

  1027.                 axisObject->stopReason = PLSR_STOP_REASON_NORMAL_COMPLETE;

  1028.                 (void)PlsrStateTransition(axis,

  1029.                                           PLSR_STATE_COMPLETED,

  1030.                                           PLSR_TRANSITION_JOB_COMPLETE);

  1031.             }

  1032.             break;

  1033. 

  1034.         case PLSR_PATH_ACTION_YIELD:

  1035.             /* 预算耗尽：本轮不再推进，下个 tick 由 PlsrPathTick 恢复。 */

  1036.             break;

  1037. 

  1038.         case PLSR_PATH_ACTION_ERROR:

  1039.             axisObject->error = PLSR_ERROR_INTERNAL;

  1040.             PlsrSetStopReason(axisObject, PLSR_STOP_REASON_FAULT);

  1041.             axisObject->done = 0U;

  1042.             (void)PlsrStateTransition(axis,

  1043.                                       PLSR_STATE_ERROR,

  1044.                                       PLSR_TRANSITION_FAULT);

  1045.             break;

  1046. 

  1047.         default:

  1048.             break;

  1049.     }

  1050. }

  1051. 

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

  1053. {

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

  1055. 

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

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

  1058.     {

  1059.         (void)PlsrStateTransition(axis,

  1060.                                   PLSR_STATE_STOPPED,

  1061.                                   PLSR_TRANSITION_STOP);

  1062.         return;

  1063.     }

  1064. 

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

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

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

  1068.     {

  1069.         (void)PlsrStateTransition(axis,

  1070.                                   PLSR_STATE_RUN,

  1071.                                   PLSR_TRANSITION_ACCEL_COMPLETE);

  1072.     }

  1073. 

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

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

  1076.     {

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

  1078.         {

  1079.             (void)PlsrStateTransition(axis,

  1080.                                       PLSR_STATE_PAUSED,

  1081.                                       PLSR_TRANSITION_DECEL_COMPLETE);

  1082.         }

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

  1084.         {

  1085.             (void)PlsrStateTransition(axis,

  1086.                                       PLSR_STATE_STOPPED,

  1087.                                       PLSR_TRANSITION_DECEL_COMPLETE);

  1088.         }

  1089.         else

  1090.         {

  1091.             (void)PlsrStateTransition(axis,

  1092.                                       PLSR_STATE_RUN,

  1093.                                       PLSR_TRANSITION_DECEL_COMPLETE);

  1094.         }

  1095.     }

  1096. 

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

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

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

  1100.     {

  1101.         (void)PlsrStateTransition(axis,

  1102.                                   PLSR_STATE_WAIT,

  1103.                                   PLSR_TRANSITION_WAIT_BEGIN);

  1104.     }

  1105. 

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

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

  1108.     {

  1109.         (void)PlsrStateTransition(axis,

  1110.                                   PLSR_STATE_ACCEL,

  1111.                                   PLSR_TRANSITION_WAIT_COMPLETE);

  1112.     }

  1113. 

  1114.     if (((events & PLSR_EVENT_SEGMENT_COMPLETE) != 0UL)

  1115.         && (axisObject->state == PLSR_STATE_RUN)

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

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

  1118.     {

  1119.         PLSR_PATH_ACTION action = PlsrPathOnSegmentDone(

  1120.             &axisObject->path,

  1121.             &axisObject->job,

  1122.             axisObject->logicalPosition);

  1123. 

  1124.         PlsrApplyPathAction(axis, action);

  1125.     }

  1126. 

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

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

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

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

  1131.     {

  1132.         axisObject->stopReason = PLSR_STOP_REASON_NORMAL_COMPLETE;

  1133.         (void)PlsrStateTransition(axis,

  1134.                                   PLSR_STATE_COMPLETED,

  1135.                                   PLSR_TRANSITION_JOB_COMPLETE);

  1136.     }

  1137. }

  1138. 

  1139. PLSR_RESULT PlsrInit(void)

  1140. {

  1141.     int32_t restoredPosition;

  1142.     uint8_t restoredPositionValid;

  1143.     uint8_t restoredLastBusy;

  1144.     uint8_t axis;

  1145. 

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

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

  1148.     PlsrNextTicket = 0UL;

  1149.     PlsrResourceInit();

  1150.     PlsrInitialized = 1U;

  1151. 

  1152.     restoredPositionValid = PlcDeviceGetRestoredHsdPositionValid();

  1153.     restoredLastBusy = PlcDeviceGetRestoredHsdLastBusy();

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

  1155.     {

  1156.         PlsrAxes[axis].state = PLSR_STATE_UNINITIALIZED;

  1157.         PlsrAxes[axis].pendingTerminal = PLSR_STATE_UNINITIALIZED;

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

  1159.         if (PlcDeviceReadHsdDword(

  1160.                 (uint16_t)(axis * PLSR_HSD_RUNTIME_AXIS_COUNT),

  1161.                 &restoredPosition) == PLC_DEVICE_OK)

  1162.         {

  1163.             PlsrAxes[axis].logicalPosition = restoredPosition;

  1164.         }

  1165.         /* 只有上次正常停机且保存了位置有效标志，才允许绝对定位；

  1166.          * 运动中掉电（lastBusy=1）时位置不可信。 */

  1167.         if ((restoredPositionValid != 0U) && (restoredLastBusy == 0U))

  1168.         {

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

  1170.         }

  1171.         if (PlsrStateTransition(axis,

  1172.                                 PLSR_STATE_IDLE,

  1173.                                 PLSR_TRANSITION_INITIALIZED)

  1174.             != PLSR_RESULT_OK)

  1175.         {

  1176.             return PLSR_RESULT_INTERNAL_ERROR;

  1177.         }

  1178.     }

  1179.     return PLSR_RESULT_OK;

  1180. }

  1181. 

  1182. void PlsrProcess(void)

  1183. {

  1184.     PLSR_COMMAND_SLOT slot;

  1185.     uint32_t events;

  1186.     uint8_t processedCommands = 0U;

  1187.     uint8_t axis;

  1188. 

  1189.     if (PlsrInitialized == 0U)

  1190.     {

  1191.         return;

  1192.     }

  1193. 

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

  1195.     {

  1196.         events = PlsrTakeEvents(axis, PLSR_EVENT_CRITICAL_MASK);

  1197.         if (events != 0UL)

  1198.         {

  1199.             PlsrProcessCriticalEvents(axis, events);

  1200.         }

  1201.     }

  1202. 

  1203.     while ((processedCommands < PLSR_COMMAND_QUEUE_DEPTH)

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

  1205.     {

  1206.         (void)PlsrExecuteCommand(&slot);

  1207.         processedCommands++;

  1208.     }

  1209. 

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

  1211.     {

  1212.         events = PlsrTakeEvents(axis,

  1213.                                 PLSR_EVENT_ALL_MASK

  1214.                                     & ~PLSR_EVENT_CRITICAL_MASK);

  1215.         if (events != 0UL)

  1216.         {

  1217.             PlsrProcessNormalEvents(axis, events);

  1218.         }

  1219.     }

  1220. 

  1221.     /* 1ms tick：路径执行器推进（WAIT/ACT 计时、信号/EXT 轮询、跳转链）。 */

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

  1223.     {

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

  1225.         PLSR_PATH_ACTION action;

  1226. 

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

  1228.         {

  1229.             continue;

  1230.         }

  1231.         action = PlsrPathTick(&axisObject->path,

  1232.                               &axisObject->job,

  1233.                               axisObject->logicalPosition);

  1234.         if (action != PLSR_PATH_ACTION_NONE)

  1235.         {

  1236.             PlsrApplyPathAction(axis, action);

  1237.         }

  1238.     }

  1239. }

  1240. 

  1241. void PlsrTask(void *argument)

  1242. {

  1243.     (void)argument;

  1244. #ifdef PLSR_HOST_TEST

  1245.     PlsrProcess();

  1246. #else

  1247.     while (1)

  1248.     {

  1249.         PlsrProcess();

  1250.         OSTimeDly(1U);

  1251.     }

  1252. #endif

  1253. }

  1254. 

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

  1256. {

  1257.     PLSR_AXIS *axisObject;

  1258.     uint32_t interruptState;

  1259. 

  1260.     if (axis >= PLSR_AXIS_COUNT)

  1261.     {

  1262.         return PLSR_RESULT_INVALID_AXIS;

  1263.     }

  1264.     if (status == NULL)

  1265.     {

  1266.         return PLSR_RESULT_INVALID_ARGUMENT;

  1267.     }

  1268. 

  1269.     interruptState = PlsrCoreEnterCritical();

  1270.     axisObject = &PlsrAxes[axis];

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  1288.                                  ? axisObject->lease.directionPoint

  1289.                                  : PLSR_DIRECTION_POINT_NONE;

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

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

  1292.     status->positionOverflow = axisObject->positionOverflow;

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

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

  1295.                                ? axisObject->job.speedClamped

  1296.                                : 0U;

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

  1298.                                ? axisObject->job.segmentCount

  1299.                                : 0U;

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

  1301.                                ? axisObject->job.startSegment

  1302.                                : 0U;

  1303.     status->currentSegment = (axisObject->jobValid != 0U)

  1304.                                  ? PlsrPathGetCurrentSegment(

  1305.                                        &axisObject->path)

  1306.                                  : 0U;

  1307.     PlsrCoreExitCritical(interruptState);

  1308.     return PLSR_RESULT_OK;

  1309. }

  1310. 

  1311. PLSR_RESULT PlsrGetLastParseDetail(uint8_t axis,

  1312.                                    PLSR_PARSE_DETAIL *detail)

  1313. {

  1314.     uint32_t interruptState;

  1315. 

  1316.     if (axis >= PLSR_AXIS_COUNT)

  1317.     {

  1318.         return PLSR_RESULT_INVALID_AXIS;

  1319.     }

  1320.     if (detail == NULL)

  1321.     {

  1322.         return PLSR_RESULT_INVALID_ARGUMENT;

  1323.     }

  1324.     interruptState = PlsrCoreEnterCritical();

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

  1326.     PlsrCoreExitCritical(interruptState);

  1327.     return PLSR_RESULT_OK;

  1328. }