yuwenhao
/
Modbus-rtu
1
0
Atdalīts 0
Kods Problēmas 0 Izmaiņu pieprasījumi 0 Laidieni 0 Vikivietne Aktivitāte
Nevar pievienot vairāk kā 25 tēmas Tēmai ir jāsākas ar burtu vai ciparu, tā var saturēt domu zīmes ('-') un var būt līdz 35 simboliem gara.
39 Revīzijas
3 Atzari
138 MiB
 
 
 
 
 
 
Koks: c776438bcd
Atzari Tagi
${ item.name }
Izveidot atzaru ${ searchTerm }
no 'c776438bcd'
${ noResults }
Modbus-rtu/PLSR/Src/plsr_job.c

1496 rindas
54 KiB
Neapstrādāts Vainot Vēsture 

  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.     uint16_t commonFlags;

  356.     uint16_t switchLogic;

  357.     uint16_t limitPoints;

  358.     uint32_t rawLimit;

  359.     int32_t selectedSet;

  360.     uint8_t useHsd;

  361.     PLSR_RESULT result;

  362. 

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

  364.     if (result != PLSR_RESULT_OK)

  365.     {

  366.         return result;

  367.     }

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

  369.     {

  370.         PlsrSetDetail(detail,

  371.                       PLSR_RESULT_INVALID_S2,

  372.                       PLSR_PARSE_BLOCK_S2,

  373.                       call->s2.data.address,

  374.                       selectedSet,

  375.                       0U);

  376.         return PLSR_RESULT_INVALID_S2;

  377.     }

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

  379.     commonBase = (uint16_t)(PLSR_SFD_CONFIG_START

  380.                             + (uint16_t)call->dAxis

  381.                                   * PLSR_SFD_AXIS_STRIDE);

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

  383.     {

  384.         useHsd = 1U;

  385.         setBase = (uint16_t)(PLSR_HSD_SET_BASE

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

  387.     }

  388.     else

  389.     {

  390.         useHsd = 0U;

  391.         setBase = (uint16_t)(commonBase + PLSR_SFD_SET_OFFSET

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

  393.                                    * PLSR_S2_SET_WORDS);

  394.     }

  395. 

  396.     result = PlsrReadFixedDword(useHsd,

  397.                                 setBase,

  398.                                 &snapshot->s2.defaultSpeed,

  399.                                 detail);

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

  401.     result = PlsrReadFixedWord(useHsd,

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

  403.                                &snapshot->s2.accelerationMs,

  404.                                detail);

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

  406.     result = PlsrReadFixedWord(useHsd,

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

  408.                                &snapshot->s2.decelerationMs,

  409.                                detail);

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

  411.     result = PlsrReadFixedWord(useHsd,

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

  413.                                &snapshot->s2.gapAccelerationMs,

  414.                                detail);

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

  416.     result = PlsrReadFixedWord(useHsd,

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

  418.                                &word,

  419.                                detail);

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

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

  422.     result = PlsrReadFixedDword(useHsd,

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

  424.                                 &snapshot->s2.maximumSpeed,

  425.                                 detail);

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

  427.     result = PlsrReadFixedDword(useHsd,

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

  429.                                 &snapshot->s2.startSpeed,

  430.                                 detail);

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

  432.     result = PlsrReadFixedDword(useHsd,

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

  434.                                 &snapshot->s2.stopSpeed,

  435.                                 detail);

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

  437.     result = PlsrReadFixedWord(useHsd,

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

  439.                                &word,

  440.                                detail);

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

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

  443.     {

  444.         PlsrSetDetail(detail,

  445.                       PLSR_RESULT_INVALID_S2,

  446.                       PLSR_PARSE_BLOCK_S2,

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

  448.                       word,

  449.                       0U);

  450.         return PLSR_RESULT_INVALID_S2;

  451.     }

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

  453.     result = PlsrReadFixedWord(useHsd,

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

  455.                                &word,

  456.                                detail);

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

  458.     if (word > 100U)

  459.     {

  460.         PlsrSetDetail(detail,

  461.                       PLSR_RESULT_INVALID_S2,

  462.                       PLSR_PARSE_BLOCK_S2,

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

  464.                       word,

  465.                       0U);

  466.         return PLSR_RESULT_INVALID_S2;

  467.     }

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

  469.     result = PlsrReadFixedWord(useHsd,

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

  471.                                &word,

  472.                                detail);

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

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

  475.     result = PlsrReadFixedDword(useHsd,

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

  477.                                 &snapshot->s2.zrnHighSpeed,

  478.                                 detail);

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

  480.     result = PlsrReadFixedDword(useHsd,

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

  482.                                 &snapshot->s2.zrnCrawlSpeed,

  483.                                 detail);

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

  485. 

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

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

  488.     commonFlags = word;

  489.     snapshot->directionActiveHigh =

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

  491.     snapshot->limits.softLimitEnabled =

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

  493.     snapshot->equivalent.unitCode =

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

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

  496.     {

  497.         PlsrSetDetail(detail,

  498.                       PLSR_RESULT_INVALID_S2,

  499.                       PLSR_PARSE_BLOCK_S2,

  500.                       commonBase,

  501.                       snapshot->equivalent.unitCode,

  502.                       0U);

  503.         return PLSR_RESULT_INVALID_S2;

  504.     }

  505.     result = PlsrReadFixedDword(0U,

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

  507.                                 &snapshot->equivalent.pulsesPerRevolution,

  508.                                 detail);

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

  510.     result = PlsrReadFixedDword(0U,

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

  512.                                 &snapshot->equivalent.movementPerRevolution,

  513.                                 detail);

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

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

  516.         != PLSR_RESULT_OK)

  517.     {

  518.         uint16_t invalidAddress =

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

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

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

  522. 

  523.         PlsrSetDetail(detail,

  524.                       PLSR_RESULT_INVALID_S2,

  525.                       PLSR_PARSE_BLOCK_S2,

  526.                       invalidAddress,

  527.                       0,

  528.                       0U);

  529.         return PLSR_RESULT_INVALID_S2;

  530.     }

  531. 

  532.     result = PlsrReadFixedWord(0U,

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

  534.                                &switchLogic,

  535.                                detail);

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

  537.     result = PlsrReadFixedWord(0U,

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

  539.                                &limitPoints,

  540.                                detail);

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

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

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

  544.     snapshot->limits.positiveInputActiveLow =

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

  546.     snapshot->limits.negativeInputActiveLow =

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

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

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

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

  551.     {

  552.         PlsrSetDetail(detail,

  553.                       PLSR_RESULT_DATA_ACCESS,

  554.                       PLSR_PARSE_BLOCK_S2,

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

  556.                       limitPoints,

  557.                       0U);

  558.         return PLSR_RESULT_DATA_ACCESS;

  559.     }

  560. 

  561.     result = PlsrReadFixedDword(0U,

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

  563.                                 &rawLimit,

  564.                                 detail);

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

  566.     result = PlsrPositionAbsoluteUnitsToPulses(

  567.         &snapshot->equivalent,

  568.         (int32_t)rawLimit,

  569.         &snapshot->limits.positiveSoftLimitPulses);

  570.     if (result != PLSR_RESULT_OK)

  571.     {

  572.         PlsrSetDetail(detail,

  573.                       PLSR_RESULT_POSITION_OVERFLOW,

  574.                       PLSR_PARSE_BLOCK_POSITION,

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

  576.                       (int32_t)rawLimit,

  577.                       0U);

  578.         return PLSR_RESULT_POSITION_OVERFLOW;

  579.     }

  580.     result = PlsrReadFixedDword(0U,

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

  582.                                 &rawLimit,

  583.                                 detail);

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

  585.     result = PlsrPositionAbsoluteUnitsToPulses(

  586.         &snapshot->equivalent,

  587.         (int32_t)rawLimit,

  588.         &snapshot->limits.negativeSoftLimitPulses);

  589.     if (result != PLSR_RESULT_OK)

  590.     {

  591.         PlsrSetDetail(detail,

  592.                       PLSR_RESULT_POSITION_OVERFLOW,

  593.                       PLSR_PARSE_BLOCK_POSITION,

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

  595.                       (int32_t)rawLimit,

  596.                       0U);

  597.         return PLSR_RESULT_POSITION_OVERFLOW;

  598.     }

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

  600.         && (snapshot->limits.positiveSoftLimitPulses

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

  602.     {

  603.         PlsrSetDetail(detail,

  604.                       PLSR_RESULT_INVALID_S2,

  605.                       PLSR_PARSE_BLOCK_S2,

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

  607.                       (int32_t)rawLimit,

  608.                       0U);

  609.         return PLSR_RESULT_INVALID_S2;

  610.     }

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

  612.     {

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

  614.                                    ? (uint8_t)PLSR_OUTPUT_AB

  615.                                    : (uint8_t)PLSR_OUTPUT_PULSE_DIR;

  616.     }

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

  618.     {

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

  620.     }

  621.     else

  622.     {

  623.         PlsrSetDetail(detail,

  624.                       PLSR_RESULT_INVALID_RESOURCE,

  625.                       PLSR_PARSE_BLOCK_OUTPUT,

  626.                       commonBase,

  627.                       call->outputModeOverride,

  628.                       0U);

  629.         return PLSR_RESULT_INVALID_RESOURCE;

  630.     }

  631.     result = PlsrReadFixedWord(0U,

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

  633.                                &word,

  634.                                detail);

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

  636.     if (word > UINT8_MAX)

  637.     {

  638.         PlsrSetDetail(detail,

  639.                       PLSR_RESULT_INVALID_RESOURCE,

  640.                       PLSR_PARSE_BLOCK_OUTPUT,

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

  642.                       word,

  643.                       0U);

  644.         return PLSR_RESULT_INVALID_RESOURCE;

  645.     }

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

  647.     result = PlsrReadFixedWord(0U,

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

  649.                                &snapshot->s2.directionDelayMs,

  650.                                detail);

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

  652. 

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

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

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

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

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

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

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

  660.     {

  661.         PlsrSetDetail(detail,

  662.                       PLSR_RESULT_INVALID_S2,

  663.                       PLSR_PARSE_BLOCK_S2,

  664.                       setBase,

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

  666.                       0U);

  667.         return PLSR_RESULT_INVALID_S2;

  668.     }

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

  670.     {

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

  672.         snapshot->speedClamped = 1U;

  673.     }

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

  675.     {

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

  677.         snapshot->speedClamped = 1U;

  678.     }

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

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

  681.     return PLSR_RESULT_OK;

  682. }

  683. 

  684. static PLSR_RESULT PlsrValidateVariableReference(

  685.     const PLSR_CALL *call,

  686.     uint8_t sourceCode,

  687.     int32_t addressValue,

  688.     uint8_t bitReference,

  689.     int32_t *currentValue,

  690.     PLSR_PARSE_BLOCK block,

  691.     uint16_t segment,

  692.     PLSR_PARSE_DETAIL *detail)

  693. {

  694.     PLSR_DEVICE_TYPE device;

  695.     PLSR_DATA_REF reference;

  696.     uint8_t bitValue;

  697.     PLSR_RESULT result;

  698. 

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

  700.     {

  701.         PlsrSetDetail(detail,

  702.                       (block == PLSR_PARSE_BLOCK_S0)

  703.                           ? PLSR_RESULT_INVALID_WAIT

  704.                           : PLSR_RESULT_DATA_ACCESS,

  705.                       block,

  706.                       (uint32_t)addressValue,

  707.                       sourceCode,

  708.                       segment);

  709.         return (block == PLSR_PARSE_BLOCK_S0) ? PLSR_RESULT_INVALID_WAIT

  710.                                               : PLSR_RESULT_DATA_ACCESS;

  711.     }

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

  713.     if (bitReference != 0U)

  714.     {

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

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

  717.                                      device,

  718.                                      (uint32_t)addressValue,

  719.                                      &bitValue)

  720.                 == 0U))

  721.         {

  722.             PlsrSetDetail(detail,

  723.                           PLSR_RESULT_INVALID_WAIT,

  724.                           block,

  725.                           (uint32_t)addressValue,

  726.                           sourceCode,

  727.                           segment);

  728.             return PLSR_RESULT_INVALID_WAIT;

  729.         }

  730.         *currentValue = (int32_t)bitValue;

  731.         return PLSR_RESULT_OK;

  732.     }

  733. 

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

  735.     {

  736.         PlsrSetDetail(detail,

  737.                       PLSR_RESULT_INVALID_WAIT,

  738.                       block,

  739.                       (uint32_t)addressValue,

  740.                       sourceCode,

  741.                       segment);

  742.         return PLSR_RESULT_INVALID_WAIT;

  743.     }

  744.     reference.device = device;

  745.     reference.address = (uint32_t)addressValue;

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

  747.                                reference,

  748.                                2UL,

  749.                                block,

  750.                                detail);

  751.     if (result != PLSR_RESULT_OK)

  752.     {

  753.         return result;

  754.     }

  755.     return PlsrReadInt32(&call->source,

  756.                          device,

  757.                          reference.address,

  758.                          currentValue,

  759.                          block,

  760.                          segment,

  761.                          detail);

  762. }

  763. 

  764. static PLSR_RESULT PlsrValidateWait(const PLSR_CALL *call,

  765.                                     PLSR_SEGMENT_SNAPSHOT *segmentData,

  766.                                     uint16_t segment,

  767.                                     PLSR_PARSE_DETAIL *detail)

  768. {

  769.     int32_t currentValue;

  770.     PLSR_RESULT result;

  771. 

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

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

  774.     {

  775.         goto invalidWait;

  776.     }

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

  778.     {

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

  780.         {

  781.             goto invalidWait;

  782.         }

  783.         return PLSR_RESULT_OK;

  784.     }

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

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

  787.     {

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

  789.         {

  790.             currentValue = segmentData->waitValueOrAddress;

  791.         }

  792.         else

  793.         {

  794.             if (segmentData->waitSource > PLSR_VALUE_FD)

  795.             {

  796.                 goto invalidWait;

  797.             }

  798.             result = PlsrValidateVariableReference(call,

  799.                                                    segmentData->waitSource,

  800.                                                    segmentData->waitValueOrAddress,

  801.                                                    0U,

  802.                                                    &currentValue,

  803.                                                    PLSR_PARSE_BLOCK_S0,

  804.                                                    segment,

  805.                                                    detail);

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

  807.         }

  808.         if (currentValue < 0) goto invalidWait;

  809.         return PLSR_RESULT_OK;

  810.     }

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

  812.     {

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

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

  815.         {

  816.             goto invalidWait;

  817.         }

  818.     }

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

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

  821.     {

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

  823.         {

  824.             goto invalidWait;

  825.         }

  826.     }

  827.     result = PlsrValidateVariableReference(call,

  828.                                            segmentData->waitSource,

  829.                                            segmentData->waitValueOrAddress,

  830.                                            1U,

  831.                                            &currentValue,

  832.                                            PLSR_PARSE_BLOCK_S0,

  833.                                            segment,

  834.                                            detail);

  835.     return result;

  836. 

  837. invalidWait:

  838.     PlsrSetDetail(detail,

  839.                   PLSR_RESULT_INVALID_WAIT,

  840.                   PLSR_PARSE_BLOCK_S0,

  841.                   call->s0.address

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

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

  844.                       | segmentData->waitSource,

  845.                   segment);

  846.     return PLSR_RESULT_INVALID_WAIT;

  847. }

  848. 

  849. static PLSR_RESULT PlsrValidateJump(const PLSR_CALL *call,

  850.                                     const PLSR_JOB_SNAPSHOT *snapshot,

  851.                                     PLSR_SEGMENT_SNAPSHOT *segmentData,

  852.                                     uint16_t segment,

  853.                                     int32_t *resolvedJump,

  854.                                     PLSR_PARSE_DETAIL *detail)

  855. {

  856.     PLSR_RESULT result;

  857. 

  858.     if (segmentData->jumpSource > PLSR_VALUE_FD)

  859.     {

  860.         goto invalidJump;

  861.     }

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

  863.     {

  864.         *resolvedJump = segmentData->jumpValueOrAddress;

  865.     }

  866.     else

  867.     {

  868.         result = PlsrValidateVariableReference(call,

  869.                                                segmentData->jumpSource,

  870.                                                segmentData->jumpValueOrAddress,

  871.                                                0U,

  872.                                                resolvedJump,

  873.                                                PLSR_PARSE_BLOCK_NONE,

  874.                                                segment,

  875.                                                detail);

  876.         if (result != PLSR_RESULT_OK)

  877.         {

  878.             PlsrSetDetail(detail,

  879.                           PLSR_RESULT_INVALID_JUMP,

  880.                           PLSR_PARSE_BLOCK_S0,

  881.                           (uint32_t)segmentData->jumpValueOrAddress,

  882.                           segmentData->jumpSource,

  883.                           segment);

  884.             return PLSR_RESULT_INVALID_JUMP;

  885.         }

  886.     }

  887.     if ((*resolvedJump < 0)

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

  889.     {

  890.         goto invalidJump;

  891.     }

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

  893.     {

  894.         segmentData->flags |= PLSR_SEGMENT_FLAG_SELF_LOOP;

  895.     }

  896.     return PLSR_RESULT_OK;

  897. 

  898. invalidJump:

  899.     PlsrSetDetail(detail,

  900.                   PLSR_RESULT_INVALID_JUMP,

  901.                   PLSR_PARSE_BLOCK_S0,

  902.                   call->s0.address

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

  904.                   *resolvedJump,

  905.                   segment);

  906.     return PLSR_RESULT_INVALID_JUMP;

  907. }

  908. 

  909. static PLSR_RESULT PlsrCheckConstantPath(PLSR_JOB_SNAPSHOT *snapshot,

  910.                                          PLSR_PARSE_DETAIL *detail)

  911. {

  912.     uint8_t visited[PLSR_MAX_SEGMENTS];

  913.     uint16_t segment = snapshot->startSegment;

  914.     int32_t next;

  915. 

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

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

  918.     {

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

  920.         {

  921.             PlsrSetDetail(detail,

  922.                           PLSR_RESULT_PATH_CYCLE,

  923.                           PLSR_PARSE_BLOCK_S0,

  924.                           snapshot->s0.address

  925.                               + (uint32_t)segment * PLSR_S0_SEGMENT_WORDS

  926.                               + 8UL,

  927.                           segment,

  928.                           segment);

  929.             return PLSR_RESULT_PATH_CYCLE;

  930.         }

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

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

  933.             != PLSR_VALUE_CONSTANT)

  934.         {

  935.             return PLSR_RESULT_OK;

  936.         }

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

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

  939.         {

  940.             snapshot->hasSelfLoop = 1U;

  941.             return PLSR_RESULT_OK;

  942.         }

  943.         if (next == 0)

  944.         {

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

  946.             {

  947.                 return PLSR_RESULT_OK;

  948.             }

  949.             segment++;

  950.         }

  951.         else

  952.         {

  953.             segment = (uint16_t)next;

  954.         }

  955.     }

  956.     return PLSR_RESULT_OK;

  957. }

  958. 

  959. static PLSR_RESULT PlsrCheckInitialPosition(

  960.     PLSR_JOB_SNAPSHOT *snapshot,

  961.     const PLSR_PARSE_CONTEXT *context,

  962.     PLSR_PARSE_DETAIL *detail)

  963. {

  964.     uint8_t visited[PLSR_MAX_SEGMENTS];

  965.     int64_t position = context->logicalPosition;

  966.     int64_t movement;

  967.     int64_t targetPosition;

  968.     int64_t remainder = 0;

  969.     int32_t next;

  970.     uint16_t segment = snapshot->startSegment;

  971.     PLSR_RESULT result;

  972. 

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

  974.     {

  975.         PlsrSetDetail(detail,

  976.                       PLSR_RESULT_POSITION_INVALID,

  977.                       PLSR_PARSE_BLOCK_POSITION,

  978.                       snapshot->s1.address,

  979.                       1,

  980.                       0U);

  981.         return PLSR_RESULT_POSITION_INVALID;

  982.     }

  983. 

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

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

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

  987.     {

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

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

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

  991.         {

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

  993.                                                 segmentData->pulseOrTarget,

  994.                                                 remainder,

  995.                                                 &movement,

  996.                                                 &remainder);

  997.             if (result != PLSR_RESULT_OK)

  998.             {

  999.                 PlsrSetDetail(detail,

  1000.                               PLSR_RESULT_POSITION_OVERFLOW,

  1001.                               PLSR_PARSE_BLOCK_POSITION,

  1002.                               snapshot->s0.address

  1003.                                   + (uint32_t)segment

  1004.                                         * PLSR_S0_SEGMENT_WORDS

  1005.                                   + 2UL,

  1006.                               segmentData->pulseOrTarget,

  1007.                               segment);

  1008.                 return PLSR_RESULT_POSITION_OVERFLOW;

  1009.             }

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

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

  1012.             {

  1013.                 PlsrSetDetail(detail,

  1014.                               PLSR_RESULT_POSITION_OVERFLOW,

  1015.                               PLSR_PARSE_BLOCK_POSITION,

  1016.                               snapshot->s0.address

  1017.                                   + (uint32_t)segment

  1018.                                         * PLSR_S0_SEGMENT_WORDS

  1019.                                   + 2UL,

  1020.                               movement,

  1021.                               segment);

  1022.                 return PLSR_RESULT_POSITION_OVERFLOW;

  1023.             }

  1024.             position += movement;

  1025.         }

  1026.         else

  1027.         {

  1028.             result = PlsrPositionAbsoluteUnitsToPulses(

  1029.                 &snapshot->equivalent,

  1030.                 segmentData->pulseOrTarget,

  1031.                 &targetPosition);

  1032.             if (result != PLSR_RESULT_OK)

  1033.             {

  1034.                 return PLSR_RESULT_POSITION_OVERFLOW;

  1035.             }

  1036.             movement = (targetPosition > position)

  1037.                            ? 1

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

  1039.             position = targetPosition;

  1040.         }

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

  1042.         {

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

  1044.         }

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

  1046.         {

  1047.             break;

  1048.         }

  1049.         next = segmentData->jumpValueOrAddress;

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

  1051.         {

  1052.             break;

  1053.         }

  1054.         if (next == 0)

  1055.         {

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

  1057.             segment++;

  1058.         }

  1059.         else

  1060.         {

  1061.             segment = (uint16_t)next;

  1062.         }

  1063.     }

  1064.     snapshot->initialDirectionPositive =

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

  1066.     return PLSR_RESULT_OK;

  1067. }

  1068. 

  1069. static PLSR_RESULT PlsrConvertSnapshotSpeeds(

  1070.     PLSR_JOB_SNAPSHOT *snapshot,

  1071.     PLSR_PARSE_DETAIL *detail)

  1072. {

  1073.     uint16_t segment;

  1074.     PLSR_RESULT result;

  1075. 

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

  1077.                                                 snapshot->s2.defaultSpeed,

  1078.                                                 &snapshot->s2.defaultSpeed);

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

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

  1081.                                                 snapshot->s2.maximumSpeed,

  1082.                                                 &snapshot->s2.maximumSpeed);

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

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

  1085.                                                 snapshot->s2.startSpeed,

  1086.                                                 &snapshot->s2.startSpeed);

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

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

  1089.                                                 snapshot->s2.stopSpeed,

  1090.                                                 &snapshot->s2.stopSpeed);

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

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

  1093.                                                 snapshot->s2.zrnHighSpeed,

  1094.                                                 &snapshot->s2.zrnHighSpeed);

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

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

  1097.                                                 snapshot->s2.zrnCrawlSpeed,

  1098.                                                 &snapshot->s2.zrnCrawlSpeed);

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

  1100. 

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

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

  1103.     {

  1104.         PlsrSetDetail(detail,

  1105.                       PLSR_RESULT_INVALID_FREQUENCY,

  1106.                       PLSR_PARSE_BLOCK_S2,

  1107.                       0UL,

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

  1109.                       0U);

  1110.         return PLSR_RESULT_INVALID_FREQUENCY;

  1111.     }

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

  1113.     {

  1114.         PLSR_SEGMENT_SNAPSHOT *segmentData =

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

  1116. 

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

  1118.         {

  1119.             continue;

  1120.         }

  1121.         result = PlsrPositionSpeedToPulseFrequency(

  1122.             &snapshot->equivalent,

  1123.             segmentData->targetFrequency,

  1124.             &segmentData->targetFrequency);

  1125.         if ((result != PLSR_RESULT_OK)

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

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

  1128.         {

  1129.             PlsrSetDetail(detail,

  1130.                           PLSR_RESULT_INVALID_FREQUENCY,

  1131.                           PLSR_PARSE_BLOCK_S0,

  1132.                           snapshot->s0.address

  1133.                               + (uint32_t)segment * PLSR_S0_SEGMENT_WORDS,

  1134.                           (int32_t)segmentData->targetFrequency,

  1135.                           segment);

  1136.             return PLSR_RESULT_INVALID_FREQUENCY;

  1137.         }

  1138.         result = PlsrValidateFrequencyDivider(snapshot,

  1139.                                                segmentData->targetFrequency,

  1140.                                                detail,

  1141.                                                segment);

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

  1143.     }

  1144.     return PLSR_RESULT_OK;

  1145. }

  1146. 

  1147. PLSR_RESULT PlsrBuildJobSnapshot(const PLSR_CALL *call,

  1148.                                  const PLSR_PARSE_CONTEXT *context,

  1149.                                  PLSR_JOB_SNAPSHOT *snapshot,

  1150.                                  PLSR_PARSE_DETAIL *detail)

  1151. {

  1152.     uint64_t s0Words64;

  1153.     uint32_t s0Words;

  1154.     uint32_t segmentBase;

  1155.     int32_t intValue;

  1156.     int32_t resolvedJump;

  1157.     uint16_t word;

  1158.     uint16_t segment;

  1159.     uint8_t index;

  1160.     PLSR_RESULT result;

  1161. 

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

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

  1164.     {

  1165.         return PLSR_RESULT_INVALID_ARGUMENT;

  1166.     }

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

  1168.     {

  1169.         return PLSR_RESULT_INVALID_AXIS;

  1170.     }

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

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

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

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

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

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

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

  1178.                                  ? PLSR_TIMER_168MHZ

  1179.                                  : PLSR_TIMER_84MHZ;

  1180. 

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

  1182.                                call->s0,

  1183.                                PLSR_S0_HEADER_WORDS,

  1184.                                PLSR_PARSE_BLOCK_S0,

  1185.                                detail);

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

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

  1188.                            call->s0.device,

  1189.                            call->s0.address,

  1190.                            &intValue,

  1191.                            PLSR_PARSE_BLOCK_S0,

  1192.                            0U,

  1193.                            detail);

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

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

  1196.     {

  1197.         if (result == PLSR_RESULT_OK)

  1198.         {

  1199.             PlsrSetDetail(detail,

  1200.                           PLSR_RESULT_SEGMENT_OVERFLOW,

  1201.                           PLSR_PARSE_BLOCK_S0,

  1202.                           call->s0.address,

  1203.                           intValue,

  1204.                           0U);

  1205.             result = PLSR_RESULT_SEGMENT_OVERFLOW;

  1206.         }

  1207.         return result;

  1208.     }

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

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

  1211.                 + PLSR_S0_HEADER_WORDS;

  1212.     if (s0Words64 > UINT32_MAX)

  1213.     {

  1214.         return PLSR_RESULT_ADDRESS_OVERFLOW;

  1215.     }

  1216.     s0Words = (uint32_t)s0Words64;

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

  1218.                                call->s0,

  1219.                                s0Words,

  1220.                                PLSR_PARSE_BLOCK_S0,

  1221.                                detail);

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

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

  1224.                                call->s1,

  1225.                                PLSR_S1_WORDS,

  1226.                                PLSR_PARSE_BLOCK_S1,

  1227.                                detail);

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

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

  1230.     {

  1231.         PlsrSetDetail(detail,

  1232.                       PLSR_RESULT_BLOCK_OVERLAP,

  1233.                       PLSR_PARSE_BLOCK_S1,

  1234.                       call->s1.address,

  1235.                       (int32_t)s0Words,

  1236.                       0U);

  1237.         return PLSR_RESULT_BLOCK_OVERLAP;

  1238.     }

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

  1240.     {

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

  1242.                               call->s0.device,

  1243.                               call->s0.address + index,

  1244.                               &word,

  1245.                               PLSR_PARSE_BLOCK_S0,

  1246.                               0U,

  1247.                               detail);

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

  1249.         if (word != 0U)

  1250.         {

  1251.             PlsrSetDetail(detail,

  1252.                           PLSR_RESULT_RESERVED_NOT_ZERO,

  1253.                           PLSR_PARSE_BLOCK_S0,

  1254.                           call->s0.address + index,

  1255.                           word,

  1256.                           0U);

  1257.             return PLSR_RESULT_RESERVED_NOT_ZERO;

  1258.         }

  1259.     }

  1260. 

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

  1262.                            call->s1.device,

  1263.                            call->s1.address,

  1264.                            &intValue,

  1265.                            PLSR_PARSE_BLOCK_S1,

  1266.                            0U,

  1267.                            detail);

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

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

  1270.     {

  1271.         PlsrSetDetail(detail,

  1272.                       PLSR_RESULT_INVALID_POSITION_MODE,

  1273.                       PLSR_PARSE_BLOCK_S1,

  1274.                       call->s1.address,

  1275.                       intValue,

  1276.                       0U);

  1277.         return PLSR_RESULT_INVALID_POSITION_MODE;

  1278.     }

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

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

  1281.                            call->s1.device,

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

  1283.                            &intValue,

  1284.                            PLSR_PARSE_BLOCK_S1,

  1285.                            0U,

  1286.                            detail);

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

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

  1289.     {

  1290.         PlsrSetDetail(detail,

  1291.                       PLSR_RESULT_INVALID_ARGUMENT,

  1292.                       PLSR_PARSE_BLOCK_S1,

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

  1294.                       intValue,

  1295.                       0U);

  1296.         return PLSR_RESULT_INVALID_ARGUMENT;

  1297.     }

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

  1299. 

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

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

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

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

  1304.     {

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

  1306.         {

  1307.             PlsrSetDetail(detail,

  1308.                           PLSR_RESULT_INVALID_RESOURCE,

  1309.                           PLSR_PARSE_BLOCK_OUTPUT,

  1310.                           call->dAxis,

  1311.                           snapshot->outputMode,

  1312.                           0U);

  1313.             return PLSR_RESULT_INVALID_RESOURCE;

  1314.         }

  1315.         snapshot->pairedTimerClockHz = PLSR_TIMER_84MHZ;

  1316.     }

  1317. 

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

  1319.     {

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

  1321.         segmentBase = call->s0.address

  1322.                       + (uint32_t)segment * PLSR_S0_SEGMENT_WORDS;

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

  1324.                                call->s0.device,

  1325.                                segmentBase,

  1326.                                &intValue,

  1327.                                PLSR_PARSE_BLOCK_S0,

  1328.                                segment,

  1329.                                detail);

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

  1331.         if (intValue < 0)

  1332.         {

  1333.             PlsrSetDetail(detail,

  1334.                           PLSR_RESULT_INVALID_FREQUENCY,

  1335.                           PLSR_PARSE_BLOCK_S0,

  1336.                           segmentBase,

  1337.                           intValue,

  1338.                           segment);

  1339.             return PLSR_RESULT_INVALID_FREQUENCY;

  1340.         }

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

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

  1343.                                call->s0.device,

  1344.                                segmentBase + 2UL,

  1345.                                &segmentData->pulseOrTarget,

  1346.                                PLSR_PARSE_BLOCK_S0,

  1347.                                segment,

  1348.                                detail);

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

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

  1351.                               call->s0.device,

  1352.                               segmentBase + 4UL,

  1353.                               &word,

  1354.                               PLSR_PARSE_BLOCK_S0,

  1355.                               segment,

  1356.                               detail);

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

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

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

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

  1361.                                call->s0.device,

  1362.                                segmentBase + 5UL,

  1363.                                &segmentData->waitValueOrAddress,

  1364.                                PLSR_PARSE_BLOCK_S0,

  1365.                                segment,

  1366.                                detail);

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

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

  1369.                               call->s0.device,

  1370.                               segmentBase + 7UL,

  1371.                               &word,

  1372.                               PLSR_PARSE_BLOCK_S0,

  1373.                               segment,

  1374.                               detail);

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

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

  1377.         {

  1378.             PlsrSetDetail(detail,

  1379.                           PLSR_RESULT_RESERVED_NOT_ZERO,

  1380.                           PLSR_PARSE_BLOCK_S0,

  1381.                           segmentBase + 7UL,

  1382.                           word,

  1383.                           segment);

  1384.             return PLSR_RESULT_RESERVED_NOT_ZERO;

  1385.         }

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

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

  1388.                                call->s0.device,

  1389.                                segmentBase + 8UL,

  1390.                                &segmentData->jumpValueOrAddress,

  1391.                                PLSR_PARSE_BLOCK_S0,

  1392.                                segment,

  1393.                                detail);

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

  1395. 

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

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

  1398.         {

  1399.             segmentData->flags |= PLSR_SEGMENT_FLAG_ZERO_PULSE;

  1400.             segmentData->targetFrequency = 0UL;

  1401.         }

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

  1403.         {

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

  1405.             {

  1406.                 PlsrSetDetail(detail,

  1407.                               PLSR_RESULT_INVALID_FREQUENCY,

  1408.                               PLSR_PARSE_BLOCK_S2,

  1409.                               0UL,

  1410.                               0,

  1411.                               segment);

  1412.                 return PLSR_RESULT_INVALID_FREQUENCY;

  1413.             }

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

  1415.             segmentData->flags |= PLSR_SEGMENT_FLAG_DEFAULT_SPEED;

  1416.         }

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

  1418.         {

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

  1420.             segmentData->flags |= PLSR_SEGMENT_FLAG_SPEED_CLAMPED;

  1421.             snapshot->speedClamped = 1U;

  1422.         }

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

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

  1425.         result = PlsrValidateJump(call,

  1426.                                   snapshot,

  1427.                                   segmentData,

  1428.                                   segment,

  1429.                                   &resolvedJump,

  1430.                                   detail);

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

  1432.     }

  1433. 

  1434.     result = PlsrConvertSnapshotSpeeds(snapshot, detail);

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

  1436.     result = PlsrCheckConstantPath(snapshot, detail);

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

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

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

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

  1441.     return PLSR_RESULT_OK;

  1442. }

  1443. 

  1444. PLSR_RESULT PlsrResolveLiveFrequency(const PLSR_JOB_SNAPSHOT *snapshot,

  1445.                                      uint16_t segment,

  1446.                                      uint32_t *frequency,

  1447.                                      uint8_t *clamped)

  1448. {

  1449.     int32_t rawFrequency;

  1450.     uint32_t segmentAddress;

  1451.     PLSR_RESULT result;

  1452. 

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

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

  1455.     {

  1456.         return PLSR_RESULT_INVALID_ARGUMENT;

  1457.     }

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

  1459.          & PLSR_SEGMENT_FLAG_ZERO_PULSE)

  1460.         != 0U)

  1461.     {

  1462.         *frequency = 0UL;

  1463.         *clamped = 0U;

  1464.         return PLSR_RESULT_OK;

  1465.     }

  1466.     segmentAddress = snapshot->s0.address

  1467.                      + (uint32_t)segment * PLSR_S0_SEGMENT_WORDS;

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

  1469.                            snapshot->s0.device,

  1470.                            segmentAddress,

  1471.                            &rawFrequency,

  1472.                            PLSR_PARSE_BLOCK_S0,

  1473.                            segment,

  1474.                            NULL);

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

  1476.     if (rawFrequency < 0) return PLSR_RESULT_INVALID_FREQUENCY;

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

  1478.                                     : (uint32_t)rawFrequency;

  1479.     *clamped = 0U;

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

  1481.     {

  1482.         *frequency = snapshot->inputMaximumSpeed;

  1483.         *clamped = 1U;

  1484.     }

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

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

  1487.                                                 *frequency,

  1488.                                                 frequency);

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

  1490.         || (*frequency > PLSR_FREQUENCY_MAX_HZ))

  1491.     {

  1492.         return PLSR_RESULT_INVALID_FREQUENCY;

  1493.     }

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

  1495. }