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

2288 lines
76 KiB
Датотека Blame Историја 

  1. #include "plsr_core.h"

  2. #include "plc_device.h"

  3. #include "plsr_address_map.h"

  4. #include "plsr_hal_f407.h"

  5. #include "plsr_path.h"

  6. #include "plsr_profile.h"

  7. #include "plsr_resource.h"

  8. #include <string.h>

  9. 

  10. #define PLSR_CORE_SFD_AXIS_STRIDE      (130U)

  11. 

  12. #ifndef PLSR_HOST_TEST

  13. #include "stm32f4xx.h"

  14. #include "ucos_ii.h"

  15. #endif

  16. 

  17. typedef struct

  18. {

  19.     PLSR_STATE state;

  20.     PLSR_OUTPUT_MODE outputMode;

  21.     PLSR_ERROR error;

  22.     uint16_t compatibleErrorCode;

  23.     uint16_t compatibleErrorBlock;

  24.     PLSR_STOP_REASON stopReason;

  25.     PLSR_STATE pendingTerminal;

  26.     PLSR_RESOURCE_LEASE lease;

  27.     PLSR_JOB_SNAPSHOT job;

  28.     PLSR_PARSE_DETAIL parseDetail;

  29.     volatile uint32_t pendingEvents;

  30.     uint32_t lastCommandSequence;

  31.     PLSR_RESULT lastCommandResult;

  32.     uint32_t illegalTransitionCount;

  33.     int64_t logicalPosition;

  34.     int64_t taskPulses;

  35.     int64_t totalPulses;

  36.     int64_t segmentAccountedPulses;

  37.     int64_t equivalentCommandRemainder;

  38.     PLSR_EQUIVALENT_CONFIG equivalent;

  39.     PLSR_PATH_CONTEXT path;

  40.     PLSR_PROFILE_STATE profile;

  41.     uint8_t profileActive;

  42.     uint8_t profileWasAccel;

  43.     uint8_t hasLastCommand;

  44.     uint8_t done;

  45.     uint8_t directionPositive;

  46.     uint8_t immediateStopPending;

  47.     uint8_t positionValid;

  48.     uint8_t jobValid;

  49.     uint8_t positionOverflow;

  50.     uint8_t segmentAccountingActive;

  51.     uint8_t positiveLimitActive;

  52.     uint8_t negativeLimitActive;

  53.     uint8_t emergencyLatched;

  54.     uint8_t segmentEventPublished;

  55. } PLSR_AXIS;

  56. 

  57. typedef struct

  58. {

  59.     PLSR_COMMAND command;

  60.     PLSR_START_REQUEST start;

  61.     PLSR_CALL call;

  62.     uint32_t ticket;

  63.     uint8_t hasStart;

  64.     uint8_t hasCall;

  65.     uint8_t occupied;

  66. } PLSR_COMMAND_SLOT;

  67. 

  68. static PLSR_AXIS PlsrAxes[PLSR_AXIS_COUNT];

  69. static PLSR_COMMAND_SLOT PlsrCommandQueue[PLSR_COMMAND_QUEUE_DEPTH];

  70. static uint32_t PlsrNextTicket;

  71. static uint8_t PlsrInitialized;

  72. static PLSR_JOB_SNAPSHOT PlsrJobScratch;

  73. 

  74. static void PlsrStopSegmentHardware(uint8_t axis, PLSR_AXIS *axisObject);

  75. static PLSR_RESULT PlsrStartSegmentHardware(uint8_t axis,

  76.                                             PLSR_AXIS *axisObject);

  77. static void PlsrAccountHardwarePulses(uint8_t axis,

  78.                                       PLSR_AXIS *axisObject);

  79. static void PlsrPublishSegmentEvent(uint8_t axis,

  80.                                     PLSR_AXIS *axisObject,

  81.                                     PLSR_STOP_REASON reason);

  82. 

  83. static uint32_t PlsrCoreEnterCritical(void)

  84. {

  85. #ifdef PLSR_HOST_TEST

  86.     return 0UL;

  87. #else

  88.     uint32_t interruptState = __get_PRIMASK();

  89.     __disable_irq();

  90.     __DMB();

  91.     return interruptState;

  92. #endif

  93. }

  94. 

  95. static void PlsrCoreExitCritical(uint32_t interruptState)

  96. {

  97. #ifdef PLSR_HOST_TEST

  98.     (void)interruptState;

  99. #else

  100.     __DMB();

  101.     if (interruptState == 0UL)

  102.     {

  103.         __enable_irq();

  104.     }

  105. #endif

  106. }

  107. 

  108. static uint8_t PlsrStateIsBusy(PLSR_STATE state)

  109. {

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

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

  112.             || (state == PLSR_STATE_PAUSED))

  113.                ? 1U

  114.                : 0U;

  115. }

  116. 

  117. static uint8_t PlsrStateIsPulseActive(PLSR_STATE state)

  118. {

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

  120.             || (state == PLSR_STATE_DECEL))

  121.                ? 1U

  122.                : 0U;

  123. }

  124. 

  125. static void PlsrLoadAxisEquivalentConfig(uint8_t axis,

  126.                                          PLSR_EQUIVALENT_CONFIG *config)

  127. {

  128.     uint16_t base = (uint16_t)(PLSR_SFD_CONFIG_START

  129.                                + (uint16_t)axis

  130.                                      * PLSR_CORE_SFD_AXIS_STRIDE);

  131.     uint16_t word;

  132.     uint16_t lowWord;

  133.     uint16_t highWord;

  134. 

  135.     config->unitCode = 0U;

  136.     config->pulsesPerRevolution = 1UL;

  137.     config->movementPerRevolution = 1UL;

  138.     if (PlcDeviceReadSfd(base, &word) != PLC_DEVICE_OK)

  139.     {

  140.         return;

  141.     }

  142.     config->unitCode = (uint8_t)((word >> 8U) & 0x07U);

  143.     if ((PlcDeviceReadSfd((uint16_t)(base + 2U), &lowWord)

  144.          != PLC_DEVICE_OK)

  145.         || (PlcDeviceReadSfd((uint16_t)(base + 3U), &highWord)

  146.             != PLC_DEVICE_OK))

  147.     {

  148.         config->unitCode = 0U;

  149.         return;

  150.     }

  151.     config->pulsesPerRevolution = (uint32_t)lowWord

  152.                                   | ((uint32_t)highWord << 16U);

  153.     if ((PlcDeviceReadSfd((uint16_t)(base + 4U), &lowWord)

  154.          != PLC_DEVICE_OK)

  155.         || (PlcDeviceReadSfd((uint16_t)(base + 5U), &highWord)

  156.             != PLC_DEVICE_OK))

  157.     {

  158.         config->unitCode = 0U;

  159.         return;

  160.     }

  161.     config->movementPerRevolution = (uint32_t)lowWord

  162.                                     | ((uint32_t)highWord << 16U);

  163.     if (PlsrPositionValidateEquivalent(config) != PLSR_RESULT_OK)

  164.     {

  165.         config->unitCode = 0U;

  166.         config->pulsesPerRevolution = 1UL;

  167.         config->movementPerRevolution = 1UL;

  168.     }

  169. }

  170. 

  171. static void PlsrPublishSdDword(uint8_t axis,

  172.                                uint8_t lowItem,

  173.                                int32_t value)

  174. {

  175.     (void)PlcDevicePublishSdDword(axis, lowItem, value);

  176. }

  177. 

  178. static int32_t PlsrGetCompatibleSegmentPulses(const PLSR_AXIS *axisObject)

  179. {

  180.     int64_t signedPulses = (axisObject->directionPositive != 0U)

  181.                                ? axisObject->segmentAccountedPulses

  182.                                : -axisObject->segmentAccountedPulses;

  183. 

  184.     if (signedPulses > INT32_MAX)

  185.     {

  186.         return INT32_MAX;

  187.     }

  188.     if (signedPulses < INT32_MIN)

  189.     {

  190.         return INT32_MIN;

  191.     }

  192.     return (int32_t)signedPulses;

  193. }

  194. 

  195. static int32_t PlsrClampCompatibleInt32(int64_t value)

  196. {

  197.     if (value > INT32_MAX) return INT32_MAX;

  198.     if (value < INT32_MIN) return INT32_MIN;

  199.     return (int32_t)value;

  200. }

  201. 

  202. static void PlsrPublishSegmentEvent(uint8_t axis,

  203.                                     PLSR_AXIS *axisObject,

  204.                                     PLSR_STOP_REASON reason)

  205. {

  206.     uint16_t segment;

  207. 

  208.     if ((axisObject->jobValid == 0U)

  209.         || (axisObject->segmentEventPublished != 0U))

  210.     {

  211.         return;

  212.     }

  213.     segment = PlsrPathGetCurrentSegment(&axisObject->path);

  214.     if ((segment == 0U) || (segment > PLSR_MAX_SEGMENTS))

  215.     {

  216.         return;

  217.     }

  218.     if (PlcDevicePublishEvent(axis, segment, (uint16_t)reason)

  219.         == PLC_DEVICE_OK)

  220.     {

  221.         axisObject->segmentEventPublished = 1U;

  222.     }

  223. }

  224. 

  225. static void PlsrPublishRuntime(uint8_t axis)

  226. {

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

  228.     uint16_t currentSegment = (axisObject->jobValid != 0U)

  229.                                   ? PlsrPathGetCurrentSegment(

  230.                                         &axisObject->path)

  231.                                   : 0U;

  232.     int32_t segmentPulses = PlsrGetCompatibleSegmentPulses(axisObject);

  233.     int32_t frequencyHz = (int32_t)PlsrHwGetCurrentFrequencyHz(axis);

  234.     int64_t segmentEquivalent64 = segmentPulses;

  235.     uint32_t speed = (uint32_t)frequencyHz;

  236.     uint16_t publishedError;

  237.     uint16_t publishedBlock;

  238. 

  239.     if (PlsrPositionPulsesToUnits(&axisObject->equivalent,

  240.                                   segmentPulses,

  241.                                   &segmentEquivalent64) != PLSR_RESULT_OK)

  242.     {

  243.         axisObject->positionOverflow = 1U;

  244.         segmentEquivalent64 = (segmentPulses < 0) ? INT32_MIN : INT32_MAX;

  245.     }

  246.     if (PlsrPositionPulseFrequencyToSpeed(&axisObject->equivalent,

  247.                                           (uint32_t)frequencyHz,

  248.                                           &speed) != PLSR_RESULT_OK)

  249.     {

  250.         speed = UINT32_MAX;

  251.     }

  252. 

  253.     PlsrPublishSdDword(axis,

  254.                        PLSR_SD_ITEM_SEGMENT,

  255.                        (int32_t)currentSegment);

  256.     PlsrPublishSdDword(axis,

  257.                        PLSR_SD_ITEM_SEGMENT_PULSES,

  258.                        segmentPulses);

  259.     PlsrPublishSdDword(axis,

  260.                        PLSR_SD_ITEM_SEGMENT_EQUIV,

  261.                        PlsrClampCompatibleInt32(segmentEquivalent64));

  262.     PlsrPublishSdDword(axis, PLSR_SD_ITEM_FREQUENCY, frequencyHz);

  263.     PlsrPublishSdDword(axis,

  264.                        PLSR_SD_ITEM_SPEED,

  265.                        (speed > (uint32_t)INT32_MAX) ? INT32_MAX

  266.                                                     : (int32_t)speed);

  267.     /* SD(B+10/+11)只发布信捷兼容码；项目内部符号错误保留在状态API，

  268.      * 不得用枚举数值占用信捷固定错误码。 */

  269.     publishedError = axisObject->compatibleErrorCode;

  270.     publishedBlock = (publishedError != 0U)

  271.                          ? axisObject->compatibleErrorBlock

  272.                          : 0U;

  273.     (void)PlcDevicePublishSd(axis,

  274.                              PLSR_SD_ITEM_ERROR_CODE,

  275.                              (int32_t)publishedError);

  276.     (void)PlcDevicePublishSd(axis,

  277.                              PLSR_SD_ITEM_ERROR_BLOCK,

  278.                              (int32_t)publishedBlock);

  279. }

  280. 

  281. static void PlsrSetCompatibleParseError(uint8_t axis,

  282.                                         PLSR_AXIS *axisObject)

  283. {

  284.     uint16_t commonBase = (uint16_t)(PLSR_SFD_CONFIG_START

  285.                                       + (uint16_t)axis

  286.                                             * PLSR_CORE_SFD_AXIS_STRIDE);

  287.     uint16_t dynamicBase = (uint16_t)(PLSR_HSD_CONFIG_START

  288.                                       + (uint16_t)axis * 20U);

  289.     uint16_t set;

  290. 

  291.     axisObject->compatibleErrorCode = 0U;

  292.     axisObject->compatibleErrorBlock = 0U;

  293.     if ((axisObject->parseDetail.result == PLSR_RESULT_RESOURCE_CONFLICT)

  294.         || (axisObject->parseDetail.result == PLSR_RESULT_INVALID_RESOURCE))

  295.     {

  296.         axisObject->compatibleErrorCode = 26U;

  297.         return;

  298.     }

  299.     if ((axisObject->parseDetail.block == PLSR_PARSE_BLOCK_S0)

  300.         && (axisObject->parseDetail.segment != 0U))

  301.     {

  302.         axisObject->compatibleErrorCode = 1U;

  303.         axisObject->compatibleErrorBlock = axisObject->parseDetail.segment;

  304.         return;

  305.     }

  306.     if ((axisObject->parseDetail.address == (uint32_t)(commonBase + 2U))

  307.         || (axisObject->parseDetail.address

  308.             == (uint32_t)(commonBase + 4U)))

  309.     {

  310.         axisObject->compatibleErrorCode = 2U;

  311.         return;

  312.     }

  313.     if ((axisObject->parseDetail.address == (uint32_t)(dynamicBase + 12U))

  314.         || (axisObject->parseDetail.address

  315.             == (uint32_t)(dynamicBase + 13U)))

  316.     {

  317.         axisObject->compatibleErrorCode =

  318.             (axisObject->parseDetail.address

  319.              == (uint32_t)(dynamicBase + 12U)) ? 15U : 16U;

  320.         return;

  321.     }

  322.     for (set = 0U; set < 4U; set++)

  323.     {

  324.         uint32_t setBase = (uint32_t)commonBase + 50UL

  325.                            + (uint32_t)set * 20UL;

  326. 

  327.         if (axisObject->parseDetail.address == setBase + 12UL)

  328.         {

  329.             axisObject->compatibleErrorCode = 15U;

  330.             return;

  331.         }

  332.         if (axisObject->parseDetail.address == setBase + 13UL)

  333.         {

  334.             axisObject->compatibleErrorCode = 16U;

  335.             return;

  336.         }

  337.     }

  338.     if ((axisObject->parseDetail.address == (uint32_t)(commonBase + 30U))

  339.         || (axisObject->parseDetail.address

  340.             == (uint32_t)(commonBase + 32U))

  341.         || (axisObject->parseDetail.result == PLSR_RESULT_SEGMENT_OVERFLOW)

  342.         || (axisObject->parseDetail.result == PLSR_RESULT_BLOCK_OVERLAP)

  343.         || (axisObject->parseDetail.result == PLSR_RESULT_ADDRESS_OVERFLOW))

  344.     {

  345.         axisObject->compatibleErrorCode = 4U;

  346.         return;

  347.     }

  348.     if (axisObject->parseDetail.block == PLSR_PARSE_BLOCK_S2)

  349.     {

  350.         axisObject->compatibleErrorCode = 3U;

  351.     }

  352. }

  353. 

  354. static void PlsrPublishAxis(uint8_t axis)

  355. {

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

  357.     uint8_t compatibleRun;

  358. 

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

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

  361.     (void)PlcDevicePublishSm(axis,

  362.                              compatibleRun,

  363.                              axisObject->directionPositive);

  364.     PlsrPublishRuntime(axis);

  365. }

  366. 

  367. static void PlsrSetStopReason(PLSR_AXIS *axis,

  368.                               PLSR_STOP_REASON stopReason)

  369. {

  370.     if (stopReason > axis->stopReason)

  371.     {

  372.         axis->stopReason = stopReason;

  373.     }

  374. }

  375. 

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

  377.  * 超出范围时保持最近一次合法值，只锁存诊断，禁止回绕或静默截断。 */

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

  379. {

  380.     int32_t compatValue;

  381.     int64_t equivalentPosition;

  382.     uint16_t base = (uint16_t)((uint16_t)axis

  383.                                * PLSR_HSD_RUNTIME_AXIS_COUNT);

  384. 

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

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

  387.     {

  388.         axisObject->positionOverflow = 1U;

  389.         return;

  390.     }

  391.     compatValue = (int32_t)axisObject->logicalPosition;

  392.     (void)PlcDevicePublishHsdDword(base, compatValue);

  393.     if ((PlsrPositionPulsesToUnits(&axisObject->equivalent,

  394.                                    axisObject->logicalPosition,

  395.                                    &equivalentPosition) != PLSR_RESULT_OK)

  396.         || (equivalentPosition > INT32_MAX)

  397.         || (equivalentPosition < INT32_MIN))

  398.     {

  399.         axisObject->positionOverflow = 1U;

  400.         return;

  401.     }

  402.     (void)PlcDevicePublishHsdDword((uint16_t)(base + 2U),

  403.                                    (int32_t)equivalentPosition);

  404. }

  405. 

  406. static uint8_t PlsrAddInt64Checked(int64_t left,

  407.                                    int64_t right,

  408.                                    int64_t *result)

  409. {

  410.     if ((result == NULL)

  411.         || ((right > 0) && (left > INT64_MAX - right))

  412.         || ((right < 0) && (left < INT64_MIN - right)))

  413.     {

  414.         return 0U;

  415.     }

  416.     *result = left + right;

  417.     return 1U;

  418. }

  419. 

  420. static PLSR_RESULT PlsrReadLimitInput(const PLSR_JOB_SNAPSHOT *job,

  421.                                       uint8_t point,

  422.                                       uint8_t activeLow,

  423.                                       uint8_t *active)

  424. {

  425.     uint8_t rawLevel;

  426. 

  427.     if ((job == NULL) || (active == NULL))

  428.     {

  429.         return PLSR_RESULT_INVALID_ARGUMENT;

  430.     }

  431.     if (point == 0xFFU)

  432.     {

  433.         *active = 0U;

  434.         return PLSR_RESULT_OK;

  435.     }

  436.     if ((job->source.readBit == NULL)

  437.         || (job->source.readBit(job->source.context,

  438.                                 PLSR_DEVICE_X,

  439.                                 point,

  440.                                 &rawLevel) == 0U))

  441.     {

  442.         return PLSR_RESULT_DATA_ACCESS;

  443.     }

  444.     *active = (activeLow != 0U)

  445.                   ? ((rawLevel == 0U) ? 1U : 0U)

  446.                   : ((rawLevel != 0U) ? 1U : 0U);

  447.     return PLSR_RESULT_OK;

  448. }

  449. 

  450. static int64_t PlsrGetBrakingDistance(const PLSR_AXIS *axisObject)

  451. {

  452.     uint64_t frequencyHz;

  453.     uint64_t denominator;

  454.     uint64_t numerator;

  455. 

  456.     if ((axisObject->profileActive == 0U)

  457.         || (axisObject->profile.decelSlopeHzPerMs == 0UL))

  458.     {

  459.         return 0;

  460.     }

  461.     frequencyHz = axisObject->profile.frequencyQ32 >> 32U;

  462.     numerator = frequencyHz * frequencyHz;

  463.     denominator = UINT64_C(2000)

  464.                   * axisObject->profile.decelSlopeHzPerMs;

  465.     return (int64_t)((numerator + denominator - 1UL) / denominator);

  466. }

  467. 

  468. static PLSR_RESULT PlsrUpdateLimitState(PLSR_AXIS *axisObject,

  469.                                         const PLSR_JOB_SNAPSHOT *job,

  470.                                         uint8_t includeBrakingDistance)

  471. {

  472.     int64_t brakingDistance = 0;

  473.     uint8_t positiveHard;

  474.     uint8_t negativeHard;

  475.     uint8_t positiveSoft = 0U;

  476.     uint8_t negativeSoft = 0U;

  477.     PLSR_RESULT result;

  478. 

  479.     result = PlsrReadLimitInput(job,

  480.                                 job->limits.positiveInputPoint,

  481.                                 job->limits.positiveInputActiveLow,

  482.                                 &positiveHard);

  483.     if (result != PLSR_RESULT_OK) return result;

  484.     result = PlsrReadLimitInput(job,

  485.                                 job->limits.negativeInputPoint,

  486.                                 job->limits.negativeInputActiveLow,

  487.                                 &negativeHard);

  488.     if (result != PLSR_RESULT_OK) return result;

  489. 

  490.     if ((job->limits.softLimitEnabled != 0U)

  491.         && (axisObject->positionValid != 0U))

  492.     {

  493.         if (includeBrakingDistance != 0U)

  494.         {

  495.             brakingDistance = PlsrGetBrakingDistance(axisObject);

  496.         }

  497.         if (axisObject->logicalPosition

  498.             >= job->limits.positiveSoftLimitPulses)

  499.         {

  500.             positiveSoft = 1U;

  501.         }

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

  503.                  && (brakingDistance > 0)

  504.                  && ((axisObject->logicalPosition

  505.                       > INT64_MAX - brakingDistance)

  506.                      || (axisObject->logicalPosition + brakingDistance

  507.                          >= job->limits.positiveSoftLimitPulses)))

  508.         {

  509.             positiveSoft = 1U;

  510.         }

  511.         if (axisObject->logicalPosition

  512.             <= job->limits.negativeSoftLimitPulses)

  513.         {

  514.             negativeSoft = 1U;

  515.         }

  516.         else if ((axisObject->directionPositive == 0U)

  517.                  && (brakingDistance > 0)

  518.                  && ((axisObject->logicalPosition

  519.                       < INT64_MIN + brakingDistance)

  520.                      || (axisObject->logicalPosition - brakingDistance

  521.                          <= job->limits.negativeSoftLimitPulses)))

  522.         {

  523.             negativeSoft = 1U;

  524.         }

  525.     }

  526.     axisObject->positiveLimitActive =

  527.         ((positiveHard != 0U) || (positiveSoft != 0U)) ? 1U : 0U;

  528.     axisObject->negativeLimitActive =

  529.         ((negativeHard != 0U) || (negativeSoft != 0U)) ? 1U : 0U;

  530.     return PLSR_RESULT_OK;

  531. }

  532. 

  533. static PLSR_RESULT PlsrCheckStartProtection(PLSR_AXIS *axisObject,

  534.                                             const PLSR_JOB_SNAPSHOT *job)

  535. {

  536.     PLSR_RESULT result;

  537. 

  538.     if (axisObject->emergencyLatched != 0U)

  539.     {

  540.         return PLSR_RESULT_EMERGENCY_LATCHED;

  541.     }

  542.     if ((job->limits.softLimitEnabled != 0U)

  543.         && (axisObject->positionValid == 0U))

  544.     {

  545.         return PLSR_RESULT_POSITION_INVALID;

  546.     }

  547.     result = PlsrUpdateLimitState(axisObject, job, 0U);

  548.     if (result != PLSR_RESULT_OK)

  549.     {

  550.         return result;

  551.     }

  552.     if ((job->initialDirectionPositive != 0U)

  553.         && (axisObject->positiveLimitActive != 0U))

  554.     {

  555.         return PLSR_RESULT_LIMIT_POSITIVE;

  556.     }

  557.     if ((job->initialDirectionPositive == 0U)

  558.         && (axisObject->negativeLimitActive != 0U))

  559.     {

  560.         return PLSR_RESULT_LIMIT_NEGATIVE;

  561.     }

  562.     return PLSR_RESULT_OK;

  563. }

  564. 

  565. /* 将 HAL 实际完成的完整脉冲/AB周期合并到64位位置。

  566.  * emittedPulses 每段从0开始，因此用 segmentAccountedPulses 做差量去重。 */

  567. static void PlsrAccountHardwarePulses(uint8_t axis,

  568.                                       PLSR_AXIS *axisObject)

  569. {

  570.     int64_t emittedPulses;

  571.     int64_t delta;

  572.     int64_t signedDelta;

  573.     int64_t newLogicalPosition;

  574.     int64_t newTaskPulses;

  575.     int64_t newTotalPulses;

  576. 

  577.     if (axisObject->segmentAccountingActive == 0U)

  578.     {

  579.         return;

  580.     }

  581.     emittedPulses = PlsrHwGetEmittedPulses(axis);

  582.     if ((emittedPulses < 0)

  583.         || (emittedPulses < axisObject->segmentAccountedPulses))

  584.     {

  585.         axisObject->positionOverflow = 1U;

  586.         (void)PlsrPostEvent(axis, PLSR_EVENT_COUNTER_FAULT);

  587.         return;

  588.     }

  589.     delta = emittedPulses - axisObject->segmentAccountedPulses;

  590.     if (delta == 0)

  591.     {

  592.         return;

  593.     }

  594.     signedDelta = (axisObject->directionPositive != 0U) ? delta : -delta;

  595.     if ((PlsrAddInt64Checked(axisObject->logicalPosition,

  596.                              signedDelta,

  597.                              &newLogicalPosition) == 0U)

  598.         || (PlsrAddInt64Checked(axisObject->taskPulses,

  599.                                 signedDelta,

  600.                                 &newTaskPulses) == 0U)

  601.         || (PlsrAddInt64Checked(axisObject->totalPulses,

  602.                                 delta,

  603.                                 &newTotalPulses) == 0U))

  604.     {

  605.         axisObject->positionOverflow = 1U;

  606.         axisObject->segmentAccountedPulses = emittedPulses;

  607.         (void)PlsrPostEvent(axis, PLSR_EVENT_COUNTER_FAULT);

  608.         return;

  609.     }

  610. 

  611.     axisObject->logicalPosition = newLogicalPosition;

  612.     axisObject->taskPulses = newTaskPulses;

  613.     axisObject->totalPulses = newTotalPulses;

  614.     axisObject->segmentAccountedPulses = emittedPulses;

  615.     PlsrPublishPosition(axis, axisObject);

  616.     PlsrPublishRuntime(axis);

  617. }

  618. 

  619. static uint8_t PlsrTransitionIsAllowed(PLSR_STATE current,

  620.                                        PLSR_STATE target)

  621. {

  622.     if (current == target)

  623.     {

  624.         return 1U;

  625.     }

  626.     if (target == PLSR_STATE_ERROR)

  627.     {

  628.         return 1U;

  629.     }

  630. 

  631.     switch (current)

  632.     {

  633.         case PLSR_STATE_UNINITIALIZED:

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

  635. 

  636.         case PLSR_STATE_IDLE:

  637.         case PLSR_STATE_COMPLETED:

  638.         case PLSR_STATE_STOPPED:

  639.             return ((target == PLSR_STATE_IDLE)

  640.                     || (target == PLSR_STATE_ACCEL)

  641.                     || (target == PLSR_STATE_WAIT)

  642.                     || (target == PLSR_STATE_COMPLETED))

  643.                        ? 1U

  644.                        : 0U;

  645. 

  646.         case PLSR_STATE_ACCEL:

  647.         case PLSR_STATE_RUN:

  648.             return ((target == PLSR_STATE_ACCEL)

  649.                     || (target == PLSR_STATE_RUN)

  650.                     || (target == PLSR_STATE_DECEL)

  651.                     || (target == PLSR_STATE_WAIT)

  652.                     || (target == PLSR_STATE_COMPLETED)

  653.                     || (target == PLSR_STATE_STOPPED))

  654.                        ? 1U

  655.                        : 0U;

  656. 

  657.         case PLSR_STATE_DECEL:

  658.             return ((target == PLSR_STATE_ACCEL)

  659.                     || (target == PLSR_STATE_RUN)

  660.                     || (target == PLSR_STATE_WAIT)

  661.                     || (target == PLSR_STATE_PAUSED)

  662.                     || (target == PLSR_STATE_COMPLETED)

  663.                     || (target == PLSR_STATE_STOPPED))

  664.                        ? 1U

  665.                        : 0U;

  666. 

  667.         case PLSR_STATE_WAIT:

  668.             return ((target == PLSR_STATE_ACCEL)

  669.                     || (target == PLSR_STATE_RUN)

  670.                     || (target == PLSR_STATE_PAUSED)

  671.                     || (target == PLSR_STATE_COMPLETED)

  672.                     || (target == PLSR_STATE_STOPPED))

  673.                        ? 1U

  674.                        : 0U;

  675. 

  676.         case PLSR_STATE_PAUSED:

  677.             return ((target == PLSR_STATE_ACCEL)

  678.                     || (target == PLSR_STATE_RUN)

  679.                     || (target == PLSR_STATE_STOPPED))

  680.                        ? 1U

  681.                        : 0U;

  682. 

  683.         case PLSR_STATE_ERROR:

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

  685. 

  686.         default:

  687.             return 0U;

  688.     }

  689. }

  690. 

  691. PLSR_RESULT PlsrStateTransition(uint8_t axis,

  692.                                 PLSR_STATE target,

  693.                                 PLSR_TRANSITION_REASON reason)

  694. {

  695.     PLSR_AXIS *axisObject;

  696. 

  697.     (void)reason;

  698.     if (axis >= PLSR_AXIS_COUNT)

  699.     {

  700.         return PLSR_RESULT_INVALID_AXIS;

  701.     }

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

  703.     {

  704.         return PLSR_RESULT_INVALID_ARGUMENT;

  705.     }

  706. 

  707.     axisObject = &PlsrAxes[axis];

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

  709.     {

  710.         axisObject->illegalTransitionCount++;

  711.         axisObject->error = PLSR_ERROR_ILLEGAL_TRANSITION;

  712.         axisObject->stopReason = PLSR_STOP_REASON_FAULT;

  713.         axisObject->done = 0U;

  714.         axisObject->state = PLSR_STATE_ERROR;

  715.         axisObject->pendingTerminal = PLSR_STATE_UNINITIALIZED;

  716.         axisObject->immediateStopPending = 0U;

  717.         PlsrStopSegmentHardware(axis, axisObject);

  718.         PlsrResourceRelease(&axisObject->lease);

  719.         PlsrPublishAxis(axis);

  720.         return PLSR_RESULT_INVALID_STATE;

  721.     }

  722. 

  723.     axisObject->state = target;

  724.     if (target == PLSR_STATE_COMPLETED)

  725.     {

  726.         axisObject->done = 1U;

  727.     }

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

  729.         || (target == PLSR_STATE_ERROR))

  730.     {

  731.         axisObject->pendingTerminal = PLSR_STATE_UNINITIALIZED;

  732.         axisObject->immediateStopPending = 0U;

  733.         PlsrPathTerminate(&axisObject->path);

  734.         PlsrStopSegmentHardware(axis, axisObject);

  735.         PlsrResourceRelease(&axisObject->lease);

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

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

  738.         (void)PlcDeviceCheckpointHsd();

  739.     }

  740.     PlsrPublishAxis(axis);

  741.     return PLSR_RESULT_OK;

  742. }

  743. 

  744. static uint8_t PlsrCommandPriority(PLSR_COMMAND_OPCODE opcode)

  745. {

  746.     switch (opcode)

  747.     {

  748.         case PLSR_CMD_STOP_IMMEDIATE:

  749.             return 0U;

  750.         case PLSR_CMD_STOP_DECEL:

  751.             return 1U;

  752.         case PLSR_CMD_PAUSE:

  753.             return 2U;

  754.         case PLSR_CMD_RESUME:

  755.             return 3U;

  756.         default:

  757.             return 4U;

  758.     }

  759. }

  760. 

  761. static PLSR_RESULT PlsrQueueCommand(const PLSR_COMMAND *command,

  762.                                     const PLSR_START_REQUEST *start,

  763.                                     const PLSR_CALL *call)

  764. {

  765.     uint32_t interruptState;

  766.     uint8_t freeSlot = PLSR_COMMAND_QUEUE_DEPTH;

  767.     uint8_t index;

  768. 

  769.     interruptState = PlsrCoreEnterCritical();

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

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

  772.     {

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

  774.         PlsrCoreExitCritical(interruptState);

  775.         return result;

  776.     }

  777. 

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

  779.     {

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

  781.         {

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

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

  784.                     == command->sequence))

  785.             {

  786.                 PlsrCoreExitCritical(interruptState);

  787.                 return PLSR_RESULT_QUEUED;

  788.             }

  789.         }

  790.         else if (freeSlot == PLSR_COMMAND_QUEUE_DEPTH)

  791.         {

  792.             freeSlot = index;

  793.         }

  794.     }

  795. 

  796.     if (freeSlot == PLSR_COMMAND_QUEUE_DEPTH)

  797.     {

  798.         PlsrCoreExitCritical(interruptState);

  799.         return PLSR_RESULT_QUEUE_FULL;

  800.     }

  801. 

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

  803.     if (start != NULL)

  804.     {

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

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

  807.     }

  808.     else

  809.     {

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

  811.                      0,

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

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

  814.     }

  815.     if (call != NULL)

  816.     {

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

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

  819.     }

  820.     else

  821.     {

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

  823.                      0,

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

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

  826.     }

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

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

  829.     PlsrCoreExitCritical(interruptState);

  830.     return PLSR_RESULT_QUEUED;

  831. }

  832. 

  833. static uint8_t PlsrPopHighestPriorityCommand(PLSR_COMMAND_SLOT *slot)

  834. {

  835.     uint32_t interruptState;

  836.     uint32_t selectedTicket = 0UL;

  837.     uint8_t selectedPriority = 0xFFU;

  838.     uint8_t selected = PLSR_COMMAND_QUEUE_DEPTH;

  839.     uint8_t index;

  840.     uint8_t priority;

  841. 

  842.     interruptState = PlsrCoreEnterCritical();

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

  844.     {

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

  846.         {

  847.             continue;

  848.         }

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

  850.         if ((selected == PLSR_COMMAND_QUEUE_DEPTH)

  851.             || (priority < selectedPriority)

  852.             || ((priority == selectedPriority)

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

  854.                               - selectedTicket)

  855.                     < 0)))

  856.         {

  857.             selected = index;

  858.             selectedPriority = priority;

  859.             selectedTicket = PlsrCommandQueue[index].ticket;

  860.         }

  861.     }

  862. 

  863.     if (selected == PLSR_COMMAND_QUEUE_DEPTH)

  864.     {

  865.         PlsrCoreExitCritical(interruptState);

  866.         return 0U;

  867.     }

  868. 

  869.     *slot = PlsrCommandQueue[selected];

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

  871.     PlsrCoreExitCritical(interruptState);

  872.     return 1U;

  873. }

  874. 

  875. #ifdef PLSR_HOST_TEST

  876. PLSR_RESULT PlsrPostStart(const PLSR_START_REQUEST *request)

  877. {

  878.     PLSR_COMMAND command;

  879. 

  880.     if (request == NULL)

  881.     {

  882.         return PLSR_RESULT_INVALID_ARGUMENT;

  883.     }

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

  885.     {

  886.         return PLSR_RESULT_INVALID_AXIS;

  887.     }

  888.     if (PlsrInitialized == 0U)

  889.     {

  890.         return PLSR_RESULT_INVALID_STATE;

  891.     }

  892. 

  893.     command.sequence = request->sequence;

  894.     command.axis = request->axis;

  895.     command.opcode = PLSR_CMD_START;

  896.     command.argument = 0;

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

  898. }

  899. #endif /* PLSR_HOST_TEST */

  900. 

  901. PLSR_RESULT PlsrPostCall(const PLSR_CALL *call)

  902. {

  903.     PLSR_COMMAND command;

  904. 

  905.     if (call == NULL)

  906.     {

  907.         return PLSR_RESULT_INVALID_ARGUMENT;

  908.     }

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

  910.     {

  911.         return PLSR_RESULT_INVALID_AXIS;

  912.     }

  913.     if (PlsrInitialized == 0U)

  914.     {

  915.         return PLSR_RESULT_INVALID_STATE;

  916.     }

  917.     command.sequence = call->sequence;

  918.     command.axis = call->dAxis;

  919.     command.opcode = PLSR_CMD_START;

  920.     command.argument = 0;

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

  922. }

  923. 

  924. PLSR_RESULT PlsrPostCommand(const PLSR_COMMAND *command)

  925. {

  926.     if (command == NULL)

  927.     {

  928.         return PLSR_RESULT_INVALID_ARGUMENT;

  929.     }

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

  931.     {

  932.         return PLSR_RESULT_INVALID_AXIS;

  933.     }

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

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

  936.     {

  937.         return PLSR_RESULT_INVALID_ARGUMENT;

  938.     }

  939.     if (PlsrInitialized == 0U)

  940.     {

  941.         return PLSR_RESULT_INVALID_STATE;

  942.     }

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

  944. }

  945. 

  946. PLSR_RESULT PlsrPostEvent(uint8_t axis, uint32_t eventMask)

  947. {

  948.     uint32_t interruptState;

  949. 

  950.     if (axis >= PLSR_AXIS_COUNT)

  951.     {

  952.         return PLSR_RESULT_INVALID_AXIS;

  953.     }

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

  955.     {

  956.         return PLSR_RESULT_INVALID_ARGUMENT;

  957.     }

  958. 

  959.     interruptState = PlsrCoreEnterCritical();

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

  961.     PlsrCoreExitCritical(interruptState);

  962.     return PLSR_RESULT_OK;

  963. }

  964. 

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

  966. {

  967.     uint32_t interruptState;

  968.     uint32_t events;

  969. 

  970.     interruptState = PlsrCoreEnterCritical();

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

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

  973.     PlsrCoreExitCritical(interruptState);

  974.     return events;

  975. }

  976. 

  977. static uint8_t PlsrAnyAxisBusy(void)

  978. {

  979.     uint8_t axis;

  980. 

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

  982.     {

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

  984.         {

  985.             return 1U;

  986.         }

  987.     }

  988.     return 0U;

  989. }

  990. 

  991. static PLSR_RESULT PlsrStartAxis(PLSR_AXIS *axisObject,

  992.                                  const PLSR_START_REQUEST *start)

  993. {

  994.     PLSR_RESOURCE_REQUEST resourceRequest;

  995.     PLSR_RESULT result;

  996. 

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

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

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

  1000.     {

  1001.         return PLSR_RESULT_INVALID_STATE;

  1002.     }

  1003. 

  1004.     resourceRequest.ownerAxis = start->axis;

  1005.     resourceRequest.outputMode = start->outputMode;

  1006.     resourceRequest.dAxis = start->axis;

  1007.     resourceRequest.directionPoint = start->directionPoint;

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

  1009.     if (result != PLSR_RESULT_OK)

  1010.     {

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

  1012.                                 ? PLSR_ERROR_RESOURCE_CONFLICT

  1013.                                 : PLSR_ERROR_INVALID_RESOURCE;

  1014.         return result;

  1015.     }

  1016. 

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

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

  1019.     axisObject->error = PLSR_ERROR_NONE;

  1020.     axisObject->compatibleErrorCode = 0U;

  1021.     axisObject->compatibleErrorBlock = 0U;

  1022.     axisObject->stopReason = PLSR_STOP_REASON_NONE;

  1023.     axisObject->pendingTerminal = PLSR_STATE_UNINITIALIZED;

  1024.     axisObject->immediateStopPending = 0U;

  1025.     axisObject->done = 0U;

  1026.     axisObject->jobValid = 0U;

  1027.     axisObject->taskPulses = 0;

  1028.     axisObject->segmentAccountedPulses = 0;

  1029.     axisObject->segmentAccountingActive = 0U;

  1030.     result = PlsrStateTransition(start->axis,

  1031.                                  PLSR_STATE_ACCEL,

  1032.                                  PLSR_TRANSITION_START);

  1033.     if (result != PLSR_RESULT_OK)

  1034.     {

  1035.         PlsrResourceRelease(&axisObject->lease);

  1036.     }

  1037.     else

  1038.     {

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

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

  1041.         (void)PlcDeviceCheckpointHsd();

  1042.     }

  1043.     return result;

  1044. }

  1045. 

  1046. static PLSR_RESULT PlsrStartCall(PLSR_AXIS *axisObject,

  1047.                                  const PLSR_CALL *call)

  1048. {

  1049.     PLSR_RESOURCE_REQUEST resourceRequest;

  1050.     PLSR_PARSE_CONTEXT parseContext;

  1051.     PLSR_RESULT result;

  1052. 

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

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

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

  1056.     {

  1057.         return PLSR_RESULT_INVALID_STATE;

  1058.     }

  1059.     if (axisObject->emergencyLatched != 0U)

  1060.     {

  1061.         return PLSR_RESULT_EMERGENCY_LATCHED;

  1062.     }

  1063. 

  1064.     axisObject->compatibleErrorCode = 0U;

  1065.     axisObject->compatibleErrorBlock = 0U;

  1066. 

  1067.     parseContext.logicalPosition = axisObject->logicalPosition;

  1068.     parseContext.positionValid = axisObject->positionValid;

  1069.     result = PlsrBuildJobSnapshot(call,

  1070.                                   &parseContext,

  1071.                                   &PlsrJobScratch,

  1072.                                   &axisObject->parseDetail);

  1073.     if (result != PLSR_RESULT_OK)

  1074.     {

  1075.         PlsrSetCompatibleParseError(call->dAxis, axisObject);

  1076.         return result;

  1077.     }

  1078.     result = PlsrCheckStartProtection(axisObject, &PlsrJobScratch);

  1079.     if (result != PLSR_RESULT_OK)

  1080.     {

  1081.         if (result == PLSR_RESULT_LIMIT_POSITIVE)

  1082.         {

  1083.             axisObject->error = PLSR_ERROR_LIMIT_POSITIVE;

  1084.             axisObject->compatibleErrorCode = 5U;

  1085.             axisObject->stopReason = PLSR_STOP_REASON_LIMIT_POSITIVE;

  1086.         }

  1087.         else if (result == PLSR_RESULT_LIMIT_NEGATIVE)

  1088.         {

  1089.             axisObject->error = PLSR_ERROR_LIMIT_NEGATIVE;

  1090.             axisObject->compatibleErrorCode = 6U;

  1091.             axisObject->stopReason = PLSR_STOP_REASON_LIMIT_NEGATIVE;

  1092.         }

  1093.         else if (result == PLSR_RESULT_EMERGENCY_LATCHED)

  1094.         {

  1095.             axisObject->error = PLSR_ERROR_EMERGENCY;

  1096.             axisObject->stopReason = PLSR_STOP_REASON_SOFTWARE_EMERGENCY;

  1097.         }

  1098.         else if (result == PLSR_RESULT_DATA_ACCESS)

  1099.         {

  1100.             axisObject->error = PLSR_ERROR_INTERNAL;

  1101.             axisObject->compatibleErrorCode = 26U;

  1102.             axisObject->stopReason = PLSR_STOP_REASON_FAULT;

  1103.         }

  1104.         return result;

  1105.     }

  1106. 

  1107.     resourceRequest.ownerAxis = call->dAxis;

  1108.     resourceRequest.outputMode =

  1109.         (PLSR_OUTPUT_MODE)PlsrJobScratch.outputMode;

  1110.     resourceRequest.dAxis = call->dAxis;

  1111.     resourceRequest.directionPoint = PlsrJobScratch.directionPoint;

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

  1113.     if (result != PLSR_RESULT_OK)

  1114.     {

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

  1116.                                 ? PLSR_ERROR_RESOURCE_CONFLICT

  1117.                                 : PLSR_ERROR_INVALID_RESOURCE;

  1118.         axisObject->parseDetail.result = result;

  1119.         axisObject->parseDetail.block = PLSR_PARSE_BLOCK_OUTPUT;

  1120.         axisObject->compatibleErrorCode = 26U;

  1121.         axisObject->compatibleErrorBlock = 0U;

  1122.         return result;

  1123.     }

  1124. 

  1125.     axisObject->job = PlsrJobScratch;

  1126.     axisObject->jobValid = 1U;

  1127.     if ((axisObject->equivalent.unitCode

  1128.          != axisObject->job.equivalent.unitCode)

  1129.         || (axisObject->equivalent.pulsesPerRevolution

  1130.             != axisObject->job.equivalent.pulsesPerRevolution)

  1131.         || (axisObject->equivalent.movementPerRevolution

  1132.             != axisObject->job.equivalent.movementPerRevolution))

  1133.     {

  1134.         axisObject->equivalentCommandRemainder = 0;

  1135.     }

  1136.     axisObject->equivalent = axisObject->job.equivalent;

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

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

  1139.     axisObject->error = PLSR_ERROR_NONE;

  1140.     axisObject->compatibleErrorCode = 0U;

  1141.     axisObject->compatibleErrorBlock = 0U;

  1142.     axisObject->stopReason = PLSR_STOP_REASON_NONE;

  1143.     axisObject->pendingTerminal = PLSR_STATE_UNINITIALIZED;

  1144.     axisObject->immediateStopPending = 0U;

  1145.     axisObject->done = 0U;

  1146.     axisObject->taskPulses = 0;

  1147.     axisObject->segmentAccountedPulses = 0;

  1148.     axisObject->segmentAccountingActive = 0U;

  1149.     axisObject->segmentEventPublished = 0U;

  1150.     PlsrPathBegin(&axisObject->path,

  1151.                   &axisObject->job,

  1152.                   axisObject->logicalPosition);

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

  1154.     {

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

  1156.         axisObject->stopReason = PLSR_STOP_REASON_NORMAL_COMPLETE;

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

  1158.                                   PLSR_STATE_COMPLETED,

  1159.                                   PLSR_TRANSITION_JOB_COMPLETE);

  1160.         axisObject->jobValid = 0U;

  1161.         return PLSR_RESULT_OK;

  1162.     }

  1163.     result = PlsrStateTransition(call->dAxis,

  1164.                                  PLSR_STATE_ACCEL,

  1165.                                  PLSR_TRANSITION_START);

  1166.     if (result != PLSR_RESULT_OK)

  1167.     {

  1168.         axisObject->jobValid = 0U;

  1169.         PlsrResourceRelease(&axisObject->lease);

  1170.     }

  1171.     else

  1172.     {

  1173.         /* 启动当前段硬件输出与速度曲线。 */

  1174.         /* 零脉冲跳转链耗尽本轮预算时没有实际运动段，等待下一次

  1175.          * PlsrPathTick 找到非零段后再启动硬件。 */

  1176.         if (axisObject->path.jumpChainPending == 0U)

  1177.         {

  1178.             result = PlsrStartSegmentHardware(call->dAxis, axisObject);

  1179.         }

  1180.         if (result != PLSR_RESULT_OK)

  1181.         {

  1182.             if ((result == PLSR_RESULT_LIMIT_POSITIVE)

  1183.                 || (result == PLSR_RESULT_LIMIT_NEGATIVE))

  1184.             {

  1185.                 axisObject->error =

  1186.                     (result == PLSR_RESULT_LIMIT_POSITIVE)

  1187.                         ? PLSR_ERROR_LIMIT_POSITIVE

  1188.                         : PLSR_ERROR_LIMIT_NEGATIVE;

  1189.                 axisObject->compatibleErrorCode =

  1190.                     (result == PLSR_RESULT_LIMIT_POSITIVE) ? 5U : 6U;

  1191.                 PlsrSetStopReason(

  1192.                     axisObject,

  1193.                     (result == PLSR_RESULT_LIMIT_POSITIVE)

  1194.                         ? PLSR_STOP_REASON_LIMIT_POSITIVE

  1195.                         : PLSR_STOP_REASON_LIMIT_NEGATIVE);

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

  1197.                                           PLSR_STATE_STOPPED,

  1198.                                           PLSR_TRANSITION_STOP);

  1199.             }

  1200.             else

  1201.             {

  1202.                 axisObject->error = PLSR_ERROR_TIMER_FAULT;

  1203.                 PlsrSetStopReason(axisObject, PLSR_STOP_REASON_FAULT);

  1204.                 axisObject->done = 0U;

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

  1206.                                           PLSR_STATE_ERROR,

  1207.                                           PLSR_TRANSITION_FAULT);

  1208.             }

  1209.             return result;

  1210.         }

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

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

  1213.         (void)PlcDeviceCheckpointHsd();

  1214.     }

  1215.     return result;

  1216. }

  1217. 

  1218. static PLSR_RESULT PlsrStopImmediate(uint8_t axis)

  1219. {

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

  1221. 

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

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

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

  1225.     {

  1226.         return PLSR_RESULT_OK;

  1227.     }

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

  1229.     {

  1230.         return PLSR_RESULT_INVALID_STATE;

  1231.     }

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

  1233.     {

  1234.         return PLSR_RESULT_OK;

  1235.     }

  1236. 

  1237.     PlsrSetStopReason(axisObject, PLSR_STOP_REASON_STOP_IMMEDIATE);

  1238.     axisObject->pendingTerminal = PLSR_STATE_STOPPED;

  1239.     PlsrPublishSegmentEvent(axis,

  1240.                             axisObject,

  1241.                             PLSR_STOP_REASON_STOP_IMMEDIATE);

  1242.     PlsrPathTerminate(&axisObject->path);

  1243.     PlsrStopSegmentHardware(axis, axisObject);

  1244.     return PlsrStateTransition(axis,

  1245.                                PLSR_STATE_STOPPED,

  1246.                                PLSR_TRANSITION_STOP);

  1247. }

  1248. 

  1249. static PLSR_RESULT PlsrRequestControlledStop(uint8_t axis,

  1250.                                              PLSR_STATE terminal,

  1251.                                              PLSR_STOP_REASON reason)

  1252. {

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

  1254.     PLSR_RESULT result;

  1255. 

  1256.     PlsrSetStopReason(axisObject, reason);

  1257.     axisObject->pendingTerminal = terminal;

  1258.     PlsrPublishSegmentEvent(axis, axisObject, reason);

  1259.     PlsrPathTerminate(&axisObject->path);

  1260. 

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

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

  1263.     {

  1264.         PlsrStopSegmentHardware(axis, axisObject);

  1265.         return PlsrStateTransition(axis,

  1266.                                    terminal,

  1267.                                    PLSR_TRANSITION_DECEL_COMPLETE);

  1268.     }

  1269.     if (axisObject->profileActive == 0U)

  1270.     {

  1271.         return (axisObject->state == PLSR_STATE_DECEL)

  1272.                    ? PLSR_RESULT_OK

  1273.                    : PlsrStateTransition(axis,

  1274.                                          PLSR_STATE_DECEL,

  1275.                                          PLSR_TRANSITION_DECEL_REQUEST);

  1276.     }

  1277.     result = PlsrProfileRequestStop(&axisObject->profile);

  1278.     if (result != PLSR_RESULT_OK)

  1279.     {

  1280.         return result;

  1281.     }

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

  1283.     {

  1284.         return PLSR_RESULT_OK;

  1285.     }

  1286.     return PlsrStateTransition(axis,

  1287.                                PLSR_STATE_DECEL,

  1288.                                PLSR_TRANSITION_DECEL_REQUEST);

  1289. }

  1290. 

  1291. static PLSR_RESULT PlsrStopDecel(uint8_t axis)

  1292. {

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

  1294. 

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

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

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

  1298.     {

  1299.         return PLSR_RESULT_OK;

  1300.     }

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

  1302.     {

  1303.         return PLSR_RESULT_INVALID_STATE;

  1304.     }

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

  1306.     {

  1307.         return PLSR_RESULT_OK;

  1308.     }

  1309. 

  1310.     return PlsrRequestControlledStop(axis,

  1311.                                      PLSR_STATE_STOPPED,

  1312.                                      PLSR_STOP_REASON_STOP_DECEL);

  1313. }

  1314. 

  1315. static PLSR_RESULT PlsrPause(uint8_t axis)

  1316. {

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

  1318. 

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

  1320.     {

  1321.         return PLSR_RESULT_OK;

  1322.     }

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

  1324.     {

  1325.         return PLSR_RESULT_BUSY;

  1326.     }

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

  1328.     {

  1329.         return PlsrRequestControlledStop(axis,

  1330.                                          PLSR_STATE_PAUSED,

  1331.                                          PLSR_STOP_REASON_PAUSE);

  1332.     }

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

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

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

  1336.     {

  1337.         return PLSR_RESULT_INVALID_STATE;

  1338.     }

  1339. 

  1340.     return PlsrRequestControlledStop(axis,

  1341.                                      PLSR_STATE_PAUSED,

  1342.                                      PLSR_STOP_REASON_PAUSE);

  1343. }

  1344. 

  1345. static PLSR_RESULT PlsrExecuteCommand(const PLSR_COMMAND_SLOT *slot)

  1346. {

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

  1348.     PLC_DEVICE_RESULT deviceResult;

  1349.     PLSR_RESULT result;

  1350. 

  1351.     switch (slot->command.opcode)

  1352.     {

  1353.         case PLSR_CMD_START:

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

  1355.             {

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

  1357.             }

  1358.             else

  1359.             {

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

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

  1362.                              : PLSR_RESULT_INVALID_ARGUMENT;

  1363.             }

  1364.             break;

  1365. 

  1366.         case PLSR_CMD_STOP_DECEL:

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

  1368.             break;

  1369. 

  1370.         case PLSR_CMD_STOP_IMMEDIATE:

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

  1372.             break;

  1373. 

  1374.         case PLSR_CMD_PAUSE:

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

  1376.             break;

  1377. 

  1378.         case PLSR_CMD_RESUME:

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

  1380.             {

  1381.                 result = PLSR_RESULT_INVALID_STATE;

  1382.             }

  1383.             else

  1384.             {

  1385.                 axisObject->stopReason = PLSR_STOP_REASON_NONE;

  1386.                 axisObject->pendingTerminal = PLSR_STATE_UNINITIALIZED;

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

  1388.                                              PLSR_STATE_ACCEL,

  1389.                                              PLSR_TRANSITION_WAIT_COMPLETE);

  1390.             }

  1391.             break;

  1392. 

  1393.         case PLSR_CMD_SET_POSITION:

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

  1395.             {

  1396.                 result = PLSR_RESULT_BUSY;

  1397.             }

  1398.             else

  1399.             {

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

  1401.                 axisObject->positionValid = 1U;

  1402.                 axisObject->positionOverflow = 0U;

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

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

  1405.                 (void)PlcDeviceCheckpointHsd();

  1406.                 result = PLSR_RESULT_OK;

  1407.             }

  1408.             break;

  1409. 

  1410.         case PLSR_CMD_CLEAR_POSITION:

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

  1412.             {

  1413.                 result = PLSR_RESULT_BUSY;

  1414.             }

  1415.             else

  1416.             {

  1417.                 axisObject->logicalPosition = 0;

  1418.                 axisObject->positionValid = 1U;

  1419.                 axisObject->positionOverflow = 0U;

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

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

  1422.                 (void)PlcDeviceCheckpointHsd();

  1423.                 result = PLSR_RESULT_OK;

  1424.             }

  1425.             break;

  1426. 

  1427.         case PLSR_CMD_CLEAR_TOTAL:

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

  1429.             {

  1430.                 result = PLSR_RESULT_BUSY;

  1431.             }

  1432.             else

  1433.             {

  1434.                 axisObject->totalPulses = 0;

  1435.                 (void)PlcDeviceSetHsdCheckpointMeta(

  1436.                     axisObject->positionValid,

  1437.                     0U);

  1438.                 (void)PlcDeviceCheckpointHsd();

  1439.                 result = PLSR_RESULT_OK;

  1440.             }

  1441.             break;

  1442. 

  1443.         case PLSR_CMD_SAVE_CONFIG:

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

  1445.             {

  1446.                 result = PLSR_RESULT_BUSY;

  1447.             }

  1448.             else

  1449.             {

  1450.                 deviceResult = PlcDeviceSaveSfd();

  1451.                 result = (deviceResult == PLC_DEVICE_OK)

  1452.                              ? PLSR_RESULT_OK

  1453.                              : PLSR_RESULT_PERSISTENCE_ERROR;

  1454.             }

  1455.             break;

  1456. 

  1457.         case PLSR_CMD_LOAD_CONFIG:

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

  1459.             {

  1460.                 result = PLSR_RESULT_BUSY;

  1461.             }

  1462.             else

  1463.             {

  1464.                 deviceResult = PlcDeviceLoadSfd();

  1465.                 result = (deviceResult == PLC_DEVICE_OK)

  1466.                              ? PLSR_RESULT_OK

  1467.                              : PLSR_RESULT_PERSISTENCE_ERROR;

  1468.             }

  1469.             break;

  1470. 

  1471.         case PLSR_CMD_RESET_ERROR:

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

  1473.             {

  1474.                 result = PLSR_RESULT_BUSY;

  1475.             }

  1476.             else if ((axisObject->state != PLSR_STATE_ERROR)

  1477.                      && (axisObject->error == PLSR_ERROR_NONE)

  1478.                      && (axisObject->emergencyLatched == 0U)

  1479.                      && (axisObject->compatibleErrorCode == 0U))

  1480.             {

  1481.                 result = PLSR_RESULT_INVALID_STATE;

  1482.             }

  1483.             else

  1484.             {

  1485.                 axisObject->error = PLSR_ERROR_NONE;

  1486.                 axisObject->compatibleErrorCode = 0U;

  1487.                 axisObject->compatibleErrorBlock = 0U;

  1488.                 axisObject->emergencyLatched = 0U;

  1489.                 axisObject->stopReason = PLSR_STOP_REASON_NONE;

  1490.                 axisObject->done = 0U;

  1491.                 result = (axisObject->state == PLSR_STATE_IDLE)

  1492.                              ? PLSR_RESULT_OK

  1493.                              : PlsrStateTransition(

  1494.                                    slot->command.axis,

  1495.                                    PLSR_STATE_IDLE,

  1496.                                    PLSR_TRANSITION_RESET_ERROR);

  1497.             }

  1498.             break;

  1499. 

  1500.         case PLSR_CMD_SELF_TEST:

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

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

  1503.                          ? PLSR_RESULT_OK

  1504.                          : PLSR_RESULT_BUSY;

  1505.             break;

  1506. 

  1507.         default:

  1508.             result = PLSR_RESULT_INVALID_ARGUMENT;

  1509.             break;

  1510.     }

  1511. 

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

  1513.     axisObject->lastCommandResult = result;

  1514.     axisObject->hasLastCommand = 1U;

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

  1516.     return result;

  1517. }

  1518. 

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

  1520. {

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

  1522. 

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

  1524.     {

  1525.         axisObject->emergencyLatched = 1U;

  1526.         axisObject->error = PLSR_ERROR_EMERGENCY;

  1527.         PlsrSetStopReason(axisObject,

  1528.                           PLSR_STOP_REASON_SOFTWARE_EMERGENCY);

  1529.         axisObject->done = 0U;

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

  1531.         {

  1532.             PlsrPublishSegmentEvent(

  1533.                 axis,

  1534.                 axisObject,

  1535.                 PLSR_STOP_REASON_SOFTWARE_EMERGENCY);

  1536.             PlsrPathTerminate(&axisObject->path);

  1537.             PlsrStopSegmentHardware(axis, axisObject);

  1538.             (void)PlsrStateTransition(axis,

  1539.                                       PLSR_STATE_STOPPED,

  1540.                                       PLSR_TRANSITION_STOP);

  1541.         }

  1542.         else

  1543.         {

  1544.             PlsrPublishAxis(axis);

  1545.         }

  1546.         return;

  1547.     }

  1548. 

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

  1550.     {

  1551.         axisObject->positiveLimitActive = 1U;

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

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

  1554.         {

  1555.             axisObject->error = PLSR_ERROR_LIMIT_POSITIVE;

  1556.             axisObject->compatibleErrorCode = 5U;

  1557.             axisObject->compatibleErrorBlock = 0U;

  1558.             (void)PlsrRequestControlledStop(

  1559.                 axis,

  1560.                 PLSR_STATE_STOPPED,

  1561.                 PLSR_STOP_REASON_LIMIT_POSITIVE);

  1562.             return;

  1563.         }

  1564.     }

  1565. 

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

  1567.     {

  1568.         axisObject->negativeLimitActive = 1U;

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

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

  1571.         {

  1572.             axisObject->error = PLSR_ERROR_LIMIT_NEGATIVE;

  1573.             axisObject->compatibleErrorCode = 6U;

  1574.             axisObject->compatibleErrorBlock = 0U;

  1575.             (void)PlsrRequestControlledStop(

  1576.                 axis,

  1577.                 PLSR_STATE_STOPPED,

  1578.                 PLSR_STOP_REASON_LIMIT_NEGATIVE);

  1579.             return;

  1580.         }

  1581.     }

  1582. 

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

  1584.     {

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

  1586.                                 ? PLSR_ERROR_TIMER_FAULT

  1587.                                 : PLSR_ERROR_COUNTER_FAULT;

  1588.         PlsrSetStopReason(axisObject, PLSR_STOP_REASON_FAULT);

  1589.         axisObject->done = 0U;

  1590.         PlsrPathTerminate(&axisObject->path);

  1591.         PlsrStopSegmentHardware(axis, axisObject);

  1592.         (void)PlsrStateTransition(axis,

  1593.                                   PLSR_STATE_ERROR,

  1594.                                   PLSR_TRANSITION_FAULT);

  1595.     }

  1596. }

  1597. 

  1598. static void PlsrMonitorAxisProtection(uint8_t axis)

  1599. {

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

  1601.     PLSR_RESULT result;

  1602. 

  1603.     if ((axisObject->jobValid == 0U)

  1604.         || (PlsrStateIsBusy(axisObject->state) == 0U))

  1605.     {

  1606.         return;

  1607.     }

  1608.     result = PlsrUpdateLimitState(axisObject, &axisObject->job, 1U);

  1609.     if (result != PLSR_RESULT_OK)

  1610.     {

  1611.         axisObject->error = PLSR_ERROR_INTERNAL;

  1612.         axisObject->compatibleErrorCode = 26U;

  1613.         axisObject->compatibleErrorBlock = 0U;

  1614.         PlsrSetStopReason(axisObject, PLSR_STOP_REASON_FAULT);

  1615.         axisObject->done = 0U;

  1616.         PlsrPublishSegmentEvent(axis,

  1617.                                 axisObject,

  1618.                                 PLSR_STOP_REASON_FAULT);

  1619.         PlsrPathTerminate(&axisObject->path);

  1620.         PlsrStopSegmentHardware(axis, axisObject);

  1621.         (void)PlsrStateTransition(axis,

  1622.                                   PLSR_STATE_ERROR,

  1623.                                   PLSR_TRANSITION_FAULT);

  1624.         return;

  1625.     }

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

  1627.         && (axisObject->positiveLimitActive != 0U)

  1628.         && !((axisObject->pendingTerminal == PLSR_STATE_STOPPED)

  1629.              && (axisObject->stopReason

  1630.                  == PLSR_STOP_REASON_LIMIT_POSITIVE)))

  1631.     {

  1632.         (void)PlsrPostEvent(axis, PLSR_EVENT_LIMIT_POSITIVE);

  1633.     }

  1634.     else if ((axisObject->directionPositive == 0U)

  1635.              && (axisObject->negativeLimitActive != 0U)

  1636.              && !((axisObject->pendingTerminal == PLSR_STATE_STOPPED)

  1637.                   && (axisObject->stopReason

  1638.                       == PLSR_STOP_REASON_LIMIT_NEGATIVE)))

  1639.     {

  1640.         (void)PlsrPostEvent(axis, PLSR_EVENT_LIMIT_NEGATIVE);

  1641.     }

  1642. }

  1643. 

  1644. /* 启动当前段的硬件输出与速度曲线（P3a：单轴 PULSE/DIR）。

  1645.  * 由段进入 ACCEL 时调用（任务启动 + 段间推进）。 */

  1646. static PLSR_RESULT PlsrStartSegmentHardware(uint8_t axis,

  1647.                                             PLSR_AXIS *axisObject)

  1648. {

  1649.     const PLSR_JOB_SNAPSHOT *job = &axisObject->job;

  1650.     const PLSR_SEGMENT_SNAPSHOT *segment =

  1651.         &job->segments[axisObject->path.currentSegment - 1U];

  1652.     PLSR_PROFILE_REQUEST profileRequest;

  1653.     PLSR_HW_START_PARAMS params;

  1654.     PLSR_RESULT result;

  1655.     int64_t pulses;

  1656.     int64_t signedPulses;

  1657.     int64_t targetPosition;

  1658.     int64_t nextEquivalentRemainder =

  1659.         axisObject->equivalentCommandRemainder;

  1660.     uint8_t positive;

  1661. 

  1662.     if (job->positioningMode == 0U)

  1663.     {

  1664.         result = PlsrPositionUnitsToPulses(

  1665.             &axisObject->equivalent,

  1666.             segment->pulseOrTarget,

  1667.             axisObject->equivalentCommandRemainder,

  1668.             &signedPulses,

  1669.             &nextEquivalentRemainder);

  1670.         if (result != PLSR_RESULT_OK)

  1671.         {

  1672.             return result;

  1673.         }

  1674.         if (signedPulses == INT64_MIN)

  1675.         {

  1676.             return PLSR_RESULT_POSITION_OVERFLOW;

  1677.         }

  1678.         pulses = (signedPulses < 0) ? -signedPulses : signedPulses;

  1679.         positive = (signedPulses >= 0) ? 1U : 0U;

  1680.     }

  1681.     else

  1682.     {

  1683.         /* 绝对模式使用实际硬件脉冲闭环更新后的逻辑位置计算位移。 */

  1684.         int64_t delta;

  1685. 

  1686.         result = PlsrPositionAbsoluteUnitsToPulses(

  1687.             &axisObject->equivalent,

  1688.             segment->pulseOrTarget,

  1689.             &targetPosition);

  1690.         if (result != PLSR_RESULT_OK)

  1691.         {

  1692.             return result;

  1693.         }

  1694.         if (((axisObject->logicalPosition > 0)

  1695.              && (targetPosition

  1696.                  < INT64_MIN + axisObject->logicalPosition))

  1697.             || ((axisObject->logicalPosition < 0)

  1698.                 && (targetPosition

  1699.                     > INT64_MAX + axisObject->logicalPosition)))

  1700.         {

  1701.             return PLSR_RESULT_POSITION_OVERFLOW;

  1702.         }

  1703.         delta = targetPosition - axisObject->logicalPosition;

  1704.         if (delta == INT64_MIN)

  1705.         {

  1706.             return PLSR_RESULT_POSITION_OVERFLOW;

  1707.         }

  1708. 

  1709.         pulses = (delta < 0) ? -delta : delta;

  1710.         positive = (delta >= 0) ? 1U : 0U;

  1711.     }

  1712. 

  1713.     result = PlsrUpdateLimitState(axisObject, job, 0U);

  1714.     if (result != PLSR_RESULT_OK)

  1715.     {

  1716.         return result;

  1717.     }

  1718.     if ((positive != 0U) && (axisObject->positiveLimitActive != 0U))

  1719.     {

  1720.         return PLSR_RESULT_LIMIT_POSITIVE;

  1721.     }

  1722.     if ((positive == 0U) && (axisObject->negativeLimitActive != 0U))

  1723.     {

  1724.         return PLSR_RESULT_LIMIT_NEGATIVE;

  1725.     }

  1726.     axisObject->segmentEventPublished = 0U;

  1727. 

  1728.     if (pulses == 0)

  1729.     {

  1730.         /* 当量小于一个物理脉冲时保存余数并按零脉冲段推进；不启动PWM。 */

  1731.         axisObject->equivalentCommandRemainder = nextEquivalentRemainder;

  1732.         axisObject->directionPositive = positive;

  1733.         axisObject->segmentAccountedPulses = 0;

  1734.         axisObject->segmentAccountingActive = 0U;

  1735.         PlsrPublishAxis(axis);

  1736.         (void)PlsrPostEvent(axis, PLSR_EVENT_SEGMENT_COMPLETE);

  1737.         return PLSR_RESULT_OK;

  1738.     }

  1739. 

  1740.     (void)memset(&profileRequest, 0, sizeof(profileRequest));

  1741.     profileRequest.targetFrequencyHz = segment->targetFrequency;

  1742.     profileRequest.startFrequencyHz = job->s2.startSpeed;

  1743.     profileRequest.stopFrequencyHz = job->s2.stopSpeed;

  1744.     profileRequest.maxFrequencyHz = job->s2.maximumSpeed;

  1745.     profileRequest.accelSlopeHzPerMs =

  1746.         (job->s2.accelerationMs != 0U)

  1747.             ? job->s2.defaultSpeed / job->s2.accelerationMs

  1748.             : 0UL;

  1749.     profileRequest.decelSlopeHzPerMs =

  1750.         (job->s2.decelerationMs != 0U)

  1751.             ? job->s2.defaultSpeed / job->s2.decelerationMs

  1752.             : 0UL;

  1753.     profileRequest.curveMode = job->s2.curveMode;

  1754. 

  1755.     result = PlsrProfileStart(&axisObject->profile,

  1756.                               &profileRequest,

  1757.                               pulses,

  1758.                               1000U);

  1759.     if (result != PLSR_RESULT_OK)

  1760.     {

  1761.         return result;

  1762.     }

  1763. 

  1764.     params.frequencyHz = job->s2.startSpeed;

  1765.     params.targetPulses = pulses;

  1766.     params.outputMode = (PLSR_OUTPUT_MODE)job->outputMode;

  1767.     params.directionPoint = job->directionPoint;

  1768.     params.directionPositive = positive;

  1769.     params.directionDelayMs = job->s2.directionDelayMs;

  1770.     result = PlsrHwStartPulse(axis, &params);

  1771.     if (result != PLSR_RESULT_OK)

  1772.     {

  1773.         axisObject->profileActive = 0U;

  1774.         axisObject->profileWasAccel = 0U;

  1775.         return result;

  1776.     }

  1777.     axisObject->equivalentCommandRemainder = nextEquivalentRemainder;

  1778.     axisObject->directionPositive = positive;

  1779.     axisObject->segmentAccountedPulses = 0;

  1780.     axisObject->segmentAccountingActive = 1U;

  1781.     axisObject->profileActive = 1U;

  1782.     axisObject->profileWasAccel =

  1783.         (axisObject->profile.phase == PLSR_PROFILE_PHASE_ACCEL) ? 1U : 0U;

  1784.     PlsrPublishAxis(axis);

  1785.     return PLSR_RESULT_OK;

  1786. }

  1787. 

  1788. /* 停止当前段的硬件输出与速度曲线。 */

  1789. static void PlsrStopSegmentHardware(uint8_t axis, PLSR_AXIS *axisObject)

  1790. {

  1791.     PlsrAccountHardwarePulses(axis, axisObject);

  1792.     axisObject->profileActive = 0U;

  1793.     axisObject->profileWasAccel = 0U;

  1794.     (void)PlsrHwStopPulse(axis);

  1795.     PlsrAccountHardwarePulses(axis, axisObject);

  1796.     axisObject->segmentAccountingActive = 0U;

  1797.     PlsrPublishRuntime(axis);

  1798. }

  1799. 

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

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

  1802. {

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

  1804. 

  1805.     switch (action)

  1806.     {

  1807.         case PLSR_PATH_ACTION_NEXT_SEGMENT:

  1808.             /* SEGMENT_COMPLETE 表示上一段输出边界已经结束。统一收口旧段

  1809.              * profile/HAL 后再启动新段；真实 IRQ 与测试注入事件均一致。 */

  1810.             PlsrStopSegmentHardware(axis, axisObject);

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

  1812.             {

  1813.                 (void)PlsrStateTransition(axis,

  1814.                                           PLSR_STATE_ACCEL,

  1815.                                           PLSR_TRANSITION_WAIT_COMPLETE);

  1816.             }

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

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

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

  1820.             {

  1821.                 (void)PlsrStateTransition(axis,

  1822.                                           PLSR_STATE_ACCEL,

  1823.                                           PLSR_TRANSITION_START);

  1824.             }

  1825.             /* 进入新段：重新启动硬件输出与速度曲线。 */

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

  1827.             {

  1828.                 PLSR_RESULT startResult =

  1829.                     PlsrStartSegmentHardware(axis, axisObject);

  1830. 

  1831.                 if ((startResult == PLSR_RESULT_LIMIT_POSITIVE)

  1832.                     || (startResult == PLSR_RESULT_LIMIT_NEGATIVE))

  1833.                 {

  1834.                     axisObject->error =

  1835.                         (startResult == PLSR_RESULT_LIMIT_POSITIVE)

  1836.                             ? PLSR_ERROR_LIMIT_POSITIVE

  1837.                             : PLSR_ERROR_LIMIT_NEGATIVE;

  1838.                     axisObject->compatibleErrorCode =

  1839.                         (startResult == PLSR_RESULT_LIMIT_POSITIVE) ? 5U : 6U;

  1840.                     PlsrSetStopReason(

  1841.                         axisObject,

  1842.                         (startResult == PLSR_RESULT_LIMIT_POSITIVE)

  1843.                             ? PLSR_STOP_REASON_LIMIT_POSITIVE

  1844.                             : PLSR_STOP_REASON_LIMIT_NEGATIVE);

  1845.                     (void)PlsrStateTransition(axis,

  1846.                                               PLSR_STATE_STOPPED,

  1847.                                               PLSR_TRANSITION_STOP);

  1848.                 }

  1849.                 else if (startResult != PLSR_RESULT_OK)

  1850.                 {

  1851.                     axisObject->error = PLSR_ERROR_TIMER_FAULT;

  1852.                     PlsrSetStopReason(axisObject, PLSR_STOP_REASON_FAULT);

  1853.                     axisObject->done = 0U;

  1854.                     (void)PlsrStateTransition(axis,

  1855.                                               PLSR_STATE_ERROR,

  1856.                                               PLSR_TRANSITION_FAULT);

  1857.                 }

  1858.             }

  1859.             break;

  1860. 

  1861.         case PLSR_PATH_ACTION_ENTER_WAIT:

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

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

  1864.             {

  1865.                 (void)PlsrStateTransition(axis,

  1866.                                           PLSR_STATE_WAIT,

  1867.                                           PLSR_TRANSITION_WAIT_BEGIN);

  1868.             }

  1869.             break;

  1870. 

  1871.         case PLSR_PATH_ACTION_JOB_COMPLETE:

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

  1873.             {

  1874.                 axisObject->stopReason = PLSR_STOP_REASON_NORMAL_COMPLETE;

  1875.                 (void)PlsrStateTransition(axis,

  1876.                                           PLSR_STATE_COMPLETED,

  1877.                                           PLSR_TRANSITION_JOB_COMPLETE);

  1878.             }

  1879.             break;

  1880. 

  1881.         case PLSR_PATH_ACTION_YIELD:

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

  1883.             break;

  1884. 

  1885.         case PLSR_PATH_ACTION_ERROR:

  1886.             axisObject->error = PLSR_ERROR_INTERNAL;

  1887.             PlsrSetStopReason(axisObject, PLSR_STOP_REASON_FAULT);

  1888.             axisObject->done = 0U;

  1889.             (void)PlsrStateTransition(axis,

  1890.                                       PLSR_STATE_ERROR,

  1891.                                       PLSR_TRANSITION_FAULT);

  1892.             break;

  1893. 

  1894.         default:

  1895.             break;

  1896.     }

  1897. }

  1898. 

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

  1900. {

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

  1902. 

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

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

  1905.     {

  1906.         (void)PlsrStateTransition(axis,

  1907.                                   PLSR_STATE_STOPPED,

  1908.                                   PLSR_TRANSITION_STOP);

  1909.         return;

  1910.     }

  1911. 

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

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

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

  1915.     {

  1916.         (void)PlsrStateTransition(axis,

  1917.                                   PLSR_STATE_RUN,

  1918.                                   PLSR_TRANSITION_ACCEL_COMPLETE);

  1919.     }

  1920. 

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

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

  1923.     {

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

  1925.         {

  1926.             (void)PlsrStateTransition(axis,

  1927.                                       PLSR_STATE_PAUSED,

  1928.                                       PLSR_TRANSITION_DECEL_COMPLETE);

  1929.         }

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

  1931.         {

  1932.             (void)PlsrStateTransition(axis,

  1933.                                       PLSR_STATE_STOPPED,

  1934.                                       PLSR_TRANSITION_DECEL_COMPLETE);

  1935.         }

  1936.         else

  1937.         {

  1938.             (void)PlsrStateTransition(axis,

  1939.                                       PLSR_STATE_RUN,

  1940.                                       PLSR_TRANSITION_DECEL_COMPLETE);

  1941.         }

  1942.     }

  1943. 

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

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

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

  1947.     {

  1948.         (void)PlsrStateTransition(axis,

  1949.                                   PLSR_STATE_WAIT,

  1950.                                   PLSR_TRANSITION_WAIT_BEGIN);

  1951.     }

  1952. 

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

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

  1955.     {

  1956.         (void)PlsrStateTransition(axis,

  1957.                                   PLSR_STATE_ACCEL,

  1958.                                   PLSR_TRANSITION_WAIT_COMPLETE);

  1959.     }

  1960. 

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

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

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

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

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

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

  1967.     {

  1968.         PLSR_PATH_ACTION action;

  1969. 

  1970.         PlsrPublishSegmentEvent(axis,

  1971.                                 axisObject,

  1972.                                 PLSR_STOP_REASON_NORMAL_COMPLETE);

  1973.         action = PlsrPathOnSegmentDone(&axisObject->path,

  1974.                                        &axisObject->job,

  1975.                                        axisObject->logicalPosition);

  1976.         PlsrApplyPathAction(axis, action);

  1977.     }

  1978. 

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

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

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

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

  1983.     {

  1984.         axisObject->stopReason = PLSR_STOP_REASON_NORMAL_COMPLETE;

  1985.         (void)PlsrStateTransition(axis,

  1986.                                   PLSR_STATE_COMPLETED,

  1987.                                   PLSR_TRANSITION_JOB_COMPLETE);

  1988.     }

  1989. }

  1990. 

  1991. PLSR_RESULT PlsrInit(void)

  1992. {

  1993.     int32_t restoredPosition;

  1994.     uint8_t restoredPositionValid;

  1995.     uint8_t restoredLastBusy;

  1996.     uint8_t axis;

  1997. 

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

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

  2000.     PlsrNextTicket = 0UL;

  2001.     PlsrResourceInit();

  2002.     (void)PlsrHwInit();

  2003.     PlsrInitialized = 1U;

  2004. 

  2005.     restoredPositionValid = PlcDeviceGetRestoredHsdPositionValid();

  2006.     restoredLastBusy = PlcDeviceGetRestoredHsdLastBusy();

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

  2008.     {

  2009.         PlsrAxes[axis].state = PLSR_STATE_UNINITIALIZED;

  2010.         PlsrAxes[axis].pendingTerminal = PLSR_STATE_UNINITIALIZED;

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

  2012.         PlsrLoadAxisEquivalentConfig(axis, &PlsrAxes[axis].equivalent);

  2013.         if (PlcDeviceReadHsdDword(

  2014.                 (uint16_t)(axis * PLSR_HSD_RUNTIME_AXIS_COUNT),

  2015.                 &restoredPosition) == PLC_DEVICE_OK)

  2016.         {

  2017.             PlsrAxes[axis].logicalPosition = restoredPosition;

  2018.         }

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

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

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

  2022.         {

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

  2024.         }

  2025.         if (PlsrStateTransition(axis,

  2026.                                 PLSR_STATE_IDLE,

  2027.                                 PLSR_TRANSITION_INITIALIZED)

  2028.             != PLSR_RESULT_OK)

  2029.         {

  2030.             return PLSR_RESULT_INTERNAL_ERROR;

  2031.         }

  2032.     }

  2033.     return PLSR_RESULT_OK;

  2034. }

  2035. 

  2036. void PlsrProcess(void)

  2037. {

  2038.     PLSR_COMMAND_SLOT slot;

  2039.     uint32_t events;

  2040.     uint8_t processedCommands = 0U;

  2041.     uint8_t criticalAxes = 0U;

  2042.     uint8_t axis;

  2043. 

  2044.     if (PlsrInitialized == 0U)

  2045.     {

  2046.         return;

  2047.     }

  2048. 

  2049.     /* 先合并 ISR 已完成的实际脉冲，确保段完成、STOP或新命令不会在

  2050.      * HAL 计数清零前丢失最后一批位置增量。 */

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

  2052.     {

  2053.         PlsrAccountHardwarePulses(axis, &PlsrAxes[axis]);

  2054.         PlsrMonitorAxisProtection(axis);

  2055.     }

  2056. 

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

  2058.     {

  2059.         events = PlsrTakeEvents(axis, PLSR_EVENT_CRITICAL_MASK);

  2060.         if (events != 0UL)

  2061.         {

  2062.             criticalAxes |= (uint8_t)(1U << axis);

  2063.             PlsrProcessCriticalEvents(axis, events);

  2064.         }

  2065.     }

  2066. 

  2067.     while ((processedCommands < PLSR_COMMAND_QUEUE_DEPTH)

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

  2069.     {

  2070.         if ((slot.command.opcode == PLSR_CMD_RESET_ERROR)

  2071.             && ((criticalAxes & (uint8_t)(1U << slot.command.axis)) != 0U))

  2072.         {

  2073.             PLSR_AXIS *axisObject = &PlsrAxes[slot.command.axis];

  2074. 

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

  2076.             axisObject->lastCommandResult = PLSR_RESULT_BUSY;

  2077.             axisObject->hasLastCommand = 1U;

  2078.             PlsrPublishAxis(slot.command.axis);

  2079.         }

  2080.         else

  2081.         {

  2082.             (void)PlsrExecuteCommand(&slot);

  2083.         }

  2084.         processedCommands++;

  2085.     }

  2086. 

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

  2088.     {

  2089.         events = PlsrTakeEvents(axis,

  2090.                                 PLSR_EVENT_ALL_MASK

  2091.                                     & ~PLSR_EVENT_CRITICAL_MASK);

  2092.         if (events != 0UL)

  2093.         {

  2094.             PlsrProcessNormalEvents(axis, events);

  2095.         }

  2096.     }

  2097. 

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

  2099.      * + 速度曲线推进（P2） + HAL 状态机（DIR 延时）。 */

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

  2101.     {

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

  2103.         PLSR_PATH_ACTION action;

  2104.         uint32_t frequencyHz;

  2105.         uint32_t outputFrequencyHz;

  2106.         uint64_t hardwarePulses;

  2107.         uint64_t remainingPulses;

  2108.         uint8_t profileDone;

  2109.         uint8_t wasAccel;

  2110. 

  2111.         PlsrHwTick(axis);

  2112.         PlsrAccountHardwarePulses(axis, axisObject);

  2113.         /* 首次 AB 内部预热周期不属于用户运动，速度曲线也必须冻结；

  2114.          * 否则低速起步时会在隐藏周期内提前爬升十余个刷新步。 */

  2115.         if (PlsrHwIsAbStartupPriming(axis) != 0U)

  2116.         {

  2117.             continue;

  2118.         }

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

  2120.         {

  2121.             continue;

  2122.         }

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

  2124.                               &axisObject->job,

  2125.                               axisObject->logicalPosition);

  2126.         if (action != PLSR_PATH_ACTION_NONE)

  2127.         {

  2128.             PlsrApplyPathAction(axis, action);

  2129.         }

  2130. 

  2131.         if ((axisObject->profileActive != 0U)

  2132.             && (PlsrHwGetState(axis) != PLSR_HW_STATE_DIR_SETTLING))

  2133.         {

  2134.             /* 虚拟计数校准到硬件实际计数：ARPE 预装载滞后的偏差不累积，

  2135.              * 保证 profile DONE 与硬件计数同步（消除段尾冻结频率收尾）。 */

  2136.             hardwarePulses = (uint64_t)PlsrHwGetEmittedPulses(axis);

  2137.             PlsrProfileSyncPulses(&axisObject->profile, hardwarePulses);

  2138.             wasAccel = axisObject->profileWasAccel;

  2139.             (void)PlsrProfileStep(&axisObject->profile,

  2140.                                   &frequencyHz,

  2141.                                   &profileDone);

  2142.             outputFrequencyHz = frequencyHz;

  2143.             if ((PlsrHwGetState(axis) == PLSR_HW_STATE_RUNNING)

  2144.                 && (wasAccel == 0U)

  2145.                 && (axisObject->pendingTerminal

  2146.                     == PLSR_STATE_UNINITIALIZED)

  2147.                 && ((uint64_t)axisObject->profile.totalPulses

  2148.                     > hardwarePulses + 1UL))

  2149.             {

  2150.                 /* ARR 预装载在当前脉冲结束后生效，因此计算的是

  2151.                  * “当前脉冲之后”剩余的脉冲。用位置反推减速频率，

  2152.                  * 避免 1 ms 时间曲线与预装载滞后造成段尾突停。 */

  2153.                 remainingPulses =

  2154.                     (uint64_t)axisObject->profile.totalPulses

  2155.                     - hardwarePulses - 1UL;

  2156.                 outputFrequencyHz =

  2157.                     PlsrProfileGetBrakingOutputFrequency(

  2158.                         &axisObject->profile,

  2159.                         remainingPulses);

  2160.             }

  2161.             if ((PlsrHwGetState(axis) == PLSR_HW_STATE_PWM_PENDING)

  2162.                 && (axisObject->profile.phase

  2163.                     == PLSR_PROFILE_PHASE_ACCEL))

  2164.             {

  2165.                 outputFrequencyHz =

  2166.                     PlsrProfileGetInitialOutputFrequency(

  2167.                         &axisObject->profile);

  2168.             }

  2169.             if ((profileDone == 0U) || (outputFrequencyHz != 0UL))

  2170.             {

  2171.                 (void)PlsrHwSetFrequency(axis, outputFrequencyHz);

  2172.             }

  2173.             if ((profileDone != 0U)

  2174.                 && (axisObject->pendingTerminal

  2175.                     != PLSR_STATE_UNINITIALIZED))

  2176.             {

  2177.                 (void)PlsrHwSetFrequency(axis, 0UL);

  2178.                 axisObject->profileActive = 0U;

  2179.                 (void)PlsrPostEvent(axis, PLSR_EVENT_DECEL_COMPLETE);

  2180.             }

  2181.             axisObject->profileWasAccel =

  2182.                 (axisObject->profile.phase == PLSR_PROFILE_PHASE_ACCEL)

  2183.                     ? 1U

  2184.                     : 0U;

  2185.             if ((wasAccel != 0U)

  2186.                 && (axisObject->profileWasAccel == 0U)

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

  2188.             {

  2189.                 /* 加速完成（曲线进入匀速/减速）→ 状态机推进到 RUN。 */

  2190.                 (void)PlsrPostEvent(axis, PLSR_EVENT_ACCEL_COMPLETE);

  2191.             }

  2192.         }

  2193.     }

  2194. }

  2195. 

  2196. void PlsrTask(void *argument)

  2197. {

  2198.     (void)argument;

  2199. #ifdef PLSR_HOST_TEST

  2200.     PlsrProcess();

  2201. #else

  2202.     while (1)

  2203.     {

  2204.         PlsrProcess();

  2205.         OSTimeDly(1U);

  2206.     }

  2207. #endif

  2208. }

  2209. 

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

  2211. {

  2212.     PLSR_AXIS *axisObject;

  2213.     uint32_t interruptState;

  2214. 

  2215.     if (axis >= PLSR_AXIS_COUNT)

  2216.     {

  2217.         return PLSR_RESULT_INVALID_AXIS;

  2218.     }

  2219.     if (status == NULL)

  2220.     {

  2221.         return PLSR_RESULT_INVALID_ARGUMENT;

  2222.     }

  2223. 

  2224.     interruptState = PlsrCoreEnterCritical();

  2225.     axisObject = &PlsrAxes[axis];

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

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

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

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

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

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

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

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

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

  2235.     status->taskPulses = axisObject->taskPulses;

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

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

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

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

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

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

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

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

  2244.                                  ? axisObject->lease.directionPoint

  2245.                                  : PLSR_DIRECTION_POINT_NONE;

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

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

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

  2249.     status->positiveLimitActive = axisObject->positiveLimitActive;

  2250.     status->negativeLimitActive = axisObject->negativeLimitActive;

  2251.     status->emergencyLatched = axisObject->emergencyLatched;

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

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

  2254.                                ? axisObject->job.speedClamped

  2255.                                : 0U;

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

  2257.                                ? axisObject->job.segmentCount

  2258.                                : 0U;

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

  2260.                                ? axisObject->job.startSegment

  2261.                                : 0U;

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

  2263.                                  ? PlsrPathGetCurrentSegment(

  2264.                                        &axisObject->path)

  2265.                                  : 0U;

  2266.     PlsrCoreExitCritical(interruptState);

  2267.     return PLSR_RESULT_OK;

  2268. }

  2269. 

  2270. PLSR_RESULT PlsrGetLastParseDetail(uint8_t axis,

  2271.                                    PLSR_PARSE_DETAIL *detail)

  2272. {

  2273.     uint32_t interruptState;

  2274. 

  2275.     if (axis >= PLSR_AXIS_COUNT)

  2276.     {

  2277.         return PLSR_RESULT_INVALID_AXIS;

  2278.     }

  2279.     if (detail == NULL)

  2280.     {

  2281.         return PLSR_RESULT_INVALID_ARGUMENT;

  2282.     }

  2283.     interruptState = PlsrCoreEnterCritical();

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

  2285.     PlsrCoreExitCritical(interruptState);

  2286.     return PLSR_RESULT_OK;

  2287. }