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

1407 lines
50 KiB
Датотека Blame Историја 

  1. #include "plsr_job.h"

  2. #include "plc_device.h"

  3. #include "plsr_address_map.h"

  4. #include <limits.h>

  5. #include <string.h>

  6. 

  7. #define PLSR_S0_HEADER_WORDS            (10UL)

  8. #define PLSR_S0_SEGMENT_WORDS           (10UL)

  9. #define PLSR_S1_WORDS                   (4UL)

  10. #define PLSR_SFD_AXIS_STRIDE             (130U)

  11. #define PLSR_SFD_SET_OFFSET              (50U)

  12. #define PLSR_S2_SET_WORDS                (20U)

  13. #define PLSR_HSD_SET_BASE                (460U)

  14. #define PLSR_TIMER_168MHZ                (168000000UL)

  15. #define PLSR_TIMER_84MHZ                 (84000000UL)

  16. 

  17. static void PlsrSetDetail(PLSR_PARSE_DETAIL *detail,

  18.                           PLSR_RESULT result,

  19.                           PLSR_PARSE_BLOCK block,

  20.                           uint32_t address,

  21.                           int32_t value,

  22.                           uint16_t segment)

  23. {

  24.     if (detail != NULL)

  25.     {

  26.         detail->result = result;

  27.         detail->block = block;

  28.         detail->address = address;

  29.         detail->value = value;

  30.         detail->segment = segment;

  31.     }

  32. }

  33. 

  34. static uint8_t PlsrIsWordDevice(PLSR_DEVICE_TYPE device)

  35. {

  36.     return ((device == PLSR_DEVICE_D) || (device == PLSR_DEVICE_HD)

  37.             || (device == PLSR_DEVICE_FD))

  38.                ? 1U

  39.                : 0U;

  40. }

  41. 

  42. static uint8_t PlsrSourceIsUsable(const PLSR_DATA_SOURCE *source)

  43. {

  44.     return ((source != NULL) && (source->validateWords != NULL)

  45.             && (source->readWord != NULL))

  46.                ? 1U

  47.                : 0U;

  48. }

  49. 

  50. static PLSR_RESULT PlsrValidateRange(const PLSR_DATA_SOURCE *source,

  51.                                      PLSR_DATA_REF reference,

  52.                                      uint32_t wordCount,

  53.                                      PLSR_PARSE_BLOCK block,

  54.                                      PLSR_PARSE_DETAIL *detail)

  55. {

  56.     uint64_t endAddress;

  57. 

  58.     if ((PlsrIsWordDevice(reference.device) == 0U) || (wordCount == 0UL))

  59.     {

  60.         PlsrSetDetail(detail,

  61.                       PLSR_RESULT_DATA_ACCESS,

  62.                       block,

  63.                       reference.address,

  64.                       (int32_t)reference.device,

  65.                       0U);

  66.         return PLSR_RESULT_DATA_ACCESS;

  67.     }

  68.     endAddress = (uint64_t)reference.address + (uint64_t)wordCount - 1ULL;

  69.     if (endAddress > UINT32_MAX)

  70.     {

  71.         PlsrSetDetail(detail,

  72.                       PLSR_RESULT_ADDRESS_OVERFLOW,

  73.                       block,

  74.                       reference.address,

  75.                       (int32_t)wordCount,

  76.                       0U);

  77.         return PLSR_RESULT_ADDRESS_OVERFLOW;

  78.     }

  79.     if (source->validateWords(source->context,

  80.                               reference.device,

  81.                               reference.address,

  82.                               wordCount)

  83.         == 0U)

  84.     {

  85.         PlsrSetDetail(detail,

  86.                       PLSR_RESULT_DATA_ACCESS,

  87.                       block,

  88.                       reference.address,

  89.                       (int32_t)wordCount,

  90.                       0U);

  91.         return PLSR_RESULT_DATA_ACCESS;

  92.     }

  93.     return PLSR_RESULT_OK;

  94. }

  95. 

  96. static PLSR_RESULT PlsrReadWord(const PLSR_DATA_SOURCE *source,

  97.                                 PLSR_DEVICE_TYPE device,

  98.                                 uint32_t address,

  99.                                 uint16_t *value,

  100.                                 PLSR_PARSE_BLOCK block,

  101.                                 uint16_t segment,

  102.                                 PLSR_PARSE_DETAIL *detail)

  103. {

  104.     if ((value == NULL)

  105.         || (source->readWord(source->context, device, address, value) == 0U))

  106.     {

  107.         PlsrSetDetail(detail,

  108.                       PLSR_RESULT_DATA_ACCESS,

  109.                       block,

  110.                       address,

  111.                       0,

  112.                       segment);

  113.         return PLSR_RESULT_DATA_ACCESS;

  114.     }

  115.     return PLSR_RESULT_OK;

  116. }

  117. 

  118. static PLSR_RESULT PlsrReadInt32(const PLSR_DATA_SOURCE *source,

  119.                                  PLSR_DEVICE_TYPE device,

  120.                                  uint32_t address,

  121.                                  int32_t *value,

  122.                                  PLSR_PARSE_BLOCK block,

  123.                                  uint16_t segment,

  124.                                  PLSR_PARSE_DETAIL *detail)

  125. {

  126.     uint16_t lowWord;

  127.     uint16_t highWord;

  128.     PLSR_RESULT result;

  129. 

  130.     if (address == UINT32_MAX)

  131.     {

  132.         PlsrSetDetail(detail,

  133.                       PLSR_RESULT_ADDRESS_OVERFLOW,

  134.                       block,

  135.                       address,

  136.                       2,

  137.                       segment);

  138.         return PLSR_RESULT_ADDRESS_OVERFLOW;

  139.     }

  140.     result = PlsrReadWord(source,

  141.                           device,

  142.                           address,

  143.                           &lowWord,

  144.                           block,

  145.                           segment,

  146.                           detail);

  147.     if (result != PLSR_RESULT_OK)

  148.     {

  149.         return result;

  150.     }

  151.     result = PlsrReadWord(source,

  152.                           device,

  153.                           address + 1UL,

  154.                           &highWord,

  155.                           block,

  156.                           segment,

  157.                           detail);

  158.     if (result != PLSR_RESULT_OK)

  159.     {

  160.         return result;

  161.     }

  162.     *value = (int32_t)(((uint32_t)highWord << 16U) | (uint32_t)lowWord);

  163.     return PLSR_RESULT_OK;

  164. }

  165. 

  166. static uint8_t PlsrBlocksOverlap(PLSR_DATA_REF first,

  167.                                  uint32_t firstWords,

  168.                                  PLSR_DATA_REF second,

  169.                                  uint32_t secondWords)

  170. {

  171.     uint64_t firstEnd;

  172.     uint64_t secondEnd;

  173. 

  174.     if (first.device != second.device)

  175.     {

  176.         return 0U;

  177.     }

  178.     firstEnd = (uint64_t)first.address + (uint64_t)firstWords - 1ULL;

  179.     secondEnd = (uint64_t)second.address + (uint64_t)secondWords - 1ULL;

  180.     return (((uint64_t)first.address <= secondEnd)

  181.             && ((uint64_t)second.address <= firstEnd))

  182.                ? 1U

  183.                : 0U;

  184. }

  185. 

  186. static PLSR_RESULT PlsrReadFixedWord(uint8_t useHsd,

  187.                                      uint16_t address,

  188.                                      uint16_t *value,

  189.                                      PLSR_PARSE_DETAIL *detail)

  190. {

  191.     PLC_DEVICE_RESULT deviceResult;

  192. 

  193.     deviceResult = (useHsd != 0U) ? PlcDeviceReadHsd(address, value)

  194.                                   : PlcDeviceReadSfd(address, value);

  195.     if (deviceResult != PLC_DEVICE_OK)

  196.     {

  197.         PlsrSetDetail(detail,

  198.                       PLSR_RESULT_INVALID_S2,

  199.                       PLSR_PARSE_BLOCK_S2,

  200.                       address,

  201.                       0,

  202.                       0U);

  203.         return PLSR_RESULT_INVALID_S2;

  204.     }

  205.     return PLSR_RESULT_OK;

  206. }

  207. 

  208. static PLSR_RESULT PlsrReadFixedDword(uint8_t useHsd,

  209.                                       uint16_t address,

  210.                                       uint32_t *value,

  211.                                       PLSR_PARSE_DETAIL *detail)

  212. {

  213.     uint16_t lowWord;

  214.     uint16_t highWord;

  215.     PLSR_RESULT result;

  216. 

  217.     result = PlsrReadFixedWord(useHsd, address, &lowWord, detail);

  218.     if (result != PLSR_RESULT_OK)

  219.     {

  220.         return result;

  221.     }

  222.     result = PlsrReadFixedWord(useHsd,

  223.                                (uint16_t)(address + 1U),

  224.                                &highWord,

  225.                                detail);

  226.     if (result != PLSR_RESULT_OK)

  227.     {

  228.         return result;

  229.     }

  230.     *value = ((uint32_t)highWord << 16U) | (uint32_t)lowWord;

  231.     return PLSR_RESULT_OK;

  232. }

  233. 

  234. PLSR_RESULT PlsrCalculateTimerDivider(uint32_t timerClockHz,

  235.                                       uint32_t frequencyHz,

  236.                                       uint16_t *psc,

  237.                                       uint16_t *arr)

  238. {

  239.     uint64_t minimumDivider;

  240.     uint64_t periodTicks;

  241. 

  242.     if ((timerClockHz == 0UL) || (frequencyHz == 0UL) || (psc == NULL)

  243.         || (arr == NULL))

  244.     {

  245.         return PLSR_RESULT_INVALID_ARGUMENT;

  246.     }

  247. 

  248.     minimumDivider = ((uint64_t)timerClockHz

  249.                       + ((uint64_t)frequencyHz * 65536ULL) - 1ULL)

  250.                      / ((uint64_t)frequencyHz * 65536ULL);

  251.     if (minimumDivider == 0ULL)

  252.     {

  253.         minimumDivider = 1ULL;

  254.     }

  255.     if (minimumDivider > 65536ULL)

  256.     {

  257.         return PLSR_RESULT_DIVIDER_UNREPRESENTABLE;

  258.     }

  259.     periodTicks = ((uint64_t)timerClockHz

  260.                    + ((uint64_t)frequencyHz * minimumDivider) / 2ULL)

  261.                   / ((uint64_t)frequencyHz * minimumDivider);

  262.     if ((periodTicks < 2ULL) || (periodTicks > 65536ULL))

  263.     {

  264.         return PLSR_RESULT_DIVIDER_UNREPRESENTABLE;

  265.     }

  266.     *psc = (uint16_t)(minimumDivider - 1ULL);

  267.     *arr = (uint16_t)(periodTicks - 1ULL);

  268.     return PLSR_RESULT_OK;

  269. }

  270. 

  271. static PLSR_RESULT PlsrValidateFrequencyDivider(

  272.     const PLSR_JOB_SNAPSHOT *snapshot,

  273.     uint32_t frequency,

  274.     PLSR_PARSE_DETAIL *detail,

  275.     uint16_t segment)

  276. {

  277.     uint16_t psc;

  278.     uint16_t arr;

  279.     PLSR_RESULT result;

  280. 

  281.     result = PlsrCalculateTimerDivider(snapshot->timerClockHz,

  282.                                        frequency,

  283.                                        &psc,

  284.                                        &arr);

  285.     if ((result == PLSR_RESULT_OK)

  286.         && (snapshot->pairedTimerClockHz != 0UL))

  287.     {

  288.         result = PlsrCalculateTimerDivider(snapshot->pairedTimerClockHz,

  289.                                            frequency,

  290.                                            &psc,

  291.                                            &arr);

  292.     }

  293.     if (result != PLSR_RESULT_OK)

  294.     {

  295.         PlsrSetDetail(detail,

  296.                       PLSR_RESULT_DIVIDER_UNREPRESENTABLE,

  297.                       PLSR_PARSE_BLOCK_S0,

  298.                       snapshot->s0.address

  299.                           + (uint32_t)segment * PLSR_S0_SEGMENT_WORDS,

  300.                       (int32_t)frequency,

  301.                       segment);

  302.         return PLSR_RESULT_DIVIDER_UNREPRESENTABLE;

  303.     }

  304.     return PLSR_RESULT_OK;

  305. }

  306. 

  307. static PLSR_RESULT PlsrResolveOperand(const PLSR_CALL *call,

  308.                                       const PLSR_VALUE_OPERAND *operand,

  309.                                       int32_t *value,

  310.                                       PLSR_PARSE_DETAIL *detail)

  311. {

  312.     PLSR_RESULT result;

  313. 

  314.     if (operand->type == PLSR_OPERAND_CONSTANT)

  315.     {

  316.         *value = operand->constant;

  317.         return PLSR_RESULT_OK;

  318.     }

  319.     if ((operand->type != PLSR_OPERAND_DATA)

  320.         || (PlsrIsWordDevice(operand->data.device) == 0U))

  321.     {

  322.         PlsrSetDetail(detail,

  323.                       PLSR_RESULT_INVALID_S2,

  324.                       PLSR_PARSE_BLOCK_S2,

  325.                       operand->data.address,

  326.                       (int32_t)operand->type,

  327.                       0U);

  328.         return PLSR_RESULT_INVALID_S2;

  329.     }

  330.     result = PlsrValidateRange(&call->source,

  331.                                operand->data,

  332.                                2UL,

  333.                                PLSR_PARSE_BLOCK_S2,

  334.                                detail);

  335.     if (result != PLSR_RESULT_OK)

  336.     {

  337.         return result;

  338.     }

  339.     return PlsrReadInt32(&call->source,

  340.                          operand->data.device,

  341.                          operand->data.address,

  342.                          value,

  343.                          PLSR_PARSE_BLOCK_S2,

  344.                          0U,

  345.                          detail);

  346. }

  347. 

  348. static PLSR_RESULT PlsrLoadS2(const PLSR_CALL *call,

  349.                               PLSR_JOB_SNAPSHOT *snapshot,

  350.                               PLSR_PARSE_DETAIL *detail)

  351. {

  352.     uint16_t commonBase;

  353.     uint16_t setBase;

  354.     uint16_t word;

  355.     int32_t selectedSet;

  356.     uint8_t useHsd;

  357.     PLSR_RESULT result;

  358. 

  359.     result = PlsrResolveOperand(call, &call->s2, &selectedSet, detail);

  360.     if (result != PLSR_RESULT_OK)

  361.     {

  362.         return result;

  363.     }

  364.     if ((selectedSet < 0) || (selectedSet > 4))

  365.     {

  366.         PlsrSetDetail(detail,

  367.                       PLSR_RESULT_INVALID_S2,

  368.                       PLSR_PARSE_BLOCK_S2,

  369.                       call->s2.data.address,

  370.                       selectedSet,

  371.                       0U);

  372.         return PLSR_RESULT_INVALID_S2;

  373.     }

  374.     snapshot->s2Set = (uint8_t)selectedSet;

  375.     commonBase = (uint16_t)(PLSR_SFD_CONFIG_START

  376.                             + (uint16_t)call->dAxis

  377.                                   * PLSR_SFD_AXIS_STRIDE);

  378.     if (snapshot->s2Set == 0U)

  379.     {

  380.         useHsd = 1U;

  381.         setBase = (uint16_t)(PLSR_HSD_SET_BASE

  382.                              + (uint16_t)call->dAxis * PLSR_S2_SET_WORDS);

  383.     }

  384.     else

  385.     {

  386.         useHsd = 0U;

  387.         setBase = (uint16_t)(commonBase + PLSR_SFD_SET_OFFSET

  388.                              + (uint16_t)(snapshot->s2Set - 1U)

  389.                                    * PLSR_S2_SET_WORDS);

  390.     }

  391. 

  392.     result = PlsrReadFixedDword(useHsd,

  393.                                 setBase,

  394.                                 &snapshot->s2.defaultSpeed,

  395.                                 detail);

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

  397.     result = PlsrReadFixedWord(useHsd,

  398.                                (uint16_t)(setBase + 2U),

  399.                                &snapshot->s2.accelerationMs,

  400.                                detail);

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

  402.     result = PlsrReadFixedWord(useHsd,

  403.                                (uint16_t)(setBase + 3U),

  404.                                &snapshot->s2.decelerationMs,

  405.                                detail);

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

  407.     result = PlsrReadFixedWord(useHsd,

  408.                                (uint16_t)(setBase + 4U),

  409.                                &snapshot->s2.gapAccelerationMs,

  410.                                detail);

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

  412.     result = PlsrReadFixedWord(useHsd,

  413.                                (uint16_t)(setBase + 5U),

  414.                                &word,

  415.                                detail);

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

  417.     snapshot->s2.curveMode = (uint8_t)(word & 0x03U);

  418.     result = PlsrReadFixedDword(useHsd,

  419.                                 (uint16_t)(setBase + 6U),

  420.                                 &snapshot->s2.maximumSpeed,

  421.                                 detail);

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

  423.     result = PlsrReadFixedDword(useHsd,

  424.                                 (uint16_t)(setBase + 8U),

  425.                                 &snapshot->s2.startSpeed,

  426.                                 detail);

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

  428.     result = PlsrReadFixedDword(useHsd,

  429.                                 (uint16_t)(setBase + 10U),

  430.                                 &snapshot->s2.stopSpeed,

  431.                                 detail);

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

  433.     result = PlsrReadFixedWord(useHsd,

  434.                                (uint16_t)(setBase + 12U),

  435.                                &word,

  436.                                detail);

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

  438.     if ((word < 1U) || (word > 100U))

  439.     {

  440.         PlsrSetDetail(detail,

  441.                       PLSR_RESULT_INVALID_S2,

  442.                       PLSR_PARSE_BLOCK_S2,

  443.                       (uint16_t)(setBase + 12U),

  444.                       word,

  445.                       0U);

  446.         return PLSR_RESULT_INVALID_S2;

  447.     }

  448.     snapshot->s2.follow = (uint8_t)word;

  449.     result = PlsrReadFixedWord(useHsd,

  450.                                (uint16_t)(setBase + 13U),

  451.                                &word,

  452.                                detail);

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

  454.     if (word > 100U)

  455.     {

  456.         PlsrSetDetail(detail,

  457.                       PLSR_RESULT_INVALID_S2,

  458.                       PLSR_PARSE_BLOCK_S2,

  459.                       (uint16_t)(setBase + 13U),

  460.                       word,

  461.                       0U);

  462.         return PLSR_RESULT_INVALID_S2;

  463.     }

  464.     snapshot->s2.feedforwardPercent = (uint8_t)word;

  465.     result = PlsrReadFixedWord(useHsd,

  466.                                (uint16_t)(setBase + 14U),

  467.                                &word,

  468.                                detail);

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

  470.     snapshot->s2.refreshCode = (uint8_t)(word & 0x03U);

  471.     result = PlsrReadFixedDword(useHsd,

  472.                                 (uint16_t)(setBase + 16U),

  473.                                 &snapshot->s2.zrnHighSpeed,

  474.                                 detail);

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

  476.     result = PlsrReadFixedDword(useHsd,

  477.                                 (uint16_t)(setBase + 18U),

  478.                                 &snapshot->s2.zrnCrawlSpeed,

  479.                                 detail);

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

  481. 

  482.     result = PlsrReadFixedWord(0U, commonBase, &word, detail);

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

  484.     snapshot->directionActiveHigh = ((word & (1U << 1U)) != 0U) ? 1U : 0U;

  485.     snapshot->equivalent.unitCode = (uint8_t)((word >> 8U) & 0x07U);

  486.     if (PlsrPositionUnitCodeIsValid(snapshot->equivalent.unitCode) == 0U)

  487.     {

  488.         PlsrSetDetail(detail,

  489.                       PLSR_RESULT_INVALID_S2,

  490.                       PLSR_PARSE_BLOCK_S2,

  491.                       commonBase,

  492.                       snapshot->equivalent.unitCode,

  493.                       0U);

  494.         return PLSR_RESULT_INVALID_S2;

  495.     }

  496.     result = PlsrReadFixedDword(0U,

  497.                                 (uint16_t)(commonBase + 2U),

  498.                                 &snapshot->equivalent.pulsesPerRevolution,

  499.                                 detail);

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

  501.     result = PlsrReadFixedDword(0U,

  502.                                 (uint16_t)(commonBase + 4U),

  503.                                 &snapshot->equivalent.movementPerRevolution,

  504.                                 detail);

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

  506.     if (PlsrPositionValidateEquivalent(&snapshot->equivalent)

  507.         != PLSR_RESULT_OK)

  508.     {

  509.         uint16_t invalidAddress =

  510.             (snapshot->equivalent.pulsesPerRevolution == 0UL)

  511.                 ? (uint16_t)(commonBase + 2U)

  512.                 : (uint16_t)(commonBase + 4U);

  513. 

  514.         PlsrSetDetail(detail,

  515.                       PLSR_RESULT_INVALID_S2,

  516.                       PLSR_PARSE_BLOCK_S2,

  517.                       invalidAddress,

  518.                       0,

  519.                       0U);

  520.         return PLSR_RESULT_INVALID_S2;

  521.     }

  522.     if (call->outputModeOverride == PLSR_OUTPUT_MODE_FROM_SFD)

  523.     {

  524.         snapshot->outputMode = ((word & (1U << 13U)) != 0U)

  525.                                    ? (uint8_t)PLSR_OUTPUT_AB

  526.                                    : (uint8_t)PLSR_OUTPUT_PULSE_DIR;

  527.     }

  528.     else if (call->outputModeOverride <= (uint8_t)PLSR_OUTPUT_CW_CCW)

  529.     {

  530.         snapshot->outputMode = call->outputModeOverride;

  531.     }

  532.     else

  533.     {

  534.         PlsrSetDetail(detail,

  535.                       PLSR_RESULT_INVALID_RESOURCE,

  536.                       PLSR_PARSE_BLOCK_OUTPUT,

  537.                       commonBase,

  538.                       call->outputModeOverride,

  539.                       0U);

  540.         return PLSR_RESULT_INVALID_RESOURCE;

  541.     }

  542.     result = PlsrReadFixedWord(0U,

  543.                                (uint16_t)(commonBase + 6U),

  544.                                &word,

  545.                                detail);

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

  547.     if (word > UINT8_MAX)

  548.     {

  549.         PlsrSetDetail(detail,

  550.                       PLSR_RESULT_INVALID_RESOURCE,

  551.                       PLSR_PARSE_BLOCK_OUTPUT,

  552.                       (uint16_t)(commonBase + 6U),

  553.                       word,

  554.                       0U);

  555.         return PLSR_RESULT_INVALID_RESOURCE;

  556.     }

  557.     snapshot->directionPoint = (uint8_t)word;

  558.     result = PlsrReadFixedWord(0U,

  559.                                (uint16_t)(commonBase + 7U),

  560.                                &snapshot->s2.directionDelayMs,

  561.                                detail);

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

  563. 

  564.     if ((snapshot->s2.maximumSpeed < PLSR_FREQUENCY_MIN_HZ)

  565.         || (snapshot->s2.maximumSpeed > PLSR_FREQUENCY_MAX_HZ)

  566.         || (snapshot->s2.curveMode > 2U) || (snapshot->s2.follow < 1U)

  567.         || (snapshot->s2.follow > 100U)

  568.         || (snapshot->s2.feedforwardPercent > 100U)

  569.         || ((snapshot->s2.refreshCode != 0U)

  570.             && (snapshot->s2.refreshCode != 2U)))

  571.     {

  572.         PlsrSetDetail(detail,

  573.                       PLSR_RESULT_INVALID_S2,

  574.                       PLSR_PARSE_BLOCK_S2,

  575.                       setBase,

  576.                       (int32_t)snapshot->s2.maximumSpeed,

  577.                       0U);

  578.         return PLSR_RESULT_INVALID_S2;

  579.     }

  580.     if (snapshot->s2.startSpeed > snapshot->s2.maximumSpeed)

  581.     {

  582.         snapshot->s2.startSpeed = snapshot->s2.maximumSpeed;

  583.         snapshot->speedClamped = 1U;

  584.     }

  585.     if (snapshot->s2.stopSpeed > snapshot->s2.maximumSpeed)

  586.     {

  587.         snapshot->s2.stopSpeed = snapshot->s2.maximumSpeed;

  588.         snapshot->speedClamped = 1U;

  589.     }

  590.     snapshot->inputDefaultSpeed = snapshot->s2.defaultSpeed;

  591.     snapshot->inputMaximumSpeed = snapshot->s2.maximumSpeed;

  592.     return PLSR_RESULT_OK;

  593. }

  594. 

  595. static PLSR_RESULT PlsrValidateVariableReference(

  596.     const PLSR_CALL *call,

  597.     uint8_t sourceCode,

  598.     int32_t addressValue,

  599.     uint8_t bitReference,

  600.     int32_t *currentValue,

  601.     PLSR_PARSE_BLOCK block,

  602.     uint16_t segment,

  603.     PLSR_PARSE_DETAIL *detail)

  604. {

  605.     PLSR_DEVICE_TYPE device;

  606.     PLSR_DATA_REF reference;

  607.     uint8_t bitValue;

  608.     PLSR_RESULT result;

  609. 

  610.     if ((sourceCode == 0U) || (sourceCode > 6U) || (addressValue < 0))

  611.     {

  612.         PlsrSetDetail(detail,

  613.                       (block == PLSR_PARSE_BLOCK_S0)

  614.                           ? PLSR_RESULT_INVALID_WAIT

  615.                           : PLSR_RESULT_DATA_ACCESS,

  616.                       block,

  617.                       (uint32_t)addressValue,

  618.                       sourceCode,

  619.                       segment);

  620.         return (block == PLSR_PARSE_BLOCK_S0) ? PLSR_RESULT_INVALID_WAIT

  621.                                               : PLSR_RESULT_DATA_ACCESS;

  622.     }

  623.     device = (PLSR_DEVICE_TYPE)(sourceCode - 1U);

  624.     if (bitReference != 0U)

  625.     {

  626.         if ((device < PLSR_DEVICE_X) || (call->source.readBit == NULL)

  627.             || (call->source.readBit(call->source.context,

  628.                                      device,

  629.                                      (uint32_t)addressValue,

  630.                                      &bitValue)

  631.                 == 0U))

  632.         {

  633.             PlsrSetDetail(detail,

  634.                           PLSR_RESULT_INVALID_WAIT,

  635.                           block,

  636.                           (uint32_t)addressValue,

  637.                           sourceCode,

  638.                           segment);

  639.             return PLSR_RESULT_INVALID_WAIT;

  640.         }

  641.         *currentValue = (int32_t)bitValue;

  642.         return PLSR_RESULT_OK;

  643.     }

  644. 

  645.     if (PlsrIsWordDevice(device) == 0U)

  646.     {

  647.         PlsrSetDetail(detail,

  648.                       PLSR_RESULT_INVALID_WAIT,

  649.                       block,

  650.                       (uint32_t)addressValue,

  651.                       sourceCode,

  652.                       segment);

  653.         return PLSR_RESULT_INVALID_WAIT;

  654.     }

  655.     reference.device = device;

  656.     reference.address = (uint32_t)addressValue;

  657.     result = PlsrValidateRange(&call->source,

  658.                                reference,

  659.                                2UL,

  660.                                block,

  661.                                detail);

  662.     if (result != PLSR_RESULT_OK)

  663.     {

  664.         return result;

  665.     }

  666.     return PlsrReadInt32(&call->source,

  667.                          device,

  668.                          reference.address,

  669.                          currentValue,

  670.                          block,

  671.                          segment,

  672.                          detail);

  673. }

  674. 

  675. static PLSR_RESULT PlsrValidateWait(const PLSR_CALL *call,

  676.                                     PLSR_SEGMENT_SNAPSHOT *segmentData,

  677.                                     uint16_t segment,

  678.                                     PLSR_PARSE_DETAIL *detail)

  679. {

  680.     int32_t currentValue;

  681.     PLSR_RESULT result;

  682. 

  683.     if ((segmentData->waitCondition > PLSR_WAIT_EXT_OR_COMPLETE)

  684.         || (segmentData->waitSource > PLSR_VALUE_HM))

  685.     {

  686.         goto invalidWait;

  687.     }

  688.     if (segmentData->waitCondition == PLSR_WAIT_PULSE_COMPLETE)

  689.     {

  690.         if (segmentData->waitSource != PLSR_VALUE_CONSTANT)

  691.         {

  692.             goto invalidWait;

  693.         }

  694.         return PLSR_RESULT_OK;

  695.     }

  696.     if ((segmentData->waitCondition == PLSR_WAIT_TIME)

  697.         || (segmentData->waitCondition == PLSR_WAIT_ACT_TIME))

  698.     {

  699.         if (segmentData->waitSource == PLSR_VALUE_CONSTANT)

  700.         {

  701.             currentValue = segmentData->waitValueOrAddress;

  702.         }

  703.         else

  704.         {

  705.             if (segmentData->waitSource > PLSR_VALUE_FD)

  706.             {

  707.                 goto invalidWait;

  708.             }

  709.             result = PlsrValidateVariableReference(call,

  710.                                                    segmentData->waitSource,

  711.                                                    segmentData->waitValueOrAddress,

  712.                                                    0U,

  713.                                                    &currentValue,

  714.                                                    PLSR_PARSE_BLOCK_S0,

  715.                                                    segment,

  716.                                                    detail);

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

  718.         }

  719.         if (currentValue < 0) goto invalidWait;

  720.         return PLSR_RESULT_OK;

  721.     }

  722.     if (segmentData->waitCondition == PLSR_WAIT_SIGNAL)

  723.     {

  724.         if ((segmentData->waitSource < PLSR_VALUE_X)

  725.             || (segmentData->waitSource > PLSR_VALUE_HM))

  726.         {

  727.             goto invalidWait;

  728.         }

  729.     }

  730.     else if ((segmentData->waitCondition == PLSR_WAIT_EXT)

  731.              || (segmentData->waitCondition == PLSR_WAIT_EXT_OR_COMPLETE))

  732.     {

  733.         if (segmentData->waitSource != PLSR_VALUE_X)

  734.         {

  735.             goto invalidWait;

  736.         }

  737.     }

  738.     result = PlsrValidateVariableReference(call,

  739.                                            segmentData->waitSource,

  740.                                            segmentData->waitValueOrAddress,

  741.                                            1U,

  742.                                            &currentValue,

  743.                                            PLSR_PARSE_BLOCK_S0,

  744.                                            segment,

  745.                                            detail);

  746.     return result;

  747. 

  748. invalidWait:

  749.     PlsrSetDetail(detail,

  750.                   PLSR_RESULT_INVALID_WAIT,

  751.                   PLSR_PARSE_BLOCK_S0,

  752.                   call->s0.address

  753.                       + (uint32_t)segment * PLSR_S0_SEGMENT_WORDS + 4UL,

  754.                   ((int32_t)segmentData->waitCondition << 8)

  755.                       | segmentData->waitSource,

  756.                   segment);

  757.     return PLSR_RESULT_INVALID_WAIT;

  758. }

  759. 

  760. static PLSR_RESULT PlsrValidateJump(const PLSR_CALL *call,

  761.                                     const PLSR_JOB_SNAPSHOT *snapshot,

  762.                                     PLSR_SEGMENT_SNAPSHOT *segmentData,

  763.                                     uint16_t segment,

  764.                                     int32_t *resolvedJump,

  765.                                     PLSR_PARSE_DETAIL *detail)

  766. {

  767.     PLSR_RESULT result;

  768. 

  769.     if (segmentData->jumpSource > PLSR_VALUE_FD)

  770.     {

  771.         goto invalidJump;

  772.     }

  773.     if (segmentData->jumpSource == PLSR_VALUE_CONSTANT)

  774.     {

  775.         *resolvedJump = segmentData->jumpValueOrAddress;

  776.     }

  777.     else

  778.     {

  779.         result = PlsrValidateVariableReference(call,

  780.                                                segmentData->jumpSource,

  781.                                                segmentData->jumpValueOrAddress,

  782.                                                0U,

  783.                                                resolvedJump,

  784.                                                PLSR_PARSE_BLOCK_NONE,

  785.                                                segment,

  786.                                                detail);

  787.         if (result != PLSR_RESULT_OK)

  788.         {

  789.             PlsrSetDetail(detail,

  790.                           PLSR_RESULT_INVALID_JUMP,

  791.                           PLSR_PARSE_BLOCK_S0,

  792.                           (uint32_t)segmentData->jumpValueOrAddress,

  793.                           segmentData->jumpSource,

  794.                           segment);

  795.             return PLSR_RESULT_INVALID_JUMP;

  796.         }

  797.     }

  798.     if ((*resolvedJump < 0)

  799.         || (*resolvedJump > (int32_t)snapshot->segmentCount))

  800.     {

  801.         goto invalidJump;

  802.     }

  803.     if (*resolvedJump == (int32_t)segment)

  804.     {

  805.         segmentData->flags |= PLSR_SEGMENT_FLAG_SELF_LOOP;

  806.     }

  807.     return PLSR_RESULT_OK;

  808. 

  809. invalidJump:

  810.     PlsrSetDetail(detail,

  811.                   PLSR_RESULT_INVALID_JUMP,

  812.                   PLSR_PARSE_BLOCK_S0,

  813.                   call->s0.address

  814.                       + (uint32_t)segment * PLSR_S0_SEGMENT_WORDS + 7UL,

  815.                   *resolvedJump,

  816.                   segment);

  817.     return PLSR_RESULT_INVALID_JUMP;

  818. }

  819. 

  820. static PLSR_RESULT PlsrCheckConstantPath(PLSR_JOB_SNAPSHOT *snapshot,

  821.                                          PLSR_PARSE_DETAIL *detail)

  822. {

  823.     uint8_t visited[PLSR_MAX_SEGMENTS];

  824.     uint16_t segment = snapshot->startSegment;

  825.     int32_t next;

  826. 

  827.     (void)memset(visited, 0, sizeof(visited));

  828.     while ((segment >= 1U) && (segment <= snapshot->segmentCount))

  829.     {

  830.         if (visited[segment - 1U] != 0U)

  831.         {

  832.             PlsrSetDetail(detail,

  833.                           PLSR_RESULT_PATH_CYCLE,

  834.                           PLSR_PARSE_BLOCK_S0,

  835.                           snapshot->s0.address

  836.                               + (uint32_t)segment * PLSR_S0_SEGMENT_WORDS

  837.                               + 8UL,

  838.                           segment,

  839.                           segment);

  840.             return PLSR_RESULT_PATH_CYCLE;

  841.         }

  842.         visited[segment - 1U] = 1U;

  843.         if (snapshot->segments[segment - 1U].jumpSource

  844.             != PLSR_VALUE_CONSTANT)

  845.         {

  846.             return PLSR_RESULT_OK;

  847.         }

  848.         next = snapshot->segments[segment - 1U].jumpValueOrAddress;

  849.         if (next == (int32_t)segment)

  850.         {

  851.             snapshot->hasSelfLoop = 1U;

  852.             return PLSR_RESULT_OK;

  853.         }

  854.         if (next == 0)

  855.         {

  856.             if (segment == snapshot->segmentCount)

  857.             {

  858.                 return PLSR_RESULT_OK;

  859.             }

  860.             segment++;

  861.         }

  862.         else

  863.         {

  864.             segment = (uint16_t)next;

  865.         }

  866.     }

  867.     return PLSR_RESULT_OK;

  868. }

  869. 

  870. static PLSR_RESULT PlsrCheckInitialPosition(

  871.     PLSR_JOB_SNAPSHOT *snapshot,

  872.     const PLSR_PARSE_CONTEXT *context,

  873.     PLSR_PARSE_DETAIL *detail)

  874. {

  875.     uint8_t visited[PLSR_MAX_SEGMENTS];

  876.     int64_t position = context->logicalPosition;

  877.     int64_t movement;

  878.     int64_t targetPosition;

  879.     int64_t remainder = 0;

  880.     int32_t next;

  881.     uint16_t segment = snapshot->startSegment;

  882.     PLSR_RESULT result;

  883. 

  884.     if ((snapshot->positioningMode != 0U) && (context->positionValid == 0U))

  885.     {

  886.         PlsrSetDetail(detail,

  887.                       PLSR_RESULT_POSITION_INVALID,

  888.                       PLSR_PARSE_BLOCK_POSITION,

  889.                       snapshot->s1.address,

  890.                       1,

  891.                       0U);

  892.         return PLSR_RESULT_POSITION_INVALID;

  893.     }

  894. 

  895.     (void)memset(visited, 0, sizeof(visited));

  896.     while ((segment >= 1U) && (segment <= snapshot->segmentCount)

  897.            && (visited[segment - 1U] == 0U))

  898.     {

  899.         PLSR_SEGMENT_SNAPSHOT *segmentData = &snapshot->segments[segment - 1U];

  900.         visited[segment - 1U] = 1U;

  901.         if (snapshot->positioningMode == 0U)

  902.         {

  903.             result = PlsrPositionUnitsToPulses(&snapshot->equivalent,

  904.                                                 segmentData->pulseOrTarget,

  905.                                                 remainder,

  906.                                                 &movement,

  907.                                                 &remainder);

  908.             if (result != PLSR_RESULT_OK)

  909.             {

  910.                 PlsrSetDetail(detail,

  911.                               PLSR_RESULT_POSITION_OVERFLOW,

  912.                               PLSR_PARSE_BLOCK_POSITION,

  913.                               snapshot->s0.address

  914.                                   + (uint32_t)segment

  915.                                         * PLSR_S0_SEGMENT_WORDS

  916.                                   + 2UL,

  917.                               segmentData->pulseOrTarget,

  918.                               segment);

  919.                 return PLSR_RESULT_POSITION_OVERFLOW;

  920.             }

  921.             if (((movement > 0) && (position > INT64_MAX - movement))

  922.                 || ((movement < 0) && (position < INT64_MIN - movement)))

  923.             {

  924.                 PlsrSetDetail(detail,

  925.                               PLSR_RESULT_POSITION_OVERFLOW,

  926.                               PLSR_PARSE_BLOCK_POSITION,

  927.                               snapshot->s0.address

  928.                                   + (uint32_t)segment

  929.                                         * PLSR_S0_SEGMENT_WORDS

  930.                                   + 2UL,

  931.                               movement,

  932.                               segment);

  933.                 return PLSR_RESULT_POSITION_OVERFLOW;

  934.             }

  935.             position += movement;

  936.         }

  937.         else

  938.         {

  939.             result = PlsrPositionAbsoluteUnitsToPulses(

  940.                 &snapshot->equivalent,

  941.                 segmentData->pulseOrTarget,

  942.                 &targetPosition);

  943.             if (result != PLSR_RESULT_OK)

  944.             {

  945.                 return PLSR_RESULT_POSITION_OVERFLOW;

  946.             }

  947.             movement = (targetPosition > position)

  948.                            ? 1

  949.                            : ((targetPosition < position) ? -1 : 0);

  950.             position = targetPosition;

  951.         }

  952.         if ((movement != 0) && (snapshot->initialDirectionPositive == 0U))

  953.         {

  954.             snapshot->initialDirectionPositive = (movement > 0) ? 2U : 1U;

  955.         }

  956.         if (segmentData->jumpSource != PLSR_VALUE_CONSTANT)

  957.         {

  958.             break;

  959.         }

  960.         next = segmentData->jumpValueOrAddress;

  961.         if (next == (int32_t)segment)

  962.         {

  963.             break;

  964.         }

  965.         if (next == 0)

  966.         {

  967.             if (segment == snapshot->segmentCount) break;

  968.             segment++;

  969.         }

  970.         else

  971.         {

  972.             segment = (uint16_t)next;

  973.         }

  974.     }

  975.     snapshot->initialDirectionPositive =

  976.         (snapshot->initialDirectionPositive == 2U) ? 1U : 0U;

  977.     return PLSR_RESULT_OK;

  978. }

  979. 

  980. static PLSR_RESULT PlsrConvertSnapshotSpeeds(

  981.     PLSR_JOB_SNAPSHOT *snapshot,

  982.     PLSR_PARSE_DETAIL *detail)

  983. {

  984.     uint16_t segment;

  985.     PLSR_RESULT result;

  986. 

  987.     result = PlsrPositionSpeedToPulseFrequency(&snapshot->equivalent,

  988.                                                 snapshot->s2.defaultSpeed,

  989.                                                 &snapshot->s2.defaultSpeed);

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

  991.     result = PlsrPositionSpeedToPulseFrequency(&snapshot->equivalent,

  992.                                                 snapshot->s2.maximumSpeed,

  993.                                                 &snapshot->s2.maximumSpeed);

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

  995.     result = PlsrPositionSpeedToPulseFrequency(&snapshot->equivalent,

  996.                                                 snapshot->s2.startSpeed,

  997.                                                 &snapshot->s2.startSpeed);

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

  999.     result = PlsrPositionSpeedToPulseFrequency(&snapshot->equivalent,

  1000.                                                 snapshot->s2.stopSpeed,

  1001.                                                 &snapshot->s2.stopSpeed);

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

  1003.     result = PlsrPositionSpeedToPulseFrequency(&snapshot->equivalent,

  1004.                                                 snapshot->s2.zrnHighSpeed,

  1005.                                                 &snapshot->s2.zrnHighSpeed);

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

  1007.     result = PlsrPositionSpeedToPulseFrequency(&snapshot->equivalent,

  1008.                                                 snapshot->s2.zrnCrawlSpeed,

  1009.                                                 &snapshot->s2.zrnCrawlSpeed);

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

  1011. 

  1012.     if ((snapshot->s2.maximumSpeed < PLSR_FREQUENCY_MIN_HZ)

  1013.         || (snapshot->s2.maximumSpeed > PLSR_FREQUENCY_MAX_HZ))

  1014.     {

  1015.         PlsrSetDetail(detail,

  1016.                       PLSR_RESULT_INVALID_FREQUENCY,

  1017.                       PLSR_PARSE_BLOCK_S2,

  1018.                       0UL,

  1019.                       (int32_t)snapshot->s2.maximumSpeed,

  1020.                       0U);

  1021.         return PLSR_RESULT_INVALID_FREQUENCY;

  1022.     }

  1023.     for (segment = 1U; segment <= snapshot->segmentCount; segment++)

  1024.     {

  1025.         PLSR_SEGMENT_SNAPSHOT *segmentData =

  1026.             &snapshot->segments[segment - 1U];

  1027. 

  1028.         if (segmentData->targetFrequency == 0UL)

  1029.         {

  1030.             continue;

  1031.         }

  1032.         result = PlsrPositionSpeedToPulseFrequency(

  1033.             &snapshot->equivalent,

  1034.             segmentData->targetFrequency,

  1035.             &segmentData->targetFrequency);

  1036.         if ((result != PLSR_RESULT_OK)

  1037.             || (segmentData->targetFrequency < PLSR_FREQUENCY_MIN_HZ)

  1038.             || (segmentData->targetFrequency > PLSR_FREQUENCY_MAX_HZ))

  1039.         {

  1040.             PlsrSetDetail(detail,

  1041.                           PLSR_RESULT_INVALID_FREQUENCY,

  1042.                           PLSR_PARSE_BLOCK_S0,

  1043.                           snapshot->s0.address

  1044.                               + (uint32_t)segment * PLSR_S0_SEGMENT_WORDS,

  1045.                           (int32_t)segmentData->targetFrequency,

  1046.                           segment);

  1047.             return PLSR_RESULT_INVALID_FREQUENCY;

  1048.         }

  1049.         result = PlsrValidateFrequencyDivider(snapshot,

  1050.                                                segmentData->targetFrequency,

  1051.                                                detail,

  1052.                                                segment);

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

  1054.     }

  1055.     return PLSR_RESULT_OK;

  1056. }

  1057. 

  1058. PLSR_RESULT PlsrBuildJobSnapshot(const PLSR_CALL *call,

  1059.                                  const PLSR_PARSE_CONTEXT *context,

  1060.                                  PLSR_JOB_SNAPSHOT *snapshot,

  1061.                                  PLSR_PARSE_DETAIL *detail)

  1062. {

  1063.     uint64_t s0Words64;

  1064.     uint32_t s0Words;

  1065.     uint32_t segmentBase;

  1066.     int32_t intValue;

  1067.     int32_t resolvedJump;

  1068.     uint16_t word;

  1069.     uint16_t segment;

  1070.     uint8_t index;

  1071.     PLSR_RESULT result;

  1072. 

  1073.     if ((call == NULL) || (context == NULL) || (snapshot == NULL)

  1074.         || (PlsrSourceIsUsable(&call->source) == 0U))

  1075.     {

  1076.         return PLSR_RESULT_INVALID_ARGUMENT;

  1077.     }

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

  1079.     {

  1080.         return PLSR_RESULT_INVALID_AXIS;

  1081.     }

  1082.     (void)memset(snapshot, 0, sizeof(*snapshot));

  1083.     if (detail != NULL) (void)memset(detail, 0, sizeof(*detail));

  1084.     snapshot->source = call->source;

  1085.     snapshot->s0 = call->s0;

  1086.     snapshot->s1 = call->s1;

  1087.     snapshot->dAxis = call->dAxis;

  1088.     snapshot->timerClockHz = ((call->dAxis == 0U) || (call->dAxis == 2U))

  1089.                                  ? PLSR_TIMER_168MHZ

  1090.                                  : PLSR_TIMER_84MHZ;

  1091. 

  1092.     result = PlsrValidateRange(&call->source,

  1093.                                call->s0,

  1094.                                PLSR_S0_HEADER_WORDS,

  1095.                                PLSR_PARSE_BLOCK_S0,

  1096.                                detail);

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

  1098.     result = PlsrReadInt32(&call->source,

  1099.                            call->s0.device,

  1100.                            call->s0.address,

  1101.                            &intValue,

  1102.                            PLSR_PARSE_BLOCK_S0,

  1103.                            0U,

  1104.                            detail);

  1105.     if ((result != PLSR_RESULT_OK) || (intValue < 1)

  1106.         || (intValue > (int32_t)PLSR_MAX_SEGMENTS))

  1107.     {

  1108.         if (result == PLSR_RESULT_OK)

  1109.         {

  1110.             PlsrSetDetail(detail,

  1111.                           PLSR_RESULT_SEGMENT_OVERFLOW,

  1112.                           PLSR_PARSE_BLOCK_S0,

  1113.                           call->s0.address,

  1114.                           intValue,

  1115.                           0U);

  1116.             result = PLSR_RESULT_SEGMENT_OVERFLOW;

  1117.         }

  1118.         return result;

  1119.     }

  1120.     snapshot->segmentCount = (uint16_t)intValue;

  1121.     s0Words64 = (uint64_t)snapshot->segmentCount * PLSR_S0_SEGMENT_WORDS

  1122.                 + PLSR_S0_HEADER_WORDS;

  1123.     if (s0Words64 > UINT32_MAX)

  1124.     {

  1125.         return PLSR_RESULT_ADDRESS_OVERFLOW;

  1126.     }

  1127.     s0Words = (uint32_t)s0Words64;

  1128.     result = PlsrValidateRange(&call->source,

  1129.                                call->s0,

  1130.                                s0Words,

  1131.                                PLSR_PARSE_BLOCK_S0,

  1132.                                detail);

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

  1134.     result = PlsrValidateRange(&call->source,

  1135.                                call->s1,

  1136.                                PLSR_S1_WORDS,

  1137.                                PLSR_PARSE_BLOCK_S1,

  1138.                                detail);

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

  1140.     if (PlsrBlocksOverlap(call->s0, s0Words, call->s1, PLSR_S1_WORDS) != 0U)

  1141.     {

  1142.         PlsrSetDetail(detail,

  1143.                       PLSR_RESULT_BLOCK_OVERLAP,

  1144.                       PLSR_PARSE_BLOCK_S1,

  1145.                       call->s1.address,

  1146.                       (int32_t)s0Words,

  1147.                       0U);

  1148.         return PLSR_RESULT_BLOCK_OVERLAP;

  1149.     }

  1150.     for (index = 2U; index < 10U; index++)

  1151.     {

  1152.         result = PlsrReadWord(&call->source,

  1153.                               call->s0.device,

  1154.                               call->s0.address + index,

  1155.                               &word,

  1156.                               PLSR_PARSE_BLOCK_S0,

  1157.                               0U,

  1158.                               detail);

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

  1160.         if (word != 0U)

  1161.         {

  1162.             PlsrSetDetail(detail,

  1163.                           PLSR_RESULT_RESERVED_NOT_ZERO,

  1164.                           PLSR_PARSE_BLOCK_S0,

  1165.                           call->s0.address + index,

  1166.                           word,

  1167.                           0U);

  1168.             return PLSR_RESULT_RESERVED_NOT_ZERO;

  1169.         }

  1170.     }

  1171. 

  1172.     result = PlsrReadInt32(&call->source,

  1173.                            call->s1.device,

  1174.                            call->s1.address,

  1175.                            &intValue,

  1176.                            PLSR_PARSE_BLOCK_S1,

  1177.                            0U,

  1178.                            detail);

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

  1180.     if ((intValue < 0) || (intValue > 1))

  1181.     {

  1182.         PlsrSetDetail(detail,

  1183.                       PLSR_RESULT_INVALID_POSITION_MODE,

  1184.                       PLSR_PARSE_BLOCK_S1,

  1185.                       call->s1.address,

  1186.                       intValue,

  1187.                       0U);

  1188.         return PLSR_RESULT_INVALID_POSITION_MODE;

  1189.     }

  1190.     snapshot->positioningMode = (uint8_t)intValue;

  1191.     result = PlsrReadInt32(&call->source,

  1192.                            call->s1.device,

  1193.                            call->s1.address + 2UL,

  1194.                            &intValue,

  1195.                            PLSR_PARSE_BLOCK_S1,

  1196.                            0U,

  1197.                            detail);

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

  1199.     if ((intValue < 0) || (intValue > snapshot->segmentCount))

  1200.     {

  1201.         PlsrSetDetail(detail,

  1202.                       PLSR_RESULT_INVALID_ARGUMENT,

  1203.                       PLSR_PARSE_BLOCK_S1,

  1204.                       call->s1.address + 2UL,

  1205.                       intValue,

  1206.                       0U);

  1207.         return PLSR_RESULT_INVALID_ARGUMENT;

  1208.     }

  1209.     snapshot->startSegment = (intValue <= 1) ? 1U : (uint16_t)intValue;

  1210. 

  1211.     result = PlsrLoadS2(call, snapshot, detail);

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

  1213.     if ((snapshot->outputMode == PLSR_OUTPUT_AB)

  1214.         || (snapshot->outputMode == PLSR_OUTPUT_CW_CCW))

  1215.     {

  1216.         if ((call->dAxis != 0U) && (call->dAxis != 2U))

  1217.         {

  1218.             PlsrSetDetail(detail,

  1219.                           PLSR_RESULT_INVALID_RESOURCE,

  1220.                           PLSR_PARSE_BLOCK_OUTPUT,

  1221.                           call->dAxis,

  1222.                           snapshot->outputMode,

  1223.                           0U);

  1224.             return PLSR_RESULT_INVALID_RESOURCE;

  1225.         }

  1226.         snapshot->pairedTimerClockHz = PLSR_TIMER_84MHZ;

  1227.     }

  1228. 

  1229.     for (segment = 1U; segment <= snapshot->segmentCount; segment++)

  1230.     {

  1231.         PLSR_SEGMENT_SNAPSHOT *segmentData = &snapshot->segments[segment - 1U];

  1232.         segmentBase = call->s0.address

  1233.                       + (uint32_t)segment * PLSR_S0_SEGMENT_WORDS;

  1234.         result = PlsrReadInt32(&call->source,

  1235.                                call->s0.device,

  1236.                                segmentBase,

  1237.                                &intValue,

  1238.                                PLSR_PARSE_BLOCK_S0,

  1239.                                segment,

  1240.                                detail);

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

  1242.         if (intValue < 0)

  1243.         {

  1244.             PlsrSetDetail(detail,

  1245.                           PLSR_RESULT_INVALID_FREQUENCY,

  1246.                           PLSR_PARSE_BLOCK_S0,

  1247.                           segmentBase,

  1248.                           intValue,

  1249.                           segment);

  1250.             return PLSR_RESULT_INVALID_FREQUENCY;

  1251.         }

  1252.         segmentData->targetFrequency = (uint32_t)intValue;

  1253.         result = PlsrReadInt32(&call->source,

  1254.                                call->s0.device,

  1255.                                segmentBase + 2UL,

  1256.                                &segmentData->pulseOrTarget,

  1257.                                PLSR_PARSE_BLOCK_S0,

  1258.                                segment,

  1259.                                detail);

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

  1261.         result = PlsrReadWord(&call->source,

  1262.                               call->s0.device,

  1263.                               segmentBase + 4UL,

  1264.                               &word,

  1265.                               PLSR_PARSE_BLOCK_S0,

  1266.                               segment,

  1267.                               detail);

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

  1269.         segmentData->waitSource = (uint8_t)(word & 0xFFU);

  1270.         segmentData->waitCondition = (uint8_t)(word >> 8U);

  1271.         result = PlsrReadInt32(&call->source,

  1272.                                call->s0.device,

  1273.                                segmentBase + 5UL,

  1274.                                &segmentData->waitValueOrAddress,

  1275.                                PLSR_PARSE_BLOCK_S0,

  1276.                                segment,

  1277.                                detail);

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

  1279.         result = PlsrReadWord(&call->source,

  1280.                               call->s0.device,

  1281.                               segmentBase + 7UL,

  1282.                               &word,

  1283.                               PLSR_PARSE_BLOCK_S0,

  1284.                               segment,

  1285.                               detail);

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

  1287.         if ((word & 0xFF00U) != 0U)

  1288.         {

  1289.             PlsrSetDetail(detail,

  1290.                           PLSR_RESULT_RESERVED_NOT_ZERO,

  1291.                           PLSR_PARSE_BLOCK_S0,

  1292.                           segmentBase + 7UL,

  1293.                           word,

  1294.                           segment);

  1295.             return PLSR_RESULT_RESERVED_NOT_ZERO;

  1296.         }

  1297.         segmentData->jumpSource = (uint8_t)(word & 0xFFU);

  1298.         result = PlsrReadInt32(&call->source,

  1299.                                call->s0.device,

  1300.                                segmentBase + 8UL,

  1301.                                &segmentData->jumpValueOrAddress,

  1302.                                PLSR_PARSE_BLOCK_S0,

  1303.                                segment,

  1304.                                detail);

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

  1306. 

  1307.         if ((snapshot->positioningMode == 0U)

  1308.             && (segmentData->pulseOrTarget == 0))

  1309.         {

  1310.             segmentData->flags |= PLSR_SEGMENT_FLAG_ZERO_PULSE;

  1311.             segmentData->targetFrequency = 0UL;

  1312.         }

  1313.         else if (segmentData->targetFrequency == 0UL)

  1314.         {

  1315.             if (snapshot->s2.defaultSpeed == 0UL)

  1316.             {

  1317.                 PlsrSetDetail(detail,

  1318.                               PLSR_RESULT_INVALID_FREQUENCY,

  1319.                               PLSR_PARSE_BLOCK_S2,

  1320.                               0UL,

  1321.                               0,

  1322.                               segment);

  1323.                 return PLSR_RESULT_INVALID_FREQUENCY;

  1324.             }

  1325.             segmentData->targetFrequency = snapshot->s2.defaultSpeed;

  1326.             segmentData->flags |= PLSR_SEGMENT_FLAG_DEFAULT_SPEED;

  1327.         }

  1328.         if (segmentData->targetFrequency > snapshot->s2.maximumSpeed)

  1329.         {

  1330.             segmentData->targetFrequency = snapshot->s2.maximumSpeed;

  1331.             segmentData->flags |= PLSR_SEGMENT_FLAG_SPEED_CLAMPED;

  1332.             snapshot->speedClamped = 1U;

  1333.         }

  1334.         result = PlsrValidateWait(call, segmentData, segment, detail);

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

  1336.         result = PlsrValidateJump(call,

  1337.                                   snapshot,

  1338.                                   segmentData,

  1339.                                   segment,

  1340.                                   &resolvedJump,

  1341.                                   detail);

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

  1343.     }

  1344. 

  1345.     result = PlsrConvertSnapshotSpeeds(snapshot, detail);

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

  1347.     result = PlsrCheckConstantPath(snapshot, detail);

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

  1349.     result = PlsrCheckInitialPosition(snapshot, context, detail);

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

  1351.     if (detail != NULL) detail->result = PLSR_RESULT_OK;

  1352.     return PLSR_RESULT_OK;

  1353. }

  1354. 

  1355. PLSR_RESULT PlsrResolveLiveFrequency(const PLSR_JOB_SNAPSHOT *snapshot,

  1356.                                      uint16_t segment,

  1357.                                      uint32_t *frequency,

  1358.                                      uint8_t *clamped)

  1359. {

  1360.     int32_t rawFrequency;

  1361.     uint32_t segmentAddress;

  1362.     PLSR_RESULT result;

  1363. 

  1364.     if ((snapshot == NULL) || (frequency == NULL) || (clamped == NULL)

  1365.         || (segment < 1U) || (segment > snapshot->segmentCount))

  1366.     {

  1367.         return PLSR_RESULT_INVALID_ARGUMENT;

  1368.     }

  1369.     if ((snapshot->segments[segment - 1U].flags

  1370.          & PLSR_SEGMENT_FLAG_ZERO_PULSE)

  1371.         != 0U)

  1372.     {

  1373.         *frequency = 0UL;

  1374.         *clamped = 0U;

  1375.         return PLSR_RESULT_OK;

  1376.     }

  1377.     segmentAddress = snapshot->s0.address

  1378.                      + (uint32_t)segment * PLSR_S0_SEGMENT_WORDS;

  1379.     result = PlsrReadInt32(&snapshot->source,

  1380.                            snapshot->s0.device,

  1381.                            segmentAddress,

  1382.                            &rawFrequency,

  1383.                            PLSR_PARSE_BLOCK_S0,

  1384.                            segment,

  1385.                            NULL);

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

  1387.     if (rawFrequency < 0) return PLSR_RESULT_INVALID_FREQUENCY;

  1388.     *frequency = (rawFrequency == 0) ? snapshot->inputDefaultSpeed

  1389.                                     : (uint32_t)rawFrequency;

  1390.     *clamped = 0U;

  1391.     if (*frequency > snapshot->inputMaximumSpeed)

  1392.     {

  1393.         *frequency = snapshot->inputMaximumSpeed;

  1394.         *clamped = 1U;

  1395.     }

  1396.     if (*frequency == 0UL) return PLSR_RESULT_INVALID_FREQUENCY;

  1397.     result = PlsrPositionSpeedToPulseFrequency(&snapshot->equivalent,

  1398.                                                 *frequency,

  1399.                                                 frequency);

  1400.     if ((result != PLSR_RESULT_OK) || (*frequency == 0UL)

  1401.         || (*frequency > PLSR_FREQUENCY_MAX_HZ))

  1402.     {

  1403.         return PLSR_RESULT_INVALID_FREQUENCY;

  1404.     }

  1405.     return PlsrValidateFrequencyDivider(snapshot, *frequency, NULL, segment);

  1406. }