yuwenhao
/
Modbus-rtu
1
0
Fork 0
Código Incidencias 0 Pull Requests 0 Lanzamientos 0 Wiki Actividad
No puede seleccionar más de 25 temas Los temas deben comenzar con una letra o número, pueden incluir guiones ('-') y pueden tener hasta 35 caracteres de largo.
44 Commits
3 Ramas
138 MiB
 
 
 
 
 
 
Árbol: 4261f3693f
Ramas Etiquetas
${ item.name }
Crear rama ${ searchTerm }
desde '4261f3693f'
${ noResults }
Modbus-rtu/PLSR/Src/plsr_job.c

1537 líneas
55 KiB
Original Blame Histórico 

  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.     if (source->readDword != NULL)

  141.     {

  142.         if (source->readDword(source->context,

  143.                               device,

  144.                               address,

  145.                               value) == 0U)

  146.         {

  147.             PlsrSetDetail(detail,

  148.                           PLSR_RESULT_DATA_ACCESS,

  149.                           block,

  150.                           address,

  151.                           0,

  152.                           segment);

  153.             return PLSR_RESULT_DATA_ACCESS;

  154.         }

  155.         return PLSR_RESULT_OK;

  156.     }

  157.     result = PlsrReadWord(source,

  158.                           device,

  159.                           address,

  160.                           &lowWord,

  161.                           block,

  162.                           segment,

  163.                           detail);

  164.     if (result != PLSR_RESULT_OK)

  165.     {

  166.         return result;

  167.     }

  168.     result = PlsrReadWord(source,

  169.                           device,

  170.                           address + 1UL,

  171.                           &highWord,

  172.                           block,

  173.                           segment,

  174.                           detail);

  175.     if (result != PLSR_RESULT_OK)

  176.     {

  177.         return result;

  178.     }

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

  180.     return PLSR_RESULT_OK;

  181. }

  182. 

  183. static uint8_t PlsrBlocksOverlap(PLSR_DATA_REF first,

  184.                                  uint32_t firstWords,

  185.                                  PLSR_DATA_REF second,

  186.                                  uint32_t secondWords)

  187. {

  188.     uint64_t firstEnd;

  189.     uint64_t secondEnd;

  190. 

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

  192.     {

  193.         return 0U;

  194.     }

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

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

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

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

  199.                ? 1U

  200.                : 0U;

  201. }

  202. 

  203. static PLSR_RESULT PlsrReadFixedWord(uint8_t useHsd,

  204.                                      uint16_t address,

  205.                                      uint16_t *value,

  206.                                      PLSR_PARSE_DETAIL *detail)

  207. {

  208.     PLC_DEVICE_RESULT deviceResult;

  209. 

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

  211.                                   : PlcDeviceReadSfd(address, value);

  212.     if (deviceResult != PLC_DEVICE_OK)

  213.     {

  214.         PlsrSetDetail(detail,

  215.                       PLSR_RESULT_INVALID_S2,

  216.                       PLSR_PARSE_BLOCK_S2,

  217.                       address,

  218.                       0,

  219.                       0U);

  220.         return PLSR_RESULT_INVALID_S2;

  221.     }

  222.     return PLSR_RESULT_OK;

  223. }

  224. 

  225. static PLSR_RESULT PlsrReadFixedDword(uint8_t useHsd,

  226.                                       uint16_t address,

  227.                                       uint32_t *value,

  228.                                       PLSR_PARSE_DETAIL *detail)

  229. {

  230.     uint16_t lowWord;

  231.     uint16_t highWord;

  232.     PLSR_RESULT result;

  233. 

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

  235.     if (result != PLSR_RESULT_OK)

  236.     {

  237.         return result;

  238.     }

  239.     result = PlsrReadFixedWord(useHsd,

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

  241.                                &highWord,

  242.                                detail);

  243.     if (result != PLSR_RESULT_OK)

  244.     {

  245.         return result;

  246.     }

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

  248.     return PLSR_RESULT_OK;

  249. }

  250. 

  251. PLSR_RESULT PlsrCalculateTimerDivider(uint32_t timerClockHz,

  252.                                       uint32_t frequencyHz,

  253.                                       uint16_t *psc,

  254.                                       uint16_t *arr)

  255. {

  256.     uint64_t minimumDivider;

  257.     uint64_t periodTicks;

  258. 

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

  260.         || (arr == NULL))

  261.     {

  262.         return PLSR_RESULT_INVALID_ARGUMENT;

  263.     }

  264. 

  265.     minimumDivider = ((uint64_t)timerClockHz

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

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

  268.     if (minimumDivider == 0ULL)

  269.     {

  270.         minimumDivider = 1ULL;

  271.     }

  272.     if (minimumDivider > 65536ULL)

  273.     {

  274.         return PLSR_RESULT_DIVIDER_UNREPRESENTABLE;

  275.     }

  276.     periodTicks = ((uint64_t)timerClockHz

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

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

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

  280.     {

  281.         return PLSR_RESULT_DIVIDER_UNREPRESENTABLE;

  282.     }

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

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

  285.     return PLSR_RESULT_OK;

  286. }

  287. 

  288. static PLSR_RESULT PlsrValidateFrequencyDivider(

  289.     const PLSR_JOB_SNAPSHOT *snapshot,

  290.     uint32_t frequency,

  291.     PLSR_PARSE_DETAIL *detail,

  292.     uint16_t segment)

  293. {

  294.     uint16_t psc;

  295.     uint16_t arr;

  296.     PLSR_RESULT result;

  297. 

  298.     result = PlsrCalculateTimerDivider(snapshot->timerClockHz,

  299.                                        frequency,

  300.                                        &psc,

  301.                                        &arr);

  302.     if ((result == PLSR_RESULT_OK)

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

  304.     {

  305.         result = PlsrCalculateTimerDivider(snapshot->pairedTimerClockHz,

  306.                                            frequency,

  307.                                            &psc,

  308.                                            &arr);

  309.     }

  310.     if (result != PLSR_RESULT_OK)

  311.     {

  312.         PlsrSetDetail(detail,

  313.                       PLSR_RESULT_DIVIDER_UNREPRESENTABLE,

  314.                       PLSR_PARSE_BLOCK_S0,

  315.                       snapshot->s0.address

  316.                           + (uint32_t)segment * PLSR_S0_SEGMENT_WORDS,

  317.                       (int32_t)frequency,

  318.                       segment);

  319.         return PLSR_RESULT_DIVIDER_UNREPRESENTABLE;

  320.     }

  321.     return PLSR_RESULT_OK;

  322. }

  323. 

  324. static PLSR_RESULT PlsrResolveOperand(const PLSR_CALL *call,

  325.                                       const PLSR_VALUE_OPERAND *operand,

  326.                                       int32_t *value,

  327.                                       PLSR_PARSE_DETAIL *detail)

  328. {

  329.     PLSR_RESULT result;

  330. 

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

  332.     {

  333.         *value = operand->constant;

  334.         return PLSR_RESULT_OK;

  335.     }

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

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

  338.     {

  339.         PlsrSetDetail(detail,

  340.                       PLSR_RESULT_INVALID_S2,

  341.                       PLSR_PARSE_BLOCK_S2,

  342.                       operand->data.address,

  343.                       (int32_t)operand->type,

  344.                       0U);

  345.         return PLSR_RESULT_INVALID_S2;

  346.     }

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

  348.                                operand->data,

  349.                                2UL,

  350.                                PLSR_PARSE_BLOCK_S2,

  351.                                detail);

  352.     if (result != PLSR_RESULT_OK)

  353.     {

  354.         return result;

  355.     }

  356.     return PlsrReadInt32(&call->source,

  357.                          operand->data.device,

  358.                          operand->data.address,

  359.                          value,

  360.                          PLSR_PARSE_BLOCK_S2,

  361.                          0U,

  362.                          detail);

  363. }

  364. 

  365. static PLSR_RESULT PlsrLoadS2(const PLSR_CALL *call,

  366.                               PLSR_JOB_SNAPSHOT *snapshot,

  367.                               PLSR_PARSE_DETAIL *detail)

  368. {

  369.     uint16_t commonBase;

  370.     uint16_t setBase;

  371.     uint16_t word;

  372.     uint16_t commonFlags;

  373.     uint16_t switchLogic;

  374.     uint16_t limitPoints;

  375.     uint32_t rawLimit;

  376.     int32_t selectedSet;

  377.     uint8_t useHsd;

  378.     PLSR_RESULT result;

  379. 

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

  381.     if (result != PLSR_RESULT_OK)

  382.     {

  383.         return result;

  384.     }

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

  386.     {

  387.         PlsrSetDetail(detail,

  388.                       PLSR_RESULT_INVALID_S2,

  389.                       PLSR_PARSE_BLOCK_S2,

  390.                       call->s2.data.address,

  391.                       selectedSet,

  392.                       0U);

  393.         return PLSR_RESULT_INVALID_S2;

  394.     }

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

  396.     commonBase = (uint16_t)(PLSR_SFD_CONFIG_START

  397.                             + (uint16_t)call->dAxis

  398.                                   * PLSR_SFD_AXIS_STRIDE);

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

  400.     {

  401.         useHsd = 1U;

  402.         setBase = (uint16_t)(PLSR_HSD_SET_BASE

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

  404.     }

  405.     else

  406.     {

  407.         useHsd = 0U;

  408.         setBase = (uint16_t)(commonBase + PLSR_SFD_SET_OFFSET

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

  410.                                    * PLSR_S2_SET_WORDS);

  411.     }

  412. 

  413.     result = PlsrReadFixedDword(useHsd,

  414.                                 setBase,

  415.                                 &snapshot->s2.defaultSpeed,

  416.                                 detail);

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

  418.     result = PlsrReadFixedWord(useHsd,

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

  420.                                &snapshot->s2.accelerationMs,

  421.                                detail);

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

  423.     result = PlsrReadFixedWord(useHsd,

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

  425.                                &snapshot->s2.decelerationMs,

  426.                                detail);

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

  428.     result = PlsrReadFixedWord(useHsd,

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

  430.                                &snapshot->s2.gapAccelerationMs,

  431.                                detail);

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

  433.     result = PlsrReadFixedWord(useHsd,

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

  435.                                &word,

  436.                                detail);

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

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

  439.     result = PlsrReadFixedDword(useHsd,

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

  441.                                 &snapshot->s2.maximumSpeed,

  442.                                 detail);

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

  444.     result = PlsrReadFixedDword(useHsd,

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

  446.                                 &snapshot->s2.startSpeed,

  447.                                 detail);

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

  449.     result = PlsrReadFixedDword(useHsd,

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

  451.                                 &snapshot->s2.stopSpeed,

  452.                                 detail);

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

  454.     result = PlsrReadFixedWord(useHsd,

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

  456.                                &word,

  457.                                detail);

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

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

  460.     {

  461.         PlsrSetDetail(detail,

  462.                       PLSR_RESULT_INVALID_S2,

  463.                       PLSR_PARSE_BLOCK_S2,

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

  465.                       word,

  466.                       0U);

  467.         return PLSR_RESULT_INVALID_S2;

  468.     }

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

  470.     result = PlsrReadFixedWord(useHsd,

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

  472.                                &word,

  473.                                detail);

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

  475.     if (word > 100U)

  476.     {

  477.         PlsrSetDetail(detail,

  478.                       PLSR_RESULT_INVALID_S2,

  479.                       PLSR_PARSE_BLOCK_S2,

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

  481.                       word,

  482.                       0U);

  483.         return PLSR_RESULT_INVALID_S2;

  484.     }

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

  486.     result = PlsrReadFixedWord(useHsd,

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

  488.                                &word,

  489.                                detail);

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

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

  492.     result = PlsrReadFixedDword(useHsd,

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

  494.                                 &snapshot->s2.zrnHighSpeed,

  495.                                 detail);

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

  497.     result = PlsrReadFixedDword(useHsd,

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

  499.                                 &snapshot->s2.zrnCrawlSpeed,

  500.                                 detail);

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

  502. 

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

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

  505.     commonFlags = word;

  506.     snapshot->directionNegativeLogic =

  507.         ((commonFlags & (1U << 1U)) != 0U) ? 1U : 0U;

  508.     snapshot->limits.softLimitEnabled =

  509.         ((commonFlags & (1U << 2U)) != 0U) ? 1U : 0U;

  510.     snapshot->equivalent.unitCode =

  511.         (uint8_t)((commonFlags >> 8U) & 0x07U);

  512. 

  513.     result = PlsrReadFixedWord(0U,

  514.                                (uint16_t)(commonBase + 8U),

  515.                                &snapshot->positiveBacklashPulses,

  516.                                detail);

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

  518.     result = PlsrReadFixedWord(0U,

  519.                                (uint16_t)(commonBase + 9U),

  520.                                &snapshot->negativeBacklashPulses,

  521.                                detail);

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

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

  524.     {

  525.         PlsrSetDetail(detail,

  526.                       PLSR_RESULT_INVALID_S2,

  527.                       PLSR_PARSE_BLOCK_S2,

  528.                       commonBase,

  529.                       snapshot->equivalent.unitCode,

  530.                       0U);

  531.         return PLSR_RESULT_INVALID_S2;

  532.     }

  533.     result = PlsrReadFixedDword(0U,

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

  535.                                 &snapshot->equivalent.pulsesPerRevolution,

  536.                                 detail);

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

  538.     result = PlsrReadFixedDword(0U,

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

  540.                                 &snapshot->equivalent.movementPerRevolution,

  541.                                 detail);

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

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

  544.         != PLSR_RESULT_OK)

  545.     {

  546.         uint16_t invalidAddress =

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

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

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

  550. 

  551.         PlsrSetDetail(detail,

  552.                       PLSR_RESULT_INVALID_S2,

  553.                       PLSR_PARSE_BLOCK_S2,

  554.                       invalidAddress,

  555.                       0,

  556.                       0U);

  557.         return PLSR_RESULT_INVALID_S2;

  558.     }

  559. 

  560.     result = PlsrReadFixedWord(0U,

  561.                                (uint16_t)(commonBase + 12U),

  562.                                &switchLogic,

  563.                                detail);

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

  565.     result = PlsrReadFixedWord(0U,

  566.                                (uint16_t)(commonBase + 15U),

  567.                                &limitPoints,

  568.                                detail);

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

  570.     snapshot->limits.positiveInputPoint = (uint8_t)(limitPoints & 0xFFU);

  571.     snapshot->limits.negativeInputPoint = (uint8_t)(limitPoints >> 8U);

  572.     snapshot->limits.positiveInputActiveLow =

  573.         ((switchLogic & (1U << 2U)) != 0U) ? 1U : 0U;

  574.     snapshot->limits.negativeInputActiveLow =

  575.         ((switchLogic & (1U << 3U)) != 0U) ? 1U : 0U;

  576.     if (((snapshot->limits.positiveInputPoint != 0xFFU)

  577.          || (snapshot->limits.negativeInputPoint != 0xFFU))

  578.         && (call->source.readBit == NULL))

  579.     {

  580.         PlsrSetDetail(detail,

  581.                       PLSR_RESULT_DATA_ACCESS,

  582.                       PLSR_PARSE_BLOCK_S2,

  583.                       (uint16_t)(commonBase + 15U),

  584.                       limitPoints,

  585.                       0U);

  586.         return PLSR_RESULT_DATA_ACCESS;

  587.     }

  588. 

  589.     result = PlsrReadFixedDword(0U,

  590.                                 (uint16_t)(commonBase + 30U),

  591.                                 &rawLimit,

  592.                                 detail);

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

  594.     result = PlsrPositionAbsoluteUnitsToPulses(

  595.         &snapshot->equivalent,

  596.         (int32_t)rawLimit,

  597.         &snapshot->limits.positiveSoftLimitPulses);

  598.     if (result != PLSR_RESULT_OK)

  599.     {

  600.         PlsrSetDetail(detail,

  601.                       PLSR_RESULT_POSITION_OVERFLOW,

  602.                       PLSR_PARSE_BLOCK_POSITION,

  603.                       (uint16_t)(commonBase + 30U),

  604.                       (int32_t)rawLimit,

  605.                       0U);

  606.         return PLSR_RESULT_POSITION_OVERFLOW;

  607.     }

  608.     result = PlsrReadFixedDword(0U,

  609.                                 (uint16_t)(commonBase + 32U),

  610.                                 &rawLimit,

  611.                                 detail);

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

  613.     result = PlsrPositionAbsoluteUnitsToPulses(

  614.         &snapshot->equivalent,

  615.         (int32_t)rawLimit,

  616.         &snapshot->limits.negativeSoftLimitPulses);

  617.     if (result != PLSR_RESULT_OK)

  618.     {

  619.         PlsrSetDetail(detail,

  620.                       PLSR_RESULT_POSITION_OVERFLOW,

  621.                       PLSR_PARSE_BLOCK_POSITION,

  622.                       (uint16_t)(commonBase + 32U),

  623.                       (int32_t)rawLimit,

  624.                       0U);

  625.         return PLSR_RESULT_POSITION_OVERFLOW;

  626.     }

  627.     if ((snapshot->limits.softLimitEnabled != 0U)

  628.         && (snapshot->limits.positiveSoftLimitPulses

  629.             <= snapshot->limits.negativeSoftLimitPulses))

  630.     {

  631.         PlsrSetDetail(detail,

  632.                       PLSR_RESULT_INVALID_S2,

  633.                       PLSR_PARSE_BLOCK_S2,

  634.                       (uint16_t)(commonBase + 30U),

  635.                       (int32_t)rawLimit,

  636.                       0U);

  637.         return PLSR_RESULT_INVALID_S2;

  638.     }

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

  640.     {

  641.         snapshot->outputMode = ((commonFlags & (1U << 13U)) != 0U)

  642.                                    ? (uint8_t)PLSR_OUTPUT_AB

  643.                                    : (uint8_t)PLSR_OUTPUT_PULSE_DIR;

  644.     }

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

  646.     {

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

  648.     }

  649.     else

  650.     {

  651.         PlsrSetDetail(detail,

  652.                       PLSR_RESULT_INVALID_RESOURCE,

  653.                       PLSR_PARSE_BLOCK_OUTPUT,

  654.                       commonBase,

  655.                       call->outputModeOverride,

  656.                       0U);

  657.         return PLSR_RESULT_INVALID_RESOURCE;

  658.     }

  659.     result = PlsrReadFixedWord(0U,

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

  661.                                &word,

  662.                                detail);

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

  664.     if (word > UINT8_MAX)

  665.     {

  666.         PlsrSetDetail(detail,

  667.                       PLSR_RESULT_INVALID_RESOURCE,

  668.                       PLSR_PARSE_BLOCK_OUTPUT,

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

  670.                       word,

  671.                       0U);

  672.         return PLSR_RESULT_INVALID_RESOURCE;

  673.     }

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

  675.     result = PlsrReadFixedWord(0U,

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

  677.                                &snapshot->s2.directionDelayMs,

  678.                                detail);

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

  680. 

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

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

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

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

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

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

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

  688.     {

  689.         PlsrSetDetail(detail,

  690.                       PLSR_RESULT_INVALID_S2,

  691.                       PLSR_PARSE_BLOCK_S2,

  692.                       setBase,

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

  694.                       0U);

  695.         return PLSR_RESULT_INVALID_S2;

  696.     }

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

  698.     {

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

  700.         snapshot->speedClamped = 1U;

  701.     }

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

  703.     {

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

  705.         snapshot->speedClamped = 1U;

  706.     }

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

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

  709.     return PLSR_RESULT_OK;

  710. }

  711. 

  712. PLSR_RESULT PlsrReadLiveFrequencyRaw(const PLSR_JOB_SNAPSHOT *snapshot,

  713.                                      uint16_t segment,

  714.                                      int32_t *rawFrequency)

  715. {

  716.     uint32_t segmentAddress;

  717. 

  718.     if ((snapshot == NULL) || (rawFrequency == NULL)

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

  720.     {

  721.         return PLSR_RESULT_INVALID_ARGUMENT;

  722.     }

  723.     segmentAddress = snapshot->s0.address

  724.                      + (uint32_t)segment * PLSR_S0_SEGMENT_WORDS;

  725.     return PlsrReadInt32(&snapshot->source,

  726.                          snapshot->s0.device,

  727.                          segmentAddress,

  728.                          rawFrequency,

  729.                          PLSR_PARSE_BLOCK_S0,

  730.                          segment,

  731.                          NULL);

  732. }

  733. 

  734. static PLSR_RESULT PlsrValidateVariableReference(

  735.     const PLSR_CALL *call,

  736.     uint8_t sourceCode,

  737.     int32_t addressValue,

  738.     uint8_t bitReference,

  739.     int32_t *currentValue,

  740.     PLSR_PARSE_BLOCK block,

  741.     uint16_t segment,

  742.     PLSR_PARSE_DETAIL *detail)

  743. {

  744.     PLSR_DEVICE_TYPE device;

  745.     PLSR_DATA_REF reference;

  746.     uint8_t bitValue;

  747.     PLSR_RESULT result;

  748. 

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

  750.     {

  751.         PlsrSetDetail(detail,

  752.                       (block == PLSR_PARSE_BLOCK_S0)

  753.                           ? PLSR_RESULT_INVALID_WAIT

  754.                           : PLSR_RESULT_DATA_ACCESS,

  755.                       block,

  756.                       (uint32_t)addressValue,

  757.                       sourceCode,

  758.                       segment);

  759.         return (block == PLSR_PARSE_BLOCK_S0) ? PLSR_RESULT_INVALID_WAIT

  760.                                               : PLSR_RESULT_DATA_ACCESS;

  761.     }

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

  763.     if (bitReference != 0U)

  764.     {

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

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

  767.                                      device,

  768.                                      (uint32_t)addressValue,

  769.                                      &bitValue)

  770.                 == 0U))

  771.         {

  772.             PlsrSetDetail(detail,

  773.                           PLSR_RESULT_INVALID_WAIT,

  774.                           block,

  775.                           (uint32_t)addressValue,

  776.                           sourceCode,

  777.                           segment);

  778.             return PLSR_RESULT_INVALID_WAIT;

  779.         }

  780.         *currentValue = (int32_t)bitValue;

  781.         return PLSR_RESULT_OK;

  782.     }

  783. 

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

  785.     {

  786.         PlsrSetDetail(detail,

  787.                       PLSR_RESULT_INVALID_WAIT,

  788.                       block,

  789.                       (uint32_t)addressValue,

  790.                       sourceCode,

  791.                       segment);

  792.         return PLSR_RESULT_INVALID_WAIT;

  793.     }

  794.     reference.device = device;

  795.     reference.address = (uint32_t)addressValue;

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

  797.                                reference,

  798.                                2UL,

  799.                                block,

  800.                                detail);

  801.     if (result != PLSR_RESULT_OK)

  802.     {

  803.         return result;

  804.     }

  805.     return PlsrReadInt32(&call->source,

  806.                          device,

  807.                          reference.address,

  808.                          currentValue,

  809.                          block,

  810.                          segment,

  811.                          detail);

  812. }

  813. 

  814. static PLSR_RESULT PlsrValidateWait(const PLSR_CALL *call,

  815.                                     PLSR_SEGMENT_SNAPSHOT *segmentData,

  816.                                     uint16_t segment,

  817.                                     PLSR_PARSE_DETAIL *detail)

  818. {

  819.     int32_t currentValue;

  820.     PLSR_RESULT result;

  821. 

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

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

  824.     {

  825.         goto invalidWait;

  826.     }

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

  828.     {

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

  830.         {

  831.             goto invalidWait;

  832.         }

  833.         return PLSR_RESULT_OK;

  834.     }

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

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

  837.     {

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

  839.         {

  840.             currentValue = segmentData->waitValueOrAddress;

  841.         }

  842.         else

  843.         {

  844.             if (segmentData->waitSource > PLSR_VALUE_FD)

  845.             {

  846.                 goto invalidWait;

  847.             }

  848.             result = PlsrValidateVariableReference(call,

  849.                                                    segmentData->waitSource,

  850.                                                    segmentData->waitValueOrAddress,

  851.                                                    0U,

  852.                                                    &currentValue,

  853.                                                    PLSR_PARSE_BLOCK_S0,

  854.                                                    segment,

  855.                                                    detail);

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

  857.         }

  858.         if (currentValue < 0) goto invalidWait;

  859.         return PLSR_RESULT_OK;

  860.     }

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

  862.     {

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

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

  865.         {

  866.             goto invalidWait;

  867.         }

  868.     }

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

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

  871.     {

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

  873.         {

  874.             goto invalidWait;

  875.         }

  876.     }

  877.     result = PlsrValidateVariableReference(call,

  878.                                            segmentData->waitSource,

  879.                                            segmentData->waitValueOrAddress,

  880.                                            1U,

  881.                                            &currentValue,

  882.                                            PLSR_PARSE_BLOCK_S0,

  883.                                            segment,

  884.                                            detail);

  885.     return result;

  886. 

  887. invalidWait:

  888.     PlsrSetDetail(detail,

  889.                   PLSR_RESULT_INVALID_WAIT,

  890.                   PLSR_PARSE_BLOCK_S0,

  891.                   call->s0.address

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

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

  894.                       | segmentData->waitSource,

  895.                   segment);

  896.     return PLSR_RESULT_INVALID_WAIT;

  897. }

  898. 

  899. static PLSR_RESULT PlsrValidateJump(const PLSR_CALL *call,

  900.                                     const PLSR_JOB_SNAPSHOT *snapshot,

  901.                                     PLSR_SEGMENT_SNAPSHOT *segmentData,

  902.                                     uint16_t segment,

  903.                                     int32_t *resolvedJump,

  904.                                     PLSR_PARSE_DETAIL *detail)

  905. {

  906.     PLSR_RESULT result;

  907. 

  908.     if (segmentData->jumpSource > PLSR_VALUE_FD)

  909.     {

  910.         goto invalidJump;

  911.     }

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

  913.     {

  914.         *resolvedJump = segmentData->jumpValueOrAddress;

  915.     }

  916.     else

  917.     {

  918.         result = PlsrValidateVariableReference(call,

  919.                                                segmentData->jumpSource,

  920.                                                segmentData->jumpValueOrAddress,

  921.                                                0U,

  922.                                                resolvedJump,

  923.                                                PLSR_PARSE_BLOCK_NONE,

  924.                                                segment,

  925.                                                detail);

  926.         if (result != PLSR_RESULT_OK)

  927.         {

  928.             PlsrSetDetail(detail,

  929.                           PLSR_RESULT_INVALID_JUMP,

  930.                           PLSR_PARSE_BLOCK_S0,

  931.                           (uint32_t)segmentData->jumpValueOrAddress,

  932.                           segmentData->jumpSource,

  933.                           segment);

  934.             return PLSR_RESULT_INVALID_JUMP;

  935.         }

  936.     }

  937.     if ((*resolvedJump < 0)

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

  939.     {

  940.         goto invalidJump;

  941.     }

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

  943.     {

  944.         segmentData->flags |= PLSR_SEGMENT_FLAG_SELF_LOOP;

  945.     }

  946.     return PLSR_RESULT_OK;

  947. 

  948. invalidJump:

  949.     PlsrSetDetail(detail,

  950.                   PLSR_RESULT_INVALID_JUMP,

  951.                   PLSR_PARSE_BLOCK_S0,

  952.                   call->s0.address

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

  954.                   *resolvedJump,

  955.                   segment);

  956.     return PLSR_RESULT_INVALID_JUMP;

  957. }

  958. 

  959. static PLSR_RESULT PlsrCheckConstantPath(PLSR_JOB_SNAPSHOT *snapshot,

  960.                                          PLSR_PARSE_DETAIL *detail)

  961. {

  962.     uint8_t visited[PLSR_MAX_SEGMENTS];

  963.     uint16_t segment = snapshot->startSegment;

  964.     int32_t next;

  965. 

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

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

  968.     {

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

  970.         {

  971.             PlsrSetDetail(detail,

  972.                           PLSR_RESULT_PATH_CYCLE,

  973.                           PLSR_PARSE_BLOCK_S0,

  974.                           snapshot->s0.address

  975.                               + (uint32_t)segment * PLSR_S0_SEGMENT_WORDS

  976.                               + 8UL,

  977.                           segment,

  978.                           segment);

  979.             return PLSR_RESULT_PATH_CYCLE;

  980.         }

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

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

  983.             != PLSR_VALUE_CONSTANT)

  984.         {

  985.             return PLSR_RESULT_OK;

  986.         }

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

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

  989.         {

  990.             snapshot->hasSelfLoop = 1U;

  991.             return PLSR_RESULT_OK;

  992.         }

  993.         if (next == 0)

  994.         {

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

  996.             {

  997.                 return PLSR_RESULT_OK;

  998.             }

  999.             segment++;

  1000.         }

  1001.         else

  1002.         {

  1003.             segment = (uint16_t)next;

  1004.         }

  1005.     }

  1006.     return PLSR_RESULT_OK;

  1007. }

  1008. 

  1009. static PLSR_RESULT PlsrCheckInitialPosition(

  1010.     PLSR_JOB_SNAPSHOT *snapshot,

  1011.     const PLSR_PARSE_CONTEXT *context,

  1012.     PLSR_PARSE_DETAIL *detail)

  1013. {

  1014.     uint8_t visited[PLSR_MAX_SEGMENTS];

  1015.     int64_t position = context->logicalPosition;

  1016.     int64_t movement;

  1017.     int64_t targetPosition;

  1018.     int64_t remainder = 0;

  1019.     int32_t next;

  1020.     uint16_t segment = snapshot->startSegment;

  1021.     PLSR_RESULT result;

  1022. 

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

  1024.     {

  1025.         PlsrSetDetail(detail,

  1026.                       PLSR_RESULT_POSITION_INVALID,

  1027.                       PLSR_PARSE_BLOCK_POSITION,

  1028.                       snapshot->s1.address,

  1029.                       1,

  1030.                       0U);

  1031.         return PLSR_RESULT_POSITION_INVALID;

  1032.     }

  1033. 

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

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

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

  1037.     {

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

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

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

  1041.         {

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

  1043.                                                 segmentData->pulseOrTarget,

  1044.                                                 remainder,

  1045.                                                 &movement,

  1046.                                                 &remainder);

  1047.             if (result != PLSR_RESULT_OK)

  1048.             {

  1049.                 PlsrSetDetail(detail,

  1050.                               PLSR_RESULT_POSITION_OVERFLOW,

  1051.                               PLSR_PARSE_BLOCK_POSITION,

  1052.                               snapshot->s0.address

  1053.                                   + (uint32_t)segment

  1054.                                         * PLSR_S0_SEGMENT_WORDS

  1055.                                   + 2UL,

  1056.                               segmentData->pulseOrTarget,

  1057.                               segment);

  1058.                 return PLSR_RESULT_POSITION_OVERFLOW;

  1059.             }

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

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

  1062.             {

  1063.                 PlsrSetDetail(detail,

  1064.                               PLSR_RESULT_POSITION_OVERFLOW,

  1065.                               PLSR_PARSE_BLOCK_POSITION,

  1066.                               snapshot->s0.address

  1067.                                   + (uint32_t)segment

  1068.                                         * PLSR_S0_SEGMENT_WORDS

  1069.                                   + 2UL,

  1070.                               movement,

  1071.                               segment);

  1072.                 return PLSR_RESULT_POSITION_OVERFLOW;

  1073.             }

  1074.             position += movement;

  1075.         }

  1076.         else

  1077.         {

  1078.             result = PlsrPositionAbsoluteUnitsToPulses(

  1079.                 &snapshot->equivalent,

  1080.                 segmentData->pulseOrTarget,

  1081.                 &targetPosition);

  1082.             if (result != PLSR_RESULT_OK)

  1083.             {

  1084.                 return PLSR_RESULT_POSITION_OVERFLOW;

  1085.             }

  1086.             movement = (targetPosition > position)

  1087.                            ? 1

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

  1089.             position = targetPosition;

  1090.         }

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

  1092.         {

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

  1094.         }

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

  1096.         {

  1097.             break;

  1098.         }

  1099.         next = segmentData->jumpValueOrAddress;

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

  1101.         {

  1102.             break;

  1103.         }

  1104.         if (next == 0)

  1105.         {

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

  1107.             segment++;

  1108.         }

  1109.         else

  1110.         {

  1111.             segment = (uint16_t)next;

  1112.         }

  1113.     }

  1114.     snapshot->initialDirectionPositive =

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

  1116.     return PLSR_RESULT_OK;

  1117. }

  1118. 

  1119. static PLSR_RESULT PlsrConvertSnapshotSpeeds(

  1120.     PLSR_JOB_SNAPSHOT *snapshot,

  1121.     PLSR_PARSE_DETAIL *detail)

  1122. {

  1123.     uint16_t segment;

  1124.     PLSR_RESULT result;

  1125. 

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

  1127.                                                 snapshot->s2.defaultSpeed,

  1128.                                                 &snapshot->s2.defaultSpeed);

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

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

  1131.                                                 snapshot->s2.maximumSpeed,

  1132.                                                 &snapshot->s2.maximumSpeed);

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

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

  1135.                                                 snapshot->s2.startSpeed,

  1136.                                                 &snapshot->s2.startSpeed);

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

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

  1139.                                                 snapshot->s2.stopSpeed,

  1140.                                                 &snapshot->s2.stopSpeed);

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

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

  1143.                                                 snapshot->s2.zrnHighSpeed,

  1144.                                                 &snapshot->s2.zrnHighSpeed);

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

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

  1147.                                                 snapshot->s2.zrnCrawlSpeed,

  1148.                                                 &snapshot->s2.zrnCrawlSpeed);

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

  1150. 

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

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

  1153.     {

  1154.         PlsrSetDetail(detail,

  1155.                       PLSR_RESULT_INVALID_FREQUENCY,

  1156.                       PLSR_PARSE_BLOCK_S2,

  1157.                       0UL,

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

  1159.                       0U);

  1160.         return PLSR_RESULT_INVALID_FREQUENCY;

  1161.     }

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

  1163.     {

  1164.         PLSR_SEGMENT_SNAPSHOT *segmentData =

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

  1166. 

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

  1168.         {

  1169.             continue;

  1170.         }

  1171.         result = PlsrPositionSpeedToPulseFrequency(

  1172.             &snapshot->equivalent,

  1173.             segmentData->targetFrequency,

  1174.             &segmentData->targetFrequency);

  1175.         if ((result != PLSR_RESULT_OK)

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

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

  1178.         {

  1179.             PlsrSetDetail(detail,

  1180.                           PLSR_RESULT_INVALID_FREQUENCY,

  1181.                           PLSR_PARSE_BLOCK_S0,

  1182.                           snapshot->s0.address

  1183.                               + (uint32_t)segment * PLSR_S0_SEGMENT_WORDS,

  1184.                           (int32_t)segmentData->targetFrequency,

  1185.                           segment);

  1186.             return PLSR_RESULT_INVALID_FREQUENCY;

  1187.         }

  1188.         result = PlsrValidateFrequencyDivider(snapshot,

  1189.                                                segmentData->targetFrequency,

  1190.                                                detail,

  1191.                                                segment);

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

  1193.     }

  1194.     return PLSR_RESULT_OK;

  1195. }

  1196. 

  1197. PLSR_RESULT PlsrBuildJobSnapshot(const PLSR_CALL *call,

  1198.                                  const PLSR_PARSE_CONTEXT *context,

  1199.                                  PLSR_JOB_SNAPSHOT *snapshot,

  1200.                                  PLSR_PARSE_DETAIL *detail)

  1201. {

  1202.     uint64_t s0Words64;

  1203.     uint32_t s0Words;

  1204.     uint32_t segmentBase;

  1205.     int32_t intValue;

  1206.     int32_t resolvedJump;

  1207.     uint16_t word;

  1208.     uint16_t segment;

  1209.     uint8_t index;

  1210.     PLSR_RESULT result;

  1211. 

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

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

  1214.     {

  1215.         return PLSR_RESULT_INVALID_ARGUMENT;

  1216.     }

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

  1218.     {

  1219.         return PLSR_RESULT_INVALID_AXIS;

  1220.     }

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

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

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

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

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

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

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

  1228.                                  ? PLSR_TIMER_168MHZ

  1229.                                  : PLSR_TIMER_84MHZ;

  1230. 

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

  1232.                                call->s0,

  1233.                                PLSR_S0_HEADER_WORDS,

  1234.                                PLSR_PARSE_BLOCK_S0,

  1235.                                detail);

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

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

  1238.                            call->s0.device,

  1239.                            call->s0.address,

  1240.                            &intValue,

  1241.                            PLSR_PARSE_BLOCK_S0,

  1242.                            0U,

  1243.                            detail);

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

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

  1246.     {

  1247.         if (result == PLSR_RESULT_OK)

  1248.         {

  1249.             PlsrSetDetail(detail,

  1250.                           PLSR_RESULT_SEGMENT_OVERFLOW,

  1251.                           PLSR_PARSE_BLOCK_S0,

  1252.                           call->s0.address,

  1253.                           intValue,

  1254.                           0U);

  1255.             result = PLSR_RESULT_SEGMENT_OVERFLOW;

  1256.         }

  1257.         return result;

  1258.     }

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

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

  1261.                 + PLSR_S0_HEADER_WORDS;

  1262.     if (s0Words64 > UINT32_MAX)

  1263.     {

  1264.         return PLSR_RESULT_ADDRESS_OVERFLOW;

  1265.     }

  1266.     s0Words = (uint32_t)s0Words64;

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

  1268.                                call->s0,

  1269.                                s0Words,

  1270.                                PLSR_PARSE_BLOCK_S0,

  1271.                                detail);

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

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

  1274.                                call->s1,

  1275.                                PLSR_S1_WORDS,

  1276.                                PLSR_PARSE_BLOCK_S1,

  1277.                                detail);

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

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

  1280.     {

  1281.         PlsrSetDetail(detail,

  1282.                       PLSR_RESULT_BLOCK_OVERLAP,

  1283.                       PLSR_PARSE_BLOCK_S1,

  1284.                       call->s1.address,

  1285.                       (int32_t)s0Words,

  1286.                       0U);

  1287.         return PLSR_RESULT_BLOCK_OVERLAP;

  1288.     }

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

  1290.     {

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

  1292.                               call->s0.device,

  1293.                               call->s0.address + index,

  1294.                               &word,

  1295.                               PLSR_PARSE_BLOCK_S0,

  1296.                               0U,

  1297.                               detail);

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

  1299.         if (word != 0U)

  1300.         {

  1301.             PlsrSetDetail(detail,

  1302.                           PLSR_RESULT_RESERVED_NOT_ZERO,

  1303.                           PLSR_PARSE_BLOCK_S0,

  1304.                           call->s0.address + index,

  1305.                           word,

  1306.                           0U);

  1307.             return PLSR_RESULT_RESERVED_NOT_ZERO;

  1308.         }

  1309.     }

  1310. 

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

  1312.                            call->s1.device,

  1313.                            call->s1.address,

  1314.                            &intValue,

  1315.                            PLSR_PARSE_BLOCK_S1,

  1316.                            0U,

  1317.                            detail);

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

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

  1320.     {

  1321.         PlsrSetDetail(detail,

  1322.                       PLSR_RESULT_INVALID_POSITION_MODE,

  1323.                       PLSR_PARSE_BLOCK_S1,

  1324.                       call->s1.address,

  1325.                       intValue,

  1326.                       0U);

  1327.         return PLSR_RESULT_INVALID_POSITION_MODE;

  1328.     }

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

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

  1331.                            call->s1.device,

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

  1333.                            &intValue,

  1334.                            PLSR_PARSE_BLOCK_S1,

  1335.                            0U,

  1336.                            detail);

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

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

  1339.     {

  1340.         PlsrSetDetail(detail,

  1341.                       PLSR_RESULT_INVALID_ARGUMENT,

  1342.                       PLSR_PARSE_BLOCK_S1,

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

  1344.                       intValue,

  1345.                       0U);

  1346.         return PLSR_RESULT_INVALID_ARGUMENT;

  1347.     }

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

  1349. 

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

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

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

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

  1354.     {

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

  1356.         {

  1357.             PlsrSetDetail(detail,

  1358.                           PLSR_RESULT_INVALID_RESOURCE,

  1359.                           PLSR_PARSE_BLOCK_OUTPUT,

  1360.                           call->dAxis,

  1361.                           snapshot->outputMode,

  1362.                           0U);

  1363.             return PLSR_RESULT_INVALID_RESOURCE;

  1364.         }

  1365.         snapshot->pairedTimerClockHz = PLSR_TIMER_84MHZ;

  1366.     }

  1367. 

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

  1369.     {

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

  1371.         segmentBase = call->s0.address

  1372.                       + (uint32_t)segment * PLSR_S0_SEGMENT_WORDS;

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

  1374.                                call->s0.device,

  1375.                                segmentBase,

  1376.                                &intValue,

  1377.                                PLSR_PARSE_BLOCK_S0,

  1378.                                segment,

  1379.                                detail);

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

  1381.         if (intValue < 0)

  1382.         {

  1383.             PlsrSetDetail(detail,

  1384.                           PLSR_RESULT_INVALID_FREQUENCY,

  1385.                           PLSR_PARSE_BLOCK_S0,

  1386.                           segmentBase,

  1387.                           intValue,

  1388.                           segment);

  1389.             return PLSR_RESULT_INVALID_FREQUENCY;

  1390.         }

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

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

  1393.                                call->s0.device,

  1394.                                segmentBase + 2UL,

  1395.                                &segmentData->pulseOrTarget,

  1396.                                PLSR_PARSE_BLOCK_S0,

  1397.                                segment,

  1398.                                detail);

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

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

  1401.                               call->s0.device,

  1402.                               segmentBase + 4UL,

  1403.                               &word,

  1404.                               PLSR_PARSE_BLOCK_S0,

  1405.                               segment,

  1406.                               detail);

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

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

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

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

  1411.                                call->s0.device,

  1412.                                segmentBase + 5UL,

  1413.                                &segmentData->waitValueOrAddress,

  1414.                                PLSR_PARSE_BLOCK_S0,

  1415.                                segment,

  1416.                                detail);

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

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

  1419.                               call->s0.device,

  1420.                               segmentBase + 7UL,

  1421.                               &word,

  1422.                               PLSR_PARSE_BLOCK_S0,

  1423.                               segment,

  1424.                               detail);

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

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

  1427.         {

  1428.             PlsrSetDetail(detail,

  1429.                           PLSR_RESULT_RESERVED_NOT_ZERO,

  1430.                           PLSR_PARSE_BLOCK_S0,

  1431.                           segmentBase + 7UL,

  1432.                           word,

  1433.                           segment);

  1434.             return PLSR_RESULT_RESERVED_NOT_ZERO;

  1435.         }

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

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

  1438.                                call->s0.device,

  1439.                                segmentBase + 8UL,

  1440.                                &segmentData->jumpValueOrAddress,

  1441.                                PLSR_PARSE_BLOCK_S0,

  1442.                                segment,

  1443.                                detail);

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

  1445. 

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

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

  1448.         {

  1449.             segmentData->flags |= PLSR_SEGMENT_FLAG_ZERO_PULSE;

  1450.             segmentData->targetFrequency = 0UL;

  1451.         }

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

  1453.         {

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

  1455.             {

  1456.                 PlsrSetDetail(detail,

  1457.                               PLSR_RESULT_INVALID_FREQUENCY,

  1458.                               PLSR_PARSE_BLOCK_S2,

  1459.                               0UL,

  1460.                               0,

  1461.                               segment);

  1462.                 return PLSR_RESULT_INVALID_FREQUENCY;

  1463.             }

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

  1465.             segmentData->flags |= PLSR_SEGMENT_FLAG_DEFAULT_SPEED;

  1466.         }

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

  1468.         {

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

  1470.             segmentData->flags |= PLSR_SEGMENT_FLAG_SPEED_CLAMPED;

  1471.             snapshot->speedClamped = 1U;

  1472.         }

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

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

  1475.         result = PlsrValidateJump(call,

  1476.                                   snapshot,

  1477.                                   segmentData,

  1478.                                   segment,

  1479.                                   &resolvedJump,

  1480.                                   detail);

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

  1482.     }

  1483. 

  1484.     result = PlsrConvertSnapshotSpeeds(snapshot, detail);

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

  1486.     result = PlsrCheckConstantPath(snapshot, detail);

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

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

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

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

  1491.     return PLSR_RESULT_OK;

  1492. }

  1493. 

  1494. PLSR_RESULT PlsrResolveLiveFrequency(const PLSR_JOB_SNAPSHOT *snapshot,

  1495.                                      uint16_t segment,

  1496.                                      uint32_t *frequency,

  1497.                                      uint8_t *clamped)

  1498. {

  1499.     int32_t rawFrequency;

  1500.     PLSR_RESULT result;

  1501. 

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

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

  1504.     {

  1505.         return PLSR_RESULT_INVALID_ARGUMENT;

  1506.     }

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

  1508.          & PLSR_SEGMENT_FLAG_ZERO_PULSE)

  1509.         != 0U)

  1510.     {

  1511.         *frequency = 0UL;

  1512.         *clamped = 0U;

  1513.         return PLSR_RESULT_OK;

  1514.     }

  1515.     result = PlsrReadLiveFrequencyRaw(snapshot, segment, &rawFrequency);

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

  1517.     if (rawFrequency < 0) return PLSR_RESULT_INVALID_FREQUENCY;

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

  1519.                                     : (uint32_t)rawFrequency;

  1520.     *clamped = 0U;

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

  1522.     {

  1523.         *frequency = snapshot->inputMaximumSpeed;

  1524.         *clamped = 1U;

  1525.     }

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

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

  1528.                                                 *frequency,

  1529.                                                 frequency);

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

  1531.         || (*frequency > PLSR_FREQUENCY_MAX_HZ))

  1532.     {

  1533.         return PLSR_RESULT_INVALID_FREQUENCY;

  1534.     }

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

  1536. }