yuwenhao
/
Modbus-rtu
1
0
フォーク 0
コード 課題 0 プルリクエスト 0 リリース 0 Wiki アクティビティ
選択できるのは25トピックまでです。 トピックは、先頭が英数字で、英数字とダッシュ('-')を使用した35文字以内のものにしてください。
37 コミット
3 ブランチ
138 MiB
 
 
 
 
 
 
ツリー: 0b7990bc99
ブランチ タグ
${ item.name }
ブランチ ${ searchTerm } を作成
'0b7990bc99' から
${ noResults }
Modbus-rtu/PLSR/Src/plsr_job.c

1260 行
44 KiB
Raw 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.     if (call->outputModeOverride == PLSR_OUTPUT_MODE_FROM_SFD)

  486.     {

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

  488.                                    ? (uint8_t)PLSR_OUTPUT_AB

  489.                                    : (uint8_t)PLSR_OUTPUT_PULSE_DIR;

  490.     }

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

  492.     {

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

  494.     }

  495.     else

  496.     {

  497.         PlsrSetDetail(detail,

  498.                       PLSR_RESULT_INVALID_RESOURCE,

  499.                       PLSR_PARSE_BLOCK_OUTPUT,

  500.                       commonBase,

  501.                       call->outputModeOverride,

  502.                       0U);

  503.         return PLSR_RESULT_INVALID_RESOURCE;

  504.     }

  505.     result = PlsrReadFixedWord(0U,

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

  507.                                &word,

  508.                                detail);

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

  510.     if (word > UINT8_MAX)

  511.     {

  512.         PlsrSetDetail(detail,

  513.                       PLSR_RESULT_INVALID_RESOURCE,

  514.                       PLSR_PARSE_BLOCK_OUTPUT,

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

  516.                       word,

  517.                       0U);

  518.         return PLSR_RESULT_INVALID_RESOURCE;

  519.     }

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

  521.     result = PlsrReadFixedWord(0U,

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

  523.                                &snapshot->s2.directionDelayMs,

  524.                                detail);

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

  526. 

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

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

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

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

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

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

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

  534.     {

  535.         PlsrSetDetail(detail,

  536.                       PLSR_RESULT_INVALID_S2,

  537.                       PLSR_PARSE_BLOCK_S2,

  538.                       setBase,

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

  540.                       0U);

  541.         return PLSR_RESULT_INVALID_S2;

  542.     }

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

  544.     {

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

  546.         snapshot->speedClamped = 1U;

  547.     }

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

  549.     {

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

  551.         snapshot->speedClamped = 1U;

  552.     }

  553.     return PLSR_RESULT_OK;

  554. }

  555. 

  556. static PLSR_RESULT PlsrValidateVariableReference(

  557.     const PLSR_CALL *call,

  558.     uint8_t sourceCode,

  559.     int32_t addressValue,

  560.     uint8_t bitReference,

  561.     int32_t *currentValue,

  562.     PLSR_PARSE_BLOCK block,

  563.     uint16_t segment,

  564.     PLSR_PARSE_DETAIL *detail)

  565. {

  566.     PLSR_DEVICE_TYPE device;

  567.     PLSR_DATA_REF reference;

  568.     uint8_t bitValue;

  569.     PLSR_RESULT result;

  570. 

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

  572.     {

  573.         PlsrSetDetail(detail,

  574.                       (block == PLSR_PARSE_BLOCK_S0)

  575.                           ? PLSR_RESULT_INVALID_WAIT

  576.                           : PLSR_RESULT_DATA_ACCESS,

  577.                       block,

  578.                       (uint32_t)addressValue,

  579.                       sourceCode,

  580.                       segment);

  581.         return (block == PLSR_PARSE_BLOCK_S0) ? PLSR_RESULT_INVALID_WAIT

  582.                                               : PLSR_RESULT_DATA_ACCESS;

  583.     }

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

  585.     if (bitReference != 0U)

  586.     {

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

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

  589.                                      device,

  590.                                      (uint32_t)addressValue,

  591.                                      &bitValue)

  592.                 == 0U))

  593.         {

  594.             PlsrSetDetail(detail,

  595.                           PLSR_RESULT_INVALID_WAIT,

  596.                           block,

  597.                           (uint32_t)addressValue,

  598.                           sourceCode,

  599.                           segment);

  600.             return PLSR_RESULT_INVALID_WAIT;

  601.         }

  602.         *currentValue = (int32_t)bitValue;

  603.         return PLSR_RESULT_OK;

  604.     }

  605. 

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

  607.     {

  608.         PlsrSetDetail(detail,

  609.                       PLSR_RESULT_INVALID_WAIT,

  610.                       block,

  611.                       (uint32_t)addressValue,

  612.                       sourceCode,

  613.                       segment);

  614.         return PLSR_RESULT_INVALID_WAIT;

  615.     }

  616.     reference.device = device;

  617.     reference.address = (uint32_t)addressValue;

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

  619.                                reference,

  620.                                2UL,

  621.                                block,

  622.                                detail);

  623.     if (result != PLSR_RESULT_OK)

  624.     {

  625.         return result;

  626.     }

  627.     return PlsrReadInt32(&call->source,

  628.                          device,

  629.                          reference.address,

  630.                          currentValue,

  631.                          block,

  632.                          segment,

  633.                          detail);

  634. }

  635. 

  636. static PLSR_RESULT PlsrValidateWait(const PLSR_CALL *call,

  637.                                     PLSR_SEGMENT_SNAPSHOT *segmentData,

  638.                                     uint16_t segment,

  639.                                     PLSR_PARSE_DETAIL *detail)

  640. {

  641.     int32_t currentValue;

  642.     PLSR_RESULT result;

  643. 

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

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

  646.     {

  647.         goto invalidWait;

  648.     }

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

  650.     {

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

  652.         {

  653.             goto invalidWait;

  654.         }

  655.         return PLSR_RESULT_OK;

  656.     }

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

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

  659.     {

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

  661.         {

  662.             currentValue = segmentData->waitValueOrAddress;

  663.         }

  664.         else

  665.         {

  666.             if (segmentData->waitSource > PLSR_VALUE_FD)

  667.             {

  668.                 goto invalidWait;

  669.             }

  670.             result = PlsrValidateVariableReference(call,

  671.                                                    segmentData->waitSource,

  672.                                                    segmentData->waitValueOrAddress,

  673.                                                    0U,

  674.                                                    &currentValue,

  675.                                                    PLSR_PARSE_BLOCK_S0,

  676.                                                    segment,

  677.                                                    detail);

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

  679.         }

  680.         if (currentValue < 0) goto invalidWait;

  681.         return PLSR_RESULT_OK;

  682.     }

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

  684.     {

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

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

  687.         {

  688.             goto invalidWait;

  689.         }

  690.     }

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

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

  693.     {

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

  695.         {

  696.             goto invalidWait;

  697.         }

  698.     }

  699.     result = PlsrValidateVariableReference(call,

  700.                                            segmentData->waitSource,

  701.                                            segmentData->waitValueOrAddress,

  702.                                            1U,

  703.                                            &currentValue,

  704.                                            PLSR_PARSE_BLOCK_S0,

  705.                                            segment,

  706.                                            detail);

  707.     return result;

  708. 

  709. invalidWait:

  710.     PlsrSetDetail(detail,

  711.                   PLSR_RESULT_INVALID_WAIT,

  712.                   PLSR_PARSE_BLOCK_S0,

  713.                   call->s0.address

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

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

  716.                       | segmentData->waitSource,

  717.                   segment);

  718.     return PLSR_RESULT_INVALID_WAIT;

  719. }

  720. 

  721. static PLSR_RESULT PlsrValidateJump(const PLSR_CALL *call,

  722.                                     const PLSR_JOB_SNAPSHOT *snapshot,

  723.                                     PLSR_SEGMENT_SNAPSHOT *segmentData,

  724.                                     uint16_t segment,

  725.                                     int32_t *resolvedJump,

  726.                                     PLSR_PARSE_DETAIL *detail)

  727. {

  728.     PLSR_RESULT result;

  729. 

  730.     if (segmentData->jumpSource > PLSR_VALUE_FD)

  731.     {

  732.         goto invalidJump;

  733.     }

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

  735.     {

  736.         *resolvedJump = segmentData->jumpValueOrAddress;

  737.     }

  738.     else

  739.     {

  740.         result = PlsrValidateVariableReference(call,

  741.                                                segmentData->jumpSource,

  742.                                                segmentData->jumpValueOrAddress,

  743.                                                0U,

  744.                                                resolvedJump,

  745.                                                PLSR_PARSE_BLOCK_NONE,

  746.                                                segment,

  747.                                                detail);

  748.         if (result != PLSR_RESULT_OK)

  749.         {

  750.             PlsrSetDetail(detail,

  751.                           PLSR_RESULT_INVALID_JUMP,

  752.                           PLSR_PARSE_BLOCK_S0,

  753.                           (uint32_t)segmentData->jumpValueOrAddress,

  754.                           segmentData->jumpSource,

  755.                           segment);

  756.             return PLSR_RESULT_INVALID_JUMP;

  757.         }

  758.     }

  759.     if ((*resolvedJump < 0)

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

  761.     {

  762.         goto invalidJump;

  763.     }

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

  765.     {

  766.         segmentData->flags |= PLSR_SEGMENT_FLAG_SELF_LOOP;

  767.     }

  768.     return PLSR_RESULT_OK;

  769. 

  770. invalidJump:

  771.     PlsrSetDetail(detail,

  772.                   PLSR_RESULT_INVALID_JUMP,

  773.                   PLSR_PARSE_BLOCK_S0,

  774.                   call->s0.address

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

  776.                   *resolvedJump,

  777.                   segment);

  778.     return PLSR_RESULT_INVALID_JUMP;

  779. }

  780. 

  781. static PLSR_RESULT PlsrCheckConstantPath(PLSR_JOB_SNAPSHOT *snapshot,

  782.                                          PLSR_PARSE_DETAIL *detail)

  783. {

  784.     uint8_t visited[PLSR_MAX_SEGMENTS];

  785.     uint16_t segment = snapshot->startSegment;

  786.     int32_t next;

  787. 

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

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

  790.     {

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

  792.         {

  793.             PlsrSetDetail(detail,

  794.                           PLSR_RESULT_PATH_CYCLE,

  795.                           PLSR_PARSE_BLOCK_S0,

  796.                           snapshot->s0.address

  797.                               + (uint32_t)segment * PLSR_S0_SEGMENT_WORDS

  798.                               + 8UL,

  799.                           segment,

  800.                           segment);

  801.             return PLSR_RESULT_PATH_CYCLE;

  802.         }

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

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

  805.             != PLSR_VALUE_CONSTANT)

  806.         {

  807.             return PLSR_RESULT_OK;

  808.         }

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

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

  811.         {

  812.             snapshot->hasSelfLoop = 1U;

  813.             return PLSR_RESULT_OK;

  814.         }

  815.         if (next == 0)

  816.         {

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

  818.             {

  819.                 return PLSR_RESULT_OK;

  820.             }

  821.             segment++;

  822.         }

  823.         else

  824.         {

  825.             segment = (uint16_t)next;

  826.         }

  827.     }

  828.     return PLSR_RESULT_OK;

  829. }

  830. 

  831. static PLSR_RESULT PlsrCheckInitialPosition(

  832.     PLSR_JOB_SNAPSHOT *snapshot,

  833.     const PLSR_PARSE_CONTEXT *context,

  834.     PLSR_PARSE_DETAIL *detail)

  835. {

  836.     uint8_t visited[PLSR_MAX_SEGMENTS];

  837.     int64_t position = context->logicalPosition;

  838.     int32_t movement;

  839.     int32_t next;

  840.     uint16_t segment = snapshot->startSegment;

  841. 

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

  843.     {

  844.         PlsrSetDetail(detail,

  845.                       PLSR_RESULT_POSITION_INVALID,

  846.                       PLSR_PARSE_BLOCK_POSITION,

  847.                       snapshot->s1.address,

  848.                       1,

  849.                       0U);

  850.         return PLSR_RESULT_POSITION_INVALID;

  851.     }

  852. 

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

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

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

  856.     {

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

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

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

  860.         {

  861.             movement = segmentData->pulseOrTarget;

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

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

  864.             {

  865.                 PlsrSetDetail(detail,

  866.                               PLSR_RESULT_POSITION_OVERFLOW,

  867.                               PLSR_PARSE_BLOCK_POSITION,

  868.                               snapshot->s0.address

  869.                                   + (uint32_t)segment

  870.                                         * PLSR_S0_SEGMENT_WORDS

  871.                                   + 2UL,

  872.                               movement,

  873.                               segment);

  874.                 return PLSR_RESULT_POSITION_OVERFLOW;

  875.             }

  876.             position += movement;

  877.         }

  878.         else

  879.         {

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

  881.                            ? 1

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

  883.             position = segmentData->pulseOrTarget;

  884.         }

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

  886.         {

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

  888.         }

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

  890.         {

  891.             break;

  892.         }

  893.         next = segmentData->jumpValueOrAddress;

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

  895.         {

  896.             break;

  897.         }

  898.         if (next == 0)

  899.         {

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

  901.             segment++;

  902.         }

  903.         else

  904.         {

  905.             segment = (uint16_t)next;

  906.         }

  907.     }

  908.     snapshot->initialDirectionPositive =

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

  910.     return PLSR_RESULT_OK;

  911. }

  912. 

  913. PLSR_RESULT PlsrBuildJobSnapshot(const PLSR_CALL *call,

  914.                                  const PLSR_PARSE_CONTEXT *context,

  915.                                  PLSR_JOB_SNAPSHOT *snapshot,

  916.                                  PLSR_PARSE_DETAIL *detail)

  917. {

  918.     uint64_t s0Words64;

  919.     uint32_t s0Words;

  920.     uint32_t segmentBase;

  921.     int32_t intValue;

  922.     int32_t resolvedJump;

  923.     uint16_t word;

  924.     uint16_t segment;

  925.     uint8_t index;

  926.     PLSR_RESULT result;

  927. 

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

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

  930.     {

  931.         return PLSR_RESULT_INVALID_ARGUMENT;

  932.     }

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

  934.     {

  935.         return PLSR_RESULT_INVALID_AXIS;

  936.     }

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

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

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

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

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

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

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

  944.                                  ? PLSR_TIMER_168MHZ

  945.                                  : PLSR_TIMER_84MHZ;

  946. 

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

  948.                                call->s0,

  949.                                PLSR_S0_HEADER_WORDS,

  950.                                PLSR_PARSE_BLOCK_S0,

  951.                                detail);

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

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

  954.                            call->s0.device,

  955.                            call->s0.address,

  956.                            &intValue,

  957.                            PLSR_PARSE_BLOCK_S0,

  958.                            0U,

  959.                            detail);

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

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

  962.     {

  963.         if (result == PLSR_RESULT_OK)

  964.         {

  965.             PlsrSetDetail(detail,

  966.                           PLSR_RESULT_SEGMENT_OVERFLOW,

  967.                           PLSR_PARSE_BLOCK_S0,

  968.                           call->s0.address,

  969.                           intValue,

  970.                           0U);

  971.             result = PLSR_RESULT_SEGMENT_OVERFLOW;

  972.         }

  973.         return result;

  974.     }

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

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

  977.                 + PLSR_S0_HEADER_WORDS;

  978.     if (s0Words64 > UINT32_MAX)

  979.     {

  980.         return PLSR_RESULT_ADDRESS_OVERFLOW;

  981.     }

  982.     s0Words = (uint32_t)s0Words64;

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

  984.                                call->s0,

  985.                                s0Words,

  986.                                PLSR_PARSE_BLOCK_S0,

  987.                                detail);

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

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

  990.                                call->s1,

  991.                                PLSR_S1_WORDS,

  992.                                PLSR_PARSE_BLOCK_S1,

  993.                                detail);

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

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

  996.     {

  997.         PlsrSetDetail(detail,

  998.                       PLSR_RESULT_BLOCK_OVERLAP,

  999.                       PLSR_PARSE_BLOCK_S1,

  1000.                       call->s1.address,

  1001.                       (int32_t)s0Words,

  1002.                       0U);

  1003.         return PLSR_RESULT_BLOCK_OVERLAP;

  1004.     }

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

  1006.     {

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

  1008.                               call->s0.device,

  1009.                               call->s0.address + index,

  1010.                               &word,

  1011.                               PLSR_PARSE_BLOCK_S0,

  1012.                               0U,

  1013.                               detail);

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

  1015.         if (word != 0U)

  1016.         {

  1017.             PlsrSetDetail(detail,

  1018.                           PLSR_RESULT_RESERVED_NOT_ZERO,

  1019.                           PLSR_PARSE_BLOCK_S0,

  1020.                           call->s0.address + index,

  1021.                           word,

  1022.                           0U);

  1023.             return PLSR_RESULT_RESERVED_NOT_ZERO;

  1024.         }

  1025.     }

  1026. 

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

  1028.                            call->s1.device,

  1029.                            call->s1.address,

  1030.                            &intValue,

  1031.                            PLSR_PARSE_BLOCK_S1,

  1032.                            0U,

  1033.                            detail);

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

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

  1036.     {

  1037.         PlsrSetDetail(detail,

  1038.                       PLSR_RESULT_INVALID_POSITION_MODE,

  1039.                       PLSR_PARSE_BLOCK_S1,

  1040.                       call->s1.address,

  1041.                       intValue,

  1042.                       0U);

  1043.         return PLSR_RESULT_INVALID_POSITION_MODE;

  1044.     }

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

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

  1047.                            call->s1.device,

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

  1049.                            &intValue,

  1050.                            PLSR_PARSE_BLOCK_S1,

  1051.                            0U,

  1052.                            detail);

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

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

  1055.     {

  1056.         PlsrSetDetail(detail,

  1057.                       PLSR_RESULT_INVALID_ARGUMENT,

  1058.                       PLSR_PARSE_BLOCK_S1,

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

  1060.                       intValue,

  1061.                       0U);

  1062.         return PLSR_RESULT_INVALID_ARGUMENT;

  1063.     }

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

  1065. 

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

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

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

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

  1070.     {

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

  1072.         {

  1073.             PlsrSetDetail(detail,

  1074.                           PLSR_RESULT_INVALID_RESOURCE,

  1075.                           PLSR_PARSE_BLOCK_OUTPUT,

  1076.                           call->dAxis,

  1077.                           snapshot->outputMode,

  1078.                           0U);

  1079.             return PLSR_RESULT_INVALID_RESOURCE;

  1080.         }

  1081.         snapshot->pairedTimerClockHz = PLSR_TIMER_84MHZ;

  1082.     }

  1083. 

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

  1085.     {

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

  1087.         segmentBase = call->s0.address

  1088.                       + (uint32_t)segment * PLSR_S0_SEGMENT_WORDS;

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

  1090.                                call->s0.device,

  1091.                                segmentBase,

  1092.                                &intValue,

  1093.                                PLSR_PARSE_BLOCK_S0,

  1094.                                segment,

  1095.                                detail);

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

  1097.         if (intValue < 0)

  1098.         {

  1099.             PlsrSetDetail(detail,

  1100.                           PLSR_RESULT_INVALID_FREQUENCY,

  1101.                           PLSR_PARSE_BLOCK_S0,

  1102.                           segmentBase,

  1103.                           intValue,

  1104.                           segment);

  1105.             return PLSR_RESULT_INVALID_FREQUENCY;

  1106.         }

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

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

  1109.                                call->s0.device,

  1110.                                segmentBase + 2UL,

  1111.                                &segmentData->pulseOrTarget,

  1112.                                PLSR_PARSE_BLOCK_S0,

  1113.                                segment,

  1114.                                detail);

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

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

  1117.                               call->s0.device,

  1118.                               segmentBase + 4UL,

  1119.                               &word,

  1120.                               PLSR_PARSE_BLOCK_S0,

  1121.                               segment,

  1122.                               detail);

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

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

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

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

  1127.                                call->s0.device,

  1128.                                segmentBase + 5UL,

  1129.                                &segmentData->waitValueOrAddress,

  1130.                                PLSR_PARSE_BLOCK_S0,

  1131.                                segment,

  1132.                                detail);

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

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

  1135.                               call->s0.device,

  1136.                               segmentBase + 7UL,

  1137.                               &word,

  1138.                               PLSR_PARSE_BLOCK_S0,

  1139.                               segment,

  1140.                               detail);

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

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

  1143.         {

  1144.             PlsrSetDetail(detail,

  1145.                           PLSR_RESULT_RESERVED_NOT_ZERO,

  1146.                           PLSR_PARSE_BLOCK_S0,

  1147.                           segmentBase + 7UL,

  1148.                           word,

  1149.                           segment);

  1150.             return PLSR_RESULT_RESERVED_NOT_ZERO;

  1151.         }

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

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

  1154.                                call->s0.device,

  1155.                                segmentBase + 8UL,

  1156.                                &segmentData->jumpValueOrAddress,

  1157.                                PLSR_PARSE_BLOCK_S0,

  1158.                                segment,

  1159.                                detail);

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

  1161. 

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

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

  1164.         {

  1165.             segmentData->flags |= PLSR_SEGMENT_FLAG_ZERO_PULSE;

  1166.             segmentData->targetFrequency = 0UL;

  1167.         }

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

  1169.         {

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

  1171.             {

  1172.                 PlsrSetDetail(detail,

  1173.                               PLSR_RESULT_INVALID_FREQUENCY,

  1174.                               PLSR_PARSE_BLOCK_S2,

  1175.                               0UL,

  1176.                               0,

  1177.                               segment);

  1178.                 return PLSR_RESULT_INVALID_FREQUENCY;

  1179.             }

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

  1181.             segmentData->flags |= PLSR_SEGMENT_FLAG_DEFAULT_SPEED;

  1182.         }

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

  1184.         {

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

  1186.             segmentData->flags |= PLSR_SEGMENT_FLAG_SPEED_CLAMPED;

  1187.             snapshot->speedClamped = 1U;

  1188.         }

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

  1190.         {

  1191.             result = PlsrValidateFrequencyDivider(snapshot,

  1192.                                                    segmentData->targetFrequency,

  1193.                                                    detail,

  1194.                                                    segment);

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

  1196.         }

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

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

  1199.         result = PlsrValidateJump(call,

  1200.                                   snapshot,

  1201.                                   segmentData,

  1202.                                   segment,

  1203.                                   &resolvedJump,

  1204.                                   detail);

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

  1206.     }

  1207. 

  1208.     result = PlsrCheckConstantPath(snapshot, detail);

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

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

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

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

  1213.     return PLSR_RESULT_OK;

  1214. }

  1215. 

  1216. PLSR_RESULT PlsrResolveLiveFrequency(const PLSR_JOB_SNAPSHOT *snapshot,

  1217.                                      uint16_t segment,

  1218.                                      uint32_t *frequency,

  1219.                                      uint8_t *clamped)

  1220. {

  1221.     int32_t rawFrequency;

  1222.     uint32_t segmentAddress;

  1223.     PLSR_RESULT result;

  1224. 

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

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

  1227.     {

  1228.         return PLSR_RESULT_INVALID_ARGUMENT;

  1229.     }

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

  1231.          & PLSR_SEGMENT_FLAG_ZERO_PULSE)

  1232.         != 0U)

  1233.     {

  1234.         *frequency = 0UL;

  1235.         *clamped = 0U;

  1236.         return PLSR_RESULT_OK;

  1237.     }

  1238.     segmentAddress = snapshot->s0.address

  1239.                      + (uint32_t)segment * PLSR_S0_SEGMENT_WORDS;

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

  1241.                            snapshot->s0.device,

  1242.                            segmentAddress,

  1243.                            &rawFrequency,

  1244.                            PLSR_PARSE_BLOCK_S0,

  1245.                            segment,

  1246.                            NULL);

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

  1248.     if (rawFrequency < 0) return PLSR_RESULT_INVALID_FREQUENCY;

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

  1250.                                     : (uint32_t)rawFrequency;

  1251.     *clamped = 0U;

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

  1253.     {

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

  1255.         *clamped = 1U;

  1256.     }

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

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

  1259. }