yuwenhao
/
Modbus-rtu
1
0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
29 Commits
3 Branches
138 MiB
 
 
 
 
 
 
Tree: 9296f55657
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '9296f55657'
${ noResults }
Modbus-rtu/PLSR/Src/plsr_job.c

1263 lines
44 KiB
Raw Blame History 

  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.     int32_t rawValue = 0;

  192.     PLC_DEVICE_RESULT deviceResult;

  193. 

  194.     deviceResult = (useHsd != 0U) ? PlcDeviceReadHsd(address, &rawValue)

  195.                                   : PlcDeviceReadSfd(address, &rawValue);

  196.     if ((deviceResult != PLC_DEVICE_OK) || (rawValue < 0)

  197.         || (rawValue > (int32_t)UINT16_MAX))

  198.     {

  199.         PlsrSetDetail(detail,

  200.                       PLSR_RESULT_INVALID_S2,

  201.                       PLSR_PARSE_BLOCK_S2,

  202.                       address,

  203.                       rawValue,

  204.                       0U);

  205.         return PLSR_RESULT_INVALID_S2;

  206.     }

  207.     *value = (uint16_t)rawValue;

  208.     return PLSR_RESULT_OK;

  209. }

  210. 

  211. static PLSR_RESULT PlsrReadFixedDword(uint8_t useHsd,

  212.                                       uint16_t address,

  213.                                       uint32_t *value,

  214.                                       PLSR_PARSE_DETAIL *detail)

  215. {

  216.     uint16_t lowWord;

  217.     uint16_t highWord;

  218.     PLSR_RESULT result;

  219. 

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

  221.     if (result != PLSR_RESULT_OK)

  222.     {

  223.         return result;

  224.     }

  225.     result = PlsrReadFixedWord(useHsd,

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

  227.                                &highWord,

  228.                                detail);

  229.     if (result != PLSR_RESULT_OK)

  230.     {

  231.         return result;

  232.     }

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

  234.     return PLSR_RESULT_OK;

  235. }

  236. 

  237. PLSR_RESULT PlsrCalculateTimerDivider(uint32_t timerClockHz,

  238.                                       uint32_t frequencyHz,

  239.                                       uint16_t *psc,

  240.                                       uint16_t *arr)

  241. {

  242.     uint64_t minimumDivider;

  243.     uint64_t periodTicks;

  244. 

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

  246.         || (arr == NULL))

  247.     {

  248.         return PLSR_RESULT_INVALID_ARGUMENT;

  249.     }

  250. 

  251.     minimumDivider = ((uint64_t)timerClockHz

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

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

  254.     if (minimumDivider == 0ULL)

  255.     {

  256.         minimumDivider = 1ULL;

  257.     }

  258.     if (minimumDivider > 65536ULL)

  259.     {

  260.         return PLSR_RESULT_DIVIDER_UNREPRESENTABLE;

  261.     }

  262.     periodTicks = ((uint64_t)timerClockHz

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

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

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

  266.     {

  267.         return PLSR_RESULT_DIVIDER_UNREPRESENTABLE;

  268.     }

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

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

  271.     return PLSR_RESULT_OK;

  272. }

  273. 

  274. static PLSR_RESULT PlsrValidateFrequencyDivider(

  275.     const PLSR_JOB_SNAPSHOT *snapshot,

  276.     uint32_t frequency,

  277.     PLSR_PARSE_DETAIL *detail,

  278.     uint16_t segment)

  279. {

  280.     uint16_t psc;

  281.     uint16_t arr;

  282.     PLSR_RESULT result;

  283. 

  284.     result = PlsrCalculateTimerDivider(snapshot->timerClockHz,

  285.                                        frequency,

  286.                                        &psc,

  287.                                        &arr);

  288.     if ((result == PLSR_RESULT_OK)

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

  290.     {

  291.         result = PlsrCalculateTimerDivider(snapshot->pairedTimerClockHz,

  292.                                            frequency,

  293.                                            &psc,

  294.                                            &arr);

  295.     }

  296.     if (result != PLSR_RESULT_OK)

  297.     {

  298.         PlsrSetDetail(detail,

  299.                       PLSR_RESULT_DIVIDER_UNREPRESENTABLE,

  300.                       PLSR_PARSE_BLOCK_S0,

  301.                       snapshot->s0.address

  302.                           + (uint32_t)segment * PLSR_S0_SEGMENT_WORDS,

  303.                       (int32_t)frequency,

  304.                       segment);

  305.         return PLSR_RESULT_DIVIDER_UNREPRESENTABLE;

  306.     }

  307.     return PLSR_RESULT_OK;

  308. }

  309. 

  310. static PLSR_RESULT PlsrResolveOperand(const PLSR_CALL *call,

  311.                                       const PLSR_VALUE_OPERAND *operand,

  312.                                       int32_t *value,

  313.                                       PLSR_PARSE_DETAIL *detail)

  314. {

  315.     PLSR_RESULT result;

  316. 

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

  318.     {

  319.         *value = operand->constant;

  320.         return PLSR_RESULT_OK;

  321.     }

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

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

  324.     {

  325.         PlsrSetDetail(detail,

  326.                       PLSR_RESULT_INVALID_S2,

  327.                       PLSR_PARSE_BLOCK_S2,

  328.                       operand->data.address,

  329.                       (int32_t)operand->type,

  330.                       0U);

  331.         return PLSR_RESULT_INVALID_S2;

  332.     }

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

  334.                                operand->data,

  335.                                2UL,

  336.                                PLSR_PARSE_BLOCK_S2,

  337.                                detail);

  338.     if (result != PLSR_RESULT_OK)

  339.     {

  340.         return result;

  341.     }

  342.     return PlsrReadInt32(&call->source,

  343.                          operand->data.device,

  344.                          operand->data.address,

  345.                          value,

  346.                          PLSR_PARSE_BLOCK_S2,

  347.                          0U,

  348.                          detail);

  349. }

  350. 

  351. static PLSR_RESULT PlsrLoadS2(const PLSR_CALL *call,

  352.                               PLSR_JOB_SNAPSHOT *snapshot,

  353.                               PLSR_PARSE_DETAIL *detail)

  354. {

  355.     uint16_t commonBase;

  356.     uint16_t setBase;

  357.     uint16_t word;

  358.     int32_t selectedSet;

  359.     uint8_t useHsd;

  360.     PLSR_RESULT result;

  361. 

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

  363.     if (result != PLSR_RESULT_OK)

  364.     {

  365.         return result;

  366.     }

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

  368.     {

  369.         PlsrSetDetail(detail,

  370.                       PLSR_RESULT_INVALID_S2,

  371.                       PLSR_PARSE_BLOCK_S2,

  372.                       call->s2.data.address,

  373.                       selectedSet,

  374.                       0U);

  375.         return PLSR_RESULT_INVALID_S2;

  376.     }

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

  378.     commonBase = (uint16_t)(PLSR_SFD_CONFIG_START

  379.                             + (uint16_t)call->dAxis

  380.                                   * PLSR_SFD_AXIS_STRIDE);

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

  382.     {

  383.         useHsd = 1U;

  384.         setBase = (uint16_t)(PLSR_HSD_SET_BASE

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

  386.     }

  387.     else

  388.     {

  389.         useHsd = 0U;

  390.         setBase = (uint16_t)(commonBase + PLSR_SFD_SET_OFFSET

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

  392.                                    * PLSR_S2_SET_WORDS);

  393.     }

  394. 

  395.     result = PlsrReadFixedDword(useHsd,

  396.                                 setBase,

  397.                                 &snapshot->s2.defaultSpeed,

  398.                                 detail);

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

  400.     result = PlsrReadFixedWord(useHsd,

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

  402.                                &snapshot->s2.accelerationMs,

  403.                                detail);

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

  405.     result = PlsrReadFixedWord(useHsd,

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

  407.                                &snapshot->s2.decelerationMs,

  408.                                detail);

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

  410.     result = PlsrReadFixedWord(useHsd,

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

  412.                                &snapshot->s2.gapAccelerationMs,

  413.                                detail);

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

  415.     result = PlsrReadFixedWord(useHsd,

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

  417.                                &word,

  418.                                detail);

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

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

  421.     result = PlsrReadFixedDword(useHsd,

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

  423.                                 &snapshot->s2.maximumSpeed,

  424.                                 detail);

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

  426.     result = PlsrReadFixedDword(useHsd,

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

  428.                                 &snapshot->s2.startSpeed,

  429.                                 detail);

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

  431.     result = PlsrReadFixedDword(useHsd,

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

  433.                                 &snapshot->s2.stopSpeed,

  434.                                 detail);

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

  436.     result = PlsrReadFixedWord(useHsd,

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

  438.                                &word,

  439.                                detail);

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

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

  442.     {

  443.         PlsrSetDetail(detail,

  444.                       PLSR_RESULT_INVALID_S2,

  445.                       PLSR_PARSE_BLOCK_S2,

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

  447.                       word,

  448.                       0U);

  449.         return PLSR_RESULT_INVALID_S2;

  450.     }

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

  452.     result = PlsrReadFixedWord(useHsd,

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

  454.                                &word,

  455.                                detail);

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

  457.     if (word > 100U)

  458.     {

  459.         PlsrSetDetail(detail,

  460.                       PLSR_RESULT_INVALID_S2,

  461.                       PLSR_PARSE_BLOCK_S2,

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

  463.                       word,

  464.                       0U);

  465.         return PLSR_RESULT_INVALID_S2;

  466.     }

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

  468.     result = PlsrReadFixedWord(useHsd,

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

  470.                                &word,

  471.                                detail);

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

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

  474.     result = PlsrReadFixedDword(useHsd,

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

  476.                                 &snapshot->s2.zrnHighSpeed,

  477.                                 detail);

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

  479.     result = PlsrReadFixedDword(useHsd,

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

  481.                                 &snapshot->s2.zrnCrawlSpeed,

  482.                                 detail);

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

  484. 

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

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

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

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

  489.     {

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

  491.                                    ? (uint8_t)PLSR_OUTPUT_AB

  492.                                    : (uint8_t)PLSR_OUTPUT_PULSE_DIR;

  493.     }

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

  495.     {

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

  497.     }

  498.     else

  499.     {

  500.         PlsrSetDetail(detail,

  501.                       PLSR_RESULT_INVALID_RESOURCE,

  502.                       PLSR_PARSE_BLOCK_OUTPUT,

  503.                       commonBase,

  504.                       call->outputModeOverride,

  505.                       0U);

  506.         return PLSR_RESULT_INVALID_RESOURCE;

  507.     }

  508.     result = PlsrReadFixedWord(0U,

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

  510.                                &word,

  511.                                detail);

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

  513.     if (word > UINT8_MAX)

  514.     {

  515.         PlsrSetDetail(detail,

  516.                       PLSR_RESULT_INVALID_RESOURCE,

  517.                       PLSR_PARSE_BLOCK_OUTPUT,

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

  519.                       word,

  520.                       0U);

  521.         return PLSR_RESULT_INVALID_RESOURCE;

  522.     }

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

  524.     result = PlsrReadFixedWord(0U,

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

  526.                                &snapshot->s2.directionDelayUs,

  527.                                detail);

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

  529. 

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

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

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

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

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

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

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

  537.     {

  538.         PlsrSetDetail(detail,

  539.                       PLSR_RESULT_INVALID_S2,

  540.                       PLSR_PARSE_BLOCK_S2,

  541.                       setBase,

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

  543.                       0U);

  544.         return PLSR_RESULT_INVALID_S2;

  545.     }

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

  547.     {

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

  549.         snapshot->speedClamped = 1U;

  550.     }

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

  552.     {

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

  554.         snapshot->speedClamped = 1U;

  555.     }

  556.     return PLSR_RESULT_OK;

  557. }

  558. 

  559. static PLSR_RESULT PlsrValidateVariableReference(

  560.     const PLSR_CALL *call,

  561.     uint8_t sourceCode,

  562.     int32_t addressValue,

  563.     uint8_t bitReference,

  564.     int32_t *currentValue,

  565.     PLSR_PARSE_BLOCK block,

  566.     uint16_t segment,

  567.     PLSR_PARSE_DETAIL *detail)

  568. {

  569.     PLSR_DEVICE_TYPE device;

  570.     PLSR_DATA_REF reference;

  571.     uint8_t bitValue;

  572.     PLSR_RESULT result;

  573. 

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

  575.     {

  576.         PlsrSetDetail(detail,

  577.                       (block == PLSR_PARSE_BLOCK_S0)

  578.                           ? PLSR_RESULT_INVALID_WAIT

  579.                           : PLSR_RESULT_DATA_ACCESS,

  580.                       block,

  581.                       (uint32_t)addressValue,

  582.                       sourceCode,

  583.                       segment);

  584.         return (block == PLSR_PARSE_BLOCK_S0) ? PLSR_RESULT_INVALID_WAIT

  585.                                               : PLSR_RESULT_DATA_ACCESS;

  586.     }

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

  588.     if (bitReference != 0U)

  589.     {

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

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

  592.                                      device,

  593.                                      (uint32_t)addressValue,

  594.                                      &bitValue)

  595.                 == 0U))

  596.         {

  597.             PlsrSetDetail(detail,

  598.                           PLSR_RESULT_INVALID_WAIT,

  599.                           block,

  600.                           (uint32_t)addressValue,

  601.                           sourceCode,

  602.                           segment);

  603.             return PLSR_RESULT_INVALID_WAIT;

  604.         }

  605.         *currentValue = (int32_t)bitValue;

  606.         return PLSR_RESULT_OK;

  607.     }

  608. 

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

  610.     {

  611.         PlsrSetDetail(detail,

  612.                       PLSR_RESULT_INVALID_WAIT,

  613.                       block,

  614.                       (uint32_t)addressValue,

  615.                       sourceCode,

  616.                       segment);

  617.         return PLSR_RESULT_INVALID_WAIT;

  618.     }

  619.     reference.device = device;

  620.     reference.address = (uint32_t)addressValue;

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

  622.                                reference,

  623.                                2UL,

  624.                                block,

  625.                                detail);

  626.     if (result != PLSR_RESULT_OK)

  627.     {

  628.         return result;

  629.     }

  630.     return PlsrReadInt32(&call->source,

  631.                          device,

  632.                          reference.address,

  633.                          currentValue,

  634.                          block,

  635.                          segment,

  636.                          detail);

  637. }

  638. 

  639. static PLSR_RESULT PlsrValidateWait(const PLSR_CALL *call,

  640.                                     PLSR_SEGMENT_SNAPSHOT *segmentData,

  641.                                     uint16_t segment,

  642.                                     PLSR_PARSE_DETAIL *detail)

  643. {

  644.     int32_t currentValue;

  645.     PLSR_RESULT result;

  646. 

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

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

  649.     {

  650.         goto invalidWait;

  651.     }

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

  653.     {

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

  655.         {

  656.             goto invalidWait;

  657.         }

  658.         return PLSR_RESULT_OK;

  659.     }

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

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

  662.     {

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

  664.         {

  665.             currentValue = segmentData->waitValueOrAddress;

  666.         }

  667.         else

  668.         {

  669.             if (segmentData->waitSource > PLSR_VALUE_FD)

  670.             {

  671.                 goto invalidWait;

  672.             }

  673.             result = PlsrValidateVariableReference(call,

  674.                                                    segmentData->waitSource,

  675.                                                    segmentData->waitValueOrAddress,

  676.                                                    0U,

  677.                                                    &currentValue,

  678.                                                    PLSR_PARSE_BLOCK_S0,

  679.                                                    segment,

  680.                                                    detail);

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

  682.         }

  683.         if (currentValue < 0) goto invalidWait;

  684.         return PLSR_RESULT_OK;

  685.     }

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

  687.     {

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

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

  690.         {

  691.             goto invalidWait;

  692.         }

  693.     }

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

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

  696.     {

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

  698.         {

  699.             goto invalidWait;

  700.         }

  701.     }

  702.     result = PlsrValidateVariableReference(call,

  703.                                            segmentData->waitSource,

  704.                                            segmentData->waitValueOrAddress,

  705.                                            1U,

  706.                                            &currentValue,

  707.                                            PLSR_PARSE_BLOCK_S0,

  708.                                            segment,

  709.                                            detail);

  710.     return result;

  711. 

  712. invalidWait:

  713.     PlsrSetDetail(detail,

  714.                   PLSR_RESULT_INVALID_WAIT,

  715.                   PLSR_PARSE_BLOCK_S0,

  716.                   call->s0.address

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

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

  719.                       | segmentData->waitSource,

  720.                   segment);

  721.     return PLSR_RESULT_INVALID_WAIT;

  722. }

  723. 

  724. static PLSR_RESULT PlsrValidateJump(const PLSR_CALL *call,

  725.                                     const PLSR_JOB_SNAPSHOT *snapshot,

  726.                                     PLSR_SEGMENT_SNAPSHOT *segmentData,

  727.                                     uint16_t segment,

  728.                                     int32_t *resolvedJump,

  729.                                     PLSR_PARSE_DETAIL *detail)

  730. {

  731.     PLSR_RESULT result;

  732. 

  733.     if (segmentData->jumpSource > PLSR_VALUE_FD)

  734.     {

  735.         goto invalidJump;

  736.     }

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

  738.     {

  739.         *resolvedJump = segmentData->jumpValueOrAddress;

  740.     }

  741.     else

  742.     {

  743.         result = PlsrValidateVariableReference(call,

  744.                                                segmentData->jumpSource,

  745.                                                segmentData->jumpValueOrAddress,

  746.                                                0U,

  747.                                                resolvedJump,

  748.                                                PLSR_PARSE_BLOCK_NONE,

  749.                                                segment,

  750.                                                detail);

  751.         if (result != PLSR_RESULT_OK)

  752.         {

  753.             PlsrSetDetail(detail,

  754.                           PLSR_RESULT_INVALID_JUMP,

  755.                           PLSR_PARSE_BLOCK_S0,

  756.                           (uint32_t)segmentData->jumpValueOrAddress,

  757.                           segmentData->jumpSource,

  758.                           segment);

  759.             return PLSR_RESULT_INVALID_JUMP;

  760.         }

  761.     }

  762.     if ((*resolvedJump < 0)

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

  764.     {

  765.         goto invalidJump;

  766.     }

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

  768.     {

  769.         segmentData->flags |= PLSR_SEGMENT_FLAG_SELF_LOOP;

  770.     }

  771.     return PLSR_RESULT_OK;

  772. 

  773. invalidJump:

  774.     PlsrSetDetail(detail,

  775.                   PLSR_RESULT_INVALID_JUMP,

  776.                   PLSR_PARSE_BLOCK_S0,

  777.                   call->s0.address

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

  779.                   *resolvedJump,

  780.                   segment);

  781.     return PLSR_RESULT_INVALID_JUMP;

  782. }

  783. 

  784. static PLSR_RESULT PlsrCheckConstantPath(PLSR_JOB_SNAPSHOT *snapshot,

  785.                                          PLSR_PARSE_DETAIL *detail)

  786. {

  787.     uint8_t visited[PLSR_MAX_SEGMENTS];

  788.     uint16_t segment = snapshot->startSegment;

  789.     int32_t next;

  790. 

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

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

  793.     {

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

  795.         {

  796.             PlsrSetDetail(detail,

  797.                           PLSR_RESULT_PATH_CYCLE,

  798.                           PLSR_PARSE_BLOCK_S0,

  799.                           snapshot->s0.address

  800.                               + (uint32_t)segment * PLSR_S0_SEGMENT_WORDS

  801.                               + 8UL,

  802.                           segment,

  803.                           segment);

  804.             return PLSR_RESULT_PATH_CYCLE;

  805.         }

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

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

  808.             != PLSR_VALUE_CONSTANT)

  809.         {

  810.             return PLSR_RESULT_OK;

  811.         }

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

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

  814.         {

  815.             snapshot->hasSelfLoop = 1U;

  816.             return PLSR_RESULT_OK;

  817.         }

  818.         if (next == 0)

  819.         {

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

  821.             {

  822.                 return PLSR_RESULT_OK;

  823.             }

  824.             segment++;

  825.         }

  826.         else

  827.         {

  828.             segment = (uint16_t)next;

  829.         }

  830.     }

  831.     return PLSR_RESULT_OK;

  832. }

  833. 

  834. static PLSR_RESULT PlsrCheckInitialPosition(

  835.     PLSR_JOB_SNAPSHOT *snapshot,

  836.     const PLSR_PARSE_CONTEXT *context,

  837.     PLSR_PARSE_DETAIL *detail)

  838. {

  839.     uint8_t visited[PLSR_MAX_SEGMENTS];

  840.     int64_t position = context->logicalPosition;

  841.     int32_t movement;

  842.     int32_t next;

  843.     uint16_t segment = snapshot->startSegment;

  844. 

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

  846.     {

  847.         PlsrSetDetail(detail,

  848.                       PLSR_RESULT_POSITION_INVALID,

  849.                       PLSR_PARSE_BLOCK_POSITION,

  850.                       snapshot->s1.address,

  851.                       1,

  852.                       0U);

  853.         return PLSR_RESULT_POSITION_INVALID;

  854.     }

  855. 

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

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

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

  859.     {

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

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

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

  863.         {

  864.             movement = segmentData->pulseOrTarget;

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

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

  867.             {

  868.                 PlsrSetDetail(detail,

  869.                               PLSR_RESULT_POSITION_OVERFLOW,

  870.                               PLSR_PARSE_BLOCK_POSITION,

  871.                               snapshot->s0.address

  872.                                   + (uint32_t)segment

  873.                                         * PLSR_S0_SEGMENT_WORDS

  874.                                   + 2UL,

  875.                               movement,

  876.                               segment);

  877.                 return PLSR_RESULT_POSITION_OVERFLOW;

  878.             }

  879.             position += movement;

  880.         }

  881.         else

  882.         {

  883.             movement = (segmentData->pulseOrTarget > position)

  884.                            ? 1

  885.                            : ((segmentData->pulseOrTarget < position) ? -1 : 0);

  886.             position = segmentData->pulseOrTarget;

  887.         }

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

  889.         {

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

  891.         }

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

  893.         {

  894.             break;

  895.         }

  896.         next = segmentData->jumpValueOrAddress;

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

  898.         {

  899.             break;

  900.         }

  901.         if (next == 0)

  902.         {

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

  904.             segment++;

  905.         }

  906.         else

  907.         {

  908.             segment = (uint16_t)next;

  909.         }

  910.     }

  911.     snapshot->initialDirectionPositive =

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

  913.     return PLSR_RESULT_OK;

  914. }

  915. 

  916. PLSR_RESULT PlsrBuildJobSnapshot(const PLSR_CALL *call,

  917.                                  const PLSR_PARSE_CONTEXT *context,

  918.                                  PLSR_JOB_SNAPSHOT *snapshot,

  919.                                  PLSR_PARSE_DETAIL *detail)

  920. {

  921.     uint64_t s0Words64;

  922.     uint32_t s0Words;

  923.     uint32_t segmentBase;

  924.     int32_t intValue;

  925.     int32_t resolvedJump;

  926.     uint16_t word;

  927.     uint16_t segment;

  928.     uint8_t index;

  929.     PLSR_RESULT result;

  930. 

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

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

  933.     {

  934.         return PLSR_RESULT_INVALID_ARGUMENT;

  935.     }

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

  937.     {

  938.         return PLSR_RESULT_INVALID_AXIS;

  939.     }

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

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

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

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

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

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

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

  947.                                  ? PLSR_TIMER_168MHZ

  948.                                  : PLSR_TIMER_84MHZ;

  949. 

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

  951.                                call->s0,

  952.                                PLSR_S0_HEADER_WORDS,

  953.                                PLSR_PARSE_BLOCK_S0,

  954.                                detail);

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

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

  957.                            call->s0.device,

  958.                            call->s0.address,

  959.                            &intValue,

  960.                            PLSR_PARSE_BLOCK_S0,

  961.                            0U,

  962.                            detail);

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

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

  965.     {

  966.         if (result == PLSR_RESULT_OK)

  967.         {

  968.             PlsrSetDetail(detail,

  969.                           PLSR_RESULT_SEGMENT_OVERFLOW,

  970.                           PLSR_PARSE_BLOCK_S0,

  971.                           call->s0.address,

  972.                           intValue,

  973.                           0U);

  974.             result = PLSR_RESULT_SEGMENT_OVERFLOW;

  975.         }

  976.         return result;

  977.     }

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

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

  980.                 + PLSR_S0_HEADER_WORDS;

  981.     if (s0Words64 > UINT32_MAX)

  982.     {

  983.         return PLSR_RESULT_ADDRESS_OVERFLOW;

  984.     }

  985.     s0Words = (uint32_t)s0Words64;

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

  987.                                call->s0,

  988.                                s0Words,

  989.                                PLSR_PARSE_BLOCK_S0,

  990.                                detail);

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

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

  993.                                call->s1,

  994.                                PLSR_S1_WORDS,

  995.                                PLSR_PARSE_BLOCK_S1,

  996.                                detail);

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

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

  999.     {

  1000.         PlsrSetDetail(detail,

  1001.                       PLSR_RESULT_BLOCK_OVERLAP,

  1002.                       PLSR_PARSE_BLOCK_S1,

  1003.                       call->s1.address,

  1004.                       (int32_t)s0Words,

  1005.                       0U);

  1006.         return PLSR_RESULT_BLOCK_OVERLAP;

  1007.     }

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

  1009.     {

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

  1011.                               call->s0.device,

  1012.                               call->s0.address + index,

  1013.                               &word,

  1014.                               PLSR_PARSE_BLOCK_S0,

  1015.                               0U,

  1016.                               detail);

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

  1018.         if (word != 0U)

  1019.         {

  1020.             PlsrSetDetail(detail,

  1021.                           PLSR_RESULT_RESERVED_NOT_ZERO,

  1022.                           PLSR_PARSE_BLOCK_S0,

  1023.                           call->s0.address + index,

  1024.                           word,

  1025.                           0U);

  1026.             return PLSR_RESULT_RESERVED_NOT_ZERO;

  1027.         }

  1028.     }

  1029. 

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

  1031.                            call->s1.device,

  1032.                            call->s1.address,

  1033.                            &intValue,

  1034.                            PLSR_PARSE_BLOCK_S1,

  1035.                            0U,

  1036.                            detail);

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

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

  1039.     {

  1040.         PlsrSetDetail(detail,

  1041.                       PLSR_RESULT_INVALID_POSITION_MODE,

  1042.                       PLSR_PARSE_BLOCK_S1,

  1043.                       call->s1.address,

  1044.                       intValue,

  1045.                       0U);

  1046.         return PLSR_RESULT_INVALID_POSITION_MODE;

  1047.     }

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

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

  1050.                            call->s1.device,

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

  1052.                            &intValue,

  1053.                            PLSR_PARSE_BLOCK_S1,

  1054.                            0U,

  1055.                            detail);

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

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

  1058.     {

  1059.         PlsrSetDetail(detail,

  1060.                       PLSR_RESULT_INVALID_ARGUMENT,

  1061.                       PLSR_PARSE_BLOCK_S1,

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

  1063.                       intValue,

  1064.                       0U);

  1065.         return PLSR_RESULT_INVALID_ARGUMENT;

  1066.     }

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

  1068. 

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

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

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

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

  1073.     {

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

  1075.         {

  1076.             PlsrSetDetail(detail,

  1077.                           PLSR_RESULT_INVALID_RESOURCE,

  1078.                           PLSR_PARSE_BLOCK_OUTPUT,

  1079.                           call->dAxis,

  1080.                           snapshot->outputMode,

  1081.                           0U);

  1082.             return PLSR_RESULT_INVALID_RESOURCE;

  1083.         }

  1084.         snapshot->pairedTimerClockHz = PLSR_TIMER_84MHZ;

  1085.     }

  1086. 

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

  1088.     {

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

  1090.         segmentBase = call->s0.address

  1091.                       + (uint32_t)segment * PLSR_S0_SEGMENT_WORDS;

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

  1093.                                call->s0.device,

  1094.                                segmentBase,

  1095.                                &intValue,

  1096.                                PLSR_PARSE_BLOCK_S0,

  1097.                                segment,

  1098.                                detail);

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

  1100.         if (intValue < 0)

  1101.         {

  1102.             PlsrSetDetail(detail,

  1103.                           PLSR_RESULT_INVALID_FREQUENCY,

  1104.                           PLSR_PARSE_BLOCK_S0,

  1105.                           segmentBase,

  1106.                           intValue,

  1107.                           segment);

  1108.             return PLSR_RESULT_INVALID_FREQUENCY;

  1109.         }

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

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

  1112.                                call->s0.device,

  1113.                                segmentBase + 2UL,

  1114.                                &segmentData->pulseOrTarget,

  1115.                                PLSR_PARSE_BLOCK_S0,

  1116.                                segment,

  1117.                                detail);

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

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

  1120.                               call->s0.device,

  1121.                               segmentBase + 4UL,

  1122.                               &word,

  1123.                               PLSR_PARSE_BLOCK_S0,

  1124.                               segment,

  1125.                               detail);

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

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

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

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

  1130.                                call->s0.device,

  1131.                                segmentBase + 5UL,

  1132.                                &segmentData->waitValueOrAddress,

  1133.                                PLSR_PARSE_BLOCK_S0,

  1134.                                segment,

  1135.                                detail);

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

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

  1138.                               call->s0.device,

  1139.                               segmentBase + 7UL,

  1140.                               &word,

  1141.                               PLSR_PARSE_BLOCK_S0,

  1142.                               segment,

  1143.                               detail);

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

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

  1146.         {

  1147.             PlsrSetDetail(detail,

  1148.                           PLSR_RESULT_RESERVED_NOT_ZERO,

  1149.                           PLSR_PARSE_BLOCK_S0,

  1150.                           segmentBase + 7UL,

  1151.                           word,

  1152.                           segment);

  1153.             return PLSR_RESULT_RESERVED_NOT_ZERO;

  1154.         }

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

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

  1157.                                call->s0.device,

  1158.                                segmentBase + 8UL,

  1159.                                &segmentData->jumpValueOrAddress,

  1160.                                PLSR_PARSE_BLOCK_S0,

  1161.                                segment,

  1162.                                detail);

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

  1164. 

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

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

  1167.         {

  1168.             segmentData->flags |= PLSR_SEGMENT_FLAG_ZERO_PULSE;

  1169.             segmentData->targetFrequency = 0UL;

  1170.         }

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

  1172.         {

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

  1174.             {

  1175.                 PlsrSetDetail(detail,

  1176.                               PLSR_RESULT_INVALID_FREQUENCY,

  1177.                               PLSR_PARSE_BLOCK_S2,

  1178.                               0UL,

  1179.                               0,

  1180.                               segment);

  1181.                 return PLSR_RESULT_INVALID_FREQUENCY;

  1182.             }

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

  1184.             segmentData->flags |= PLSR_SEGMENT_FLAG_DEFAULT_SPEED;

  1185.         }

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

  1187.         {

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

  1189.             segmentData->flags |= PLSR_SEGMENT_FLAG_SPEED_CLAMPED;

  1190.             snapshot->speedClamped = 1U;

  1191.         }

  1192.         if (segmentData->targetFrequency != 0UL)

  1193.         {

  1194.             result = PlsrValidateFrequencyDivider(snapshot,

  1195.                                                    segmentData->targetFrequency,

  1196.                                                    detail,

  1197.                                                    segment);

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

  1199.         }

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

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

  1202.         result = PlsrValidateJump(call,

  1203.                                   snapshot,

  1204.                                   segmentData,

  1205.                                   segment,

  1206.                                   &resolvedJump,

  1207.                                   detail);

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

  1209.     }

  1210. 

  1211.     result = PlsrCheckConstantPath(snapshot, detail);

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

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

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

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

  1216.     return PLSR_RESULT_OK;

  1217. }

  1218. 

  1219. PLSR_RESULT PlsrResolveLiveFrequency(const PLSR_JOB_SNAPSHOT *snapshot,

  1220.                                      uint16_t segment,

  1221.                                      uint32_t *frequency,

  1222.                                      uint8_t *clamped)

  1223. {

  1224.     int32_t rawFrequency;

  1225.     uint32_t segmentAddress;

  1226.     PLSR_RESULT result;

  1227. 

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

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

  1230.     {

  1231.         return PLSR_RESULT_INVALID_ARGUMENT;

  1232.     }

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

  1234.          & PLSR_SEGMENT_FLAG_ZERO_PULSE)

  1235.         != 0U)

  1236.     {

  1237.         *frequency = 0UL;

  1238.         *clamped = 0U;

  1239.         return PLSR_RESULT_OK;

  1240.     }

  1241.     segmentAddress = snapshot->s0.address

  1242.                      + (uint32_t)segment * PLSR_S0_SEGMENT_WORDS;

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

  1244.                            snapshot->s0.device,

  1245.                            segmentAddress,

  1246.                            &rawFrequency,

  1247.                            PLSR_PARSE_BLOCK_S0,

  1248.                            segment,

  1249.                            NULL);

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

  1251.     if (rawFrequency < 0) return PLSR_RESULT_INVALID_FREQUENCY;

  1252.     *frequency = (rawFrequency == 0) ? snapshot->s2.defaultSpeed

  1253.                                     : (uint32_t)rawFrequency;

  1254.     *clamped = 0U;

  1255.     if (*frequency > snapshot->s2.maximumSpeed)

  1256.     {

  1257.         *frequency = snapshot->s2.maximumSpeed;

  1258.         *clamped = 1U;

  1259.     }

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

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

  1262. }