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.
31 Commits
3 Ramas
138 MiB
 
 
 
 
 
 
Árbol: ec430e357c
Ramas Etiquetas
${ item.name }
Crear rama ${ searchTerm }
desde 'ec430e357c'
${ noResults }
Modbus-rtu/PLSR/Src/plsr_profile.c

532 líneas
18 KiB
Original Blame Histórico 

  1. #include "plsr_profile.h"

  2. #include <math.h>

  3. #include <string.h>

  4. 

  5. /* 正弦表：256 项，sin(pi*i/256) 的 Q16 表示。 */

  6. static const uint16_t PlsrProfileSineTable[256] =

  7. {

  8.     0, 804, 1608, 2412, 3216, 4019, 4821, 5623,

  9.     6424, 7224, 8022, 8820, 9616, 10411, 11204, 11996,

  10.     12785, 13573, 14359, 15143, 15924, 16703, 17479, 18253,

  11.     19024, 19792, 20557, 21320, 22078, 22834, 23586, 24335,

  12.     25080, 25821, 26558, 27291, 28020, 28745, 29466, 30182,

  13.     30893, 31600, 32303, 33000, 33692, 34380, 35062, 35738,

  14.     36410, 37076, 37736, 38391, 39040, 39683, 40320, 40951,

  15.     41576, 42194, 42806, 43412, 44011, 44604, 45190, 45769,

  16.     46341, 46906, 47464, 48015, 48559, 49095, 49624, 50146,

  17.     50660, 51166, 51665, 52156, 52639, 53114, 53581, 54040,

  18.     54491, 54934, 55368, 55794, 56212, 56621, 57022, 57414,

  19.     57798, 58172, 58538, 58896, 59244, 59583, 59914, 60235,

  20.     60547, 60851, 61145, 61429, 61705, 61971, 62228, 62476,

  21.     62714, 62943, 63162, 63372, 63572, 63763, 63944, 64115,

  22.     64277, 64429, 64571, 64704, 64827, 64940, 65043, 65137,

  23.     65220, 65294, 65358, 65413, 65457, 65492, 65516, 65531,

  24.     65535, 65531, 65516, 65492, 65457, 65413, 65358, 65294,

  25.     65220, 65137, 65043, 64940, 64827, 64704, 64571, 64429,

  26.     64277, 64115, 63944, 63763, 63572, 63372, 63162, 62943,

  27.     62714, 62476, 62228, 61971, 61705, 61429, 61145, 60851,

  28.     60547, 60235, 59914, 59583, 59244, 58896, 58538, 58172,

  29.     57798, 57414, 57022, 56621, 56212, 55794, 55368, 54934,

  30.     54491, 54040, 53581, 53114, 52639, 52156, 51665, 51166,

  31.     50660, 50146, 49624, 49095, 48559, 48015, 47464, 46906,

  32.     46341, 45769, 45190, 44604, 44011, 43412, 42806, 42194,

  33.     41576, 40951, 40320, 39683, 39040, 38391, 37736, 37076,

  34.     36410, 35738, 35062, 34380, 33692, 33000, 32303, 31600,

  35.     30893, 30182, 29466, 28745, 28020, 27291, 26558, 25821,

  36.     25080, 24335, 23586, 22834, 22078, 21320, 20557, 19792,

  37.     19024, 18253, 17479, 16703, 15924, 15143, 14359, 13573,

  38.     12785, 11996, 11204, 10411, 9616, 8820, 8022, 7224,

  39.     6424, 5623, 4821, 4019, 3216, 2412, 1608, 804,

  40. };

  41. static uint64_t PlsrProfileHzToQ32(uint32_t hz)

  42. {

  43.     return (uint64_t)hz << 32U;

  44. }

  45. 

  46. /* 每刷新步的斜率增量（Q32.32），支持 0.1ms 刷新（1000/refreshHz 可能 < 1）。 */

  47. static uint64_t PlsrProfileSlopePerStepQ32(uint32_t slopeHzPerMs,

  48.                                            uint32_t refreshHz)

  49. {

  50.     return PlsrProfileHzToQ32(slopeHzPerMs) * UINT64_C(1000)

  51.            / (uint64_t)refreshHz;

  52. }

  53. 

  54. /* 从当前频率减速到目标频率所需的脉冲数（Q32.32 精度）。 */

  55. static uint64_t PlsrProfileDecelPulsesQ32(uint32_t frequencyHz,

  56.                                           uint32_t targetHz,

  57.                                           uint32_t slopeHzPerMs)

  58. {

  59.     uint64_t numerator;

  60.     uint64_t denominator;

  61. 

  62.     if (frequencyHz <= targetHz)

  63.     {

  64.         return 0UL;

  65.     }

  66.     numerator = (uint64_t)frequencyHz * (uint64_t)frequencyHz

  67.                 - (uint64_t)targetHz * (uint64_t)targetHz;

  68.     denominator = 2000UL * (uint64_t)slopeHzPerMs;

  69.     if (denominator == 0UL)

  70.     {

  71.         return 0UL;

  72.     }

  73.     return (numerator / denominator) * PLSR_PROFILE_Q32_ONE

  74.            + ((numerator % denominator) * PLSR_PROFILE_Q32_ONE)

  75.                  / denominator;

  76. }

  77. 

  78. /* 直线增量初始化。 */

  79. static void PlsrProfileInitLinearDelta(PLSR_PROFILE_STATE *state,

  80.                                        uint32_t slopeHzPerMs,

  81.                                        uint32_t refreshHz)

  82. {

  83.     state->deltaPerStepQ32 = PlsrProfileSlopePerStepQ32(slopeHzPerMs,

  84.                                                         refreshHz);

  85.     state->jerkPerStepQ32 = 0UL;

  86.     state->curveStep = 0U;

  87.     state->curveStepLimit = 0U;

  88.     state->sPhase = 0U;

  89. }

  90. 

  91. /* S 形/正弦增量初始化：增量先升后降（S形）或正弦半波。 */

  92. static void PlsrProfileInitCurveDelta(PLSR_PROFILE_STATE *state,

  93.                                       uint32_t frequencyGapHz,

  94.                                       uint32_t slopeHzPerMs,

  95.                                       uint32_t refreshHz,

  96.                                       uint8_t curveMode)

  97. {

  98.     uint64_t linearPerStep = PlsrProfileSlopePerStepQ32(slopeHzPerMs,

  99.                                                         refreshHz);

  100.     uint64_t integerPerStepHz;

  101.     uint64_t rampSteps;

  102.     uint64_t jerkQ32;

  103. 

  104.     integerPerStepHz = ((uint64_t)slopeHzPerMs * UINT64_C(1000))

  105.                        / (uint64_t)refreshHz;

  106.     if (integerPerStepHz == 0UL)

  107.     {

  108.         integerPerStepHz = 1UL;

  109.     }

  110.     rampSteps = ((uint64_t)frequencyGapHz + integerPerStepHz - 1UL)

  111.                 / integerPerStepHz;

  112. 

  113.     if (curveMode == PLSR_PROFILE_CURVE_SINE)

  114.     {

  115.         /* 正弦：时间同直线，峰值增量 = 直线增量 * pi/2（面积匹配）。 */

  116.         state->deltaPerStepQ32 = 0UL;

  117.         state->jerkPerStepQ32 = 0UL;

  118.         state->curveStep = 0U;

  119.         state->curveStepLimit = (uint32_t)rampSteps;

  120.         state->sPhase = 0U;

  121.         return;

  122.     }

  123. 

  124.     /* S 形：增量 0→峰值→0，总时间 2 倍直线时间。 */

  125.     jerkQ32 = linearPerStep / rampSteps;

  126.     state->deltaPerStepQ32 = 0UL;

  127.     state->jerkPerStepQ32 = jerkQ32;

  128.     state->curveStep = 0U;

  129.     state->curveStepLimit = (uint32_t)(rampSteps * 2UL);

  130.     state->sPhase = 0U;

  131. }

  132. 

  133. /* 进入加速段（直线或曲线）。 */

  134. static void PlsrProfileBeginAccel(PLSR_PROFILE_STATE *state)

  135. {

  136.     uint32_t gapHz;

  137. 

  138.     if (state->targetFrequencyHz <= state->frequencyQ32 >> 32U)

  139.     {

  140.         state->phase = PLSR_PROFILE_PHASE_CRUISE;

  141.         return;

  142.     }

  143.     if (state->curveMode == PLSR_PROFILE_CURVE_LINEAR)

  144.     {

  145.         PlsrProfileInitLinearDelta(state,

  146.                                    state->accelSlopeHzPerMs,

  147.                                    state->refreshHz);

  148.     }

  149.     else

  150.     {

  151.         gapHz = state->targetFrequencyHz

  152.                 - (uint32_t)(state->frequencyQ32 >> 32U);

  153.         PlsrProfileInitCurveDelta(state,

  154.                                   gapHz,

  155.                                   state->accelSlopeHzPerMs,

  156.                                   state->refreshHz,

  157.                                   state->curveMode);

  158.     }

  159.     state->phase = PLSR_PROFILE_PHASE_ACCEL;

  160. }

  161. 

  162. /* 进入减速段：减速到 decelTargetHz（默认=终止速度，降频时=新目标）。 */

  163. static void PlsrProfileBeginDecel(PLSR_PROFILE_STATE *state)

  164. {

  165.     uint32_t gapHz;

  166. 

  167.     if (state->frequencyQ32 >> 32U <= state->decelTargetHz)

  168.     {

  169.         state->frequencyQ32 = PlsrProfileHzToQ32(state->decelTargetHz);

  170.         if (state->decelTargetHz == state->stopFrequencyHz)

  171.         {

  172.             state->phase = PLSR_PROFILE_PHASE_DONE;

  173.         }

  174.         else

  175.         {

  176.             /* 降频到新目标：转匀速继续。 */

  177.             state->targetFrequencyHz = state->decelTargetHz;

  178.             state->decelTargetHz = state->stopFrequencyHz;

  179.             state->phase = PLSR_PROFILE_PHASE_CRUISE;

  180.         }

  181.         return;

  182.     }

  183.     if (state->curveMode == PLSR_PROFILE_CURVE_LINEAR)

  184.     {

  185.         PlsrProfileInitLinearDelta(state,

  186.                                    state->decelSlopeHzPerMs,

  187.                                    state->refreshHz);

  188.     }

  189.     else

  190.     {

  191.         gapHz = (uint32_t)(state->frequencyQ32 >> 32U)

  192.                 - state->decelTargetHz;

  193.         PlsrProfileInitCurveDelta(state,

  194.                                   gapHz,

  195.                                   state->decelSlopeHzPerMs,

  196.                                   state->refreshHz,

  197.                                   state->curveMode);

  198.     }

  199.     state->phase = PLSR_PROFILE_PHASE_DECEL;

  200. }

  201. 

  202. /* 曲线模式下推进增量（S形三角增量 / 正弦查表）。 */

  203. static uint64_t PlsrProfileAdvanceDelta(PLSR_PROFILE_STATE *state,

  204.                                         uint64_t linearPerStepQ32)

  205. {

  206.     uint64_t delta;

  207. 

  208.     if (state->curveMode == PLSR_PROFILE_CURVE_SINE)

  209.     {

  210.         uint32_t index = ((uint32_t)state->curveStep * 256U)

  211.                          / (uint32_t)state->curveStepLimit;

  212. 

  213.         if (index > 255U)

  214.         {

  215.             index = 255U;

  216.         }

  217.         delta = ((uint64_t)PlsrProfileSineTable[index]

  218.                  * linearPerStepQ32) / 65536UL;

  219.     }

  220.     else

  221.     {

  222.         if (state->sPhase == 0U)

  223.         {

  224.             state->deltaPerStepQ32 += state->jerkPerStepQ32;

  225.             if ((state->curveStepLimit != 0U)

  226.                 && (state->curveStep >= state->curveStepLimit / 2U))

  227.             {

  228.                 state->sPhase = 1U;

  229.             }

  230.         }

  231.         else

  232.         {

  233.             if (state->deltaPerStepQ32 > state->jerkPerStepQ32)

  234.             {

  235.                 state->deltaPerStepQ32 -= state->jerkPerStepQ32;

  236.             }

  237.             else

  238.             {

  239.                 state->deltaPerStepQ32 = 0UL;

  240.             }

  241.         }

  242.         delta = state->deltaPerStepQ32;

  243.     }

  244.     state->curveStep++;

  245.     return delta;

  246. }

  247. 

  248. PLSR_RESULT PlsrProfileStart(PLSR_PROFILE_STATE *state,

  249.                              const PLSR_PROFILE_REQUEST *request,

  250.                              int64_t pulses,

  251.                              uint32_t refreshHz)

  252. {

  253.     uint32_t startHz;

  254. 

  255.     if ((state == NULL) || (request == NULL))

  256.     {

  257.         return PLSR_RESULT_INVALID_ARGUMENT;

  258.     }

  259.     if ((pulses <= 0) || (refreshHz == 0UL)

  260.         || (request->targetFrequencyHz == 0UL))

  261.     {

  262.         return PLSR_RESULT_INVALID_ARGUMENT;

  263.     }

  264. 

  265.     state->refreshHz = refreshHz;

  266.     state->totalPulses = pulses;

  267.     state->targetFrequencyHz = request->targetFrequencyHz;

  268.     if (request->targetFrequencyHz > request->maxFrequencyHz)

  269.     {

  270.         state->targetFrequencyHz = request->maxFrequencyHz;

  271.     }

  272.     state->startFrequencyHz = request->startFrequencyHz;

  273.     state->stopFrequencyHz = request->stopFrequencyHz;

  274.     state->decelTargetHz = request->stopFrequencyHz;

  275.     state->accelSlopeHzPerMs = request->accelSlopeHzPerMs;

  276.     state->decelSlopeHzPerMs = request->decelSlopeHzPerMs;

  277.     state->curveMode = request->curveMode;

  278.     startHz = request->startFrequencyHz;

  279.     if (startHz > state->targetFrequencyHz)

  280.     {

  281.         startHz = state->targetFrequencyHz;

  282.     }

  283.     state->frequencyQ32 = PlsrProfileHzToQ32(startHz);

  284.     state->emittedPulsesQ32 = 0UL;

  285.     state->phase = PLSR_PROFILE_PHASE_ACCEL;

  286.     state->started = 1U;

  287. 

  288.     if (startHz >= state->targetFrequencyHz)

  289.     {

  290.         state->phase = PLSR_PROFILE_PHASE_CRUISE;

  291.     }

  292.     else if (request->accelSlopeHzPerMs == 0UL)

  293.     {

  294.         state->frequencyQ32 = PlsrProfileHzToQ32(state->targetFrequencyHz);

  295.         state->phase = PLSR_PROFILE_PHASE_CRUISE;

  296.     }

  297.     else

  298.     {

  299.         PlsrProfileBeginAccel(state);

  300.     }

  301.     return PLSR_RESULT_OK;

  302. }

  303. 

  304. PLSR_RESULT PlsrProfileStep(PLSR_PROFILE_STATE *state,

  305.                             uint32_t *frequencyHz,

  306.                             uint8_t *completed)

  307. {

  308.     uint64_t emittedThisStep;

  309.     uint64_t remainingQ32;

  310.     uint64_t decelNeeded;

  311.     uint64_t linearPerStepQ32;

  312.     uint64_t deltaQ32;

  313.     uint32_t currentHz;

  314. 

  315.     if ((state == NULL) || (frequencyHz == NULL) || (completed == NULL))

  316.     {

  317.         return PLSR_RESULT_INVALID_ARGUMENT;

  318.     }

  319.     *completed = 0U;

  320.     if (state->phase == PLSR_PROFILE_PHASE_DONE)

  321.     {

  322.         *frequencyHz = 0U;

  323.         *completed = 1U;

  324.         return PLSR_RESULT_OK;

  325.     }

  326. 

  327.     linearPerStepQ32 = PlsrProfileSlopePerStepQ32(

  328.         (state->phase == PLSR_PROFILE_PHASE_ACCEL)

  329.             ? state->accelSlopeHzPerMs

  330.             : state->decelSlopeHzPerMs,

  331.         state->refreshHz);

  332. 

  333.     switch (state->phase)

  334.     {

  335.         case PLSR_PROFILE_PHASE_ACCEL:

  336.             deltaQ32 = PlsrProfileAdvanceDelta(state, linearPerStepQ32);

  337.             state->frequencyQ32 += deltaQ32;

  338.             if ((state->frequencyQ32

  339.                  >= PlsrProfileHzToQ32(state->targetFrequencyHz))

  340.                 || ((state->curveMode != PLSR_PROFILE_CURVE_LINEAR)

  341.                     && (state->curveStep >= state->curveStepLimit)))

  342.             {

  343.                 state->frequencyQ32 =

  344.                     PlsrProfileHzToQ32(state->targetFrequencyHz);

  345.                 state->phase = PLSR_PROFILE_PHASE_CRUISE;

  346.             }

  347.             break;

  348. 

  349.         case PLSR_PROFILE_PHASE_CRUISE:

  350.             /* 剩余脉冲不足以按当前频率完成减速时开始减速（Q32 精度）。 */

  351.             remainingQ32 = PlsrProfileHzToQ32(

  352.                                (uint32_t)state->totalPulses)

  353.                            - state->emittedPulsesQ32;

  354.             decelNeeded = PlsrProfileDecelPulsesQ32(

  355.                 (uint32_t)(state->frequencyQ32 >> 32U),

  356.                 state->stopFrequencyHz,

  357.                 state->decelSlopeHzPerMs);

  358.             if (remainingQ32 <= decelNeeded)

  359.             {

  360.                 PlsrProfileBeginDecel(state);

  361.             }

  362.             break;

  363. 

  364.         case PLSR_PROFILE_PHASE_DECEL:

  365.             deltaQ32 = PlsrProfileAdvanceDelta(state, linearPerStepQ32);

  366.             state->frequencyQ32 -= deltaQ32;

  367.             if (state->frequencyQ32

  368.                 <= PlsrProfileHzToQ32(state->decelTargetHz))

  369.             {

  370.                 state->frequencyQ32 =

  371.                     PlsrProfileHzToQ32(state->decelTargetHz);

  372.                 if (state->decelTargetHz == state->stopFrequencyHz)

  373.                 {

  374.                     state->phase = PLSR_PROFILE_PHASE_DONE;

  375.                 }

  376.                 else

  377.                 {

  378.                     /* 降频到新目标：转匀速继续。 */

  379.                     state->targetFrequencyHz = state->decelTargetHz;

  380.                     state->decelTargetHz = state->stopFrequencyHz;

  381.                     state->phase = PLSR_PROFILE_PHASE_CRUISE;

  382.                 }

  383.             }

  384.             break;

  385. 

  386.         default:

  387.             break;

  388.     }

  389. 

  390.     /* 发射本步脉冲：频率(Hz) / 刷新率。 */

  391.     currentHz = (uint32_t)(state->frequencyQ32 >> 32U);

  392.     emittedThisStep = state->frequencyQ32 / (uint64_t)state->refreshHz;

  393.     if ((state->emittedPulsesQ32 + emittedThisStep)

  394.         >= PlsrProfileHzToQ32((uint32_t)state->totalPulses))

  395.     {

  396.         state->emittedPulsesQ32 =

  397.             PlsrProfileHzToQ32((uint32_t)state->totalPulses);

  398.         state->phase = PLSR_PROFILE_PHASE_DONE;

  399.     }

  400.     else

  401.     {

  402.         state->emittedPulsesQ32 += emittedThisStep;

  403.     }

  404. 

  405.     *frequencyHz = currentHz;

  406.     if (state->phase == PLSR_PROFILE_PHASE_DONE)

  407.     {

  408.         *completed = 1U;

  409.         *frequencyHz = 0U;

  410.     }

  411.     return PLSR_RESULT_OK;

  412. }

  413. 

  414. PLSR_RESULT PlsrProfileRetarget(PLSR_PROFILE_STATE *state,

  415.                                 uint32_t newTargetFrequencyHz)

  416. {

  417.     uint32_t currentHz;

  418. 

  419.     if (state == NULL)

  420.     {

  421.         return PLSR_RESULT_INVALID_ARGUMENT;

  422.     }

  423.     if (newTargetFrequencyHz == 0UL)

  424.     {

  425.         return PLSR_RESULT_INVALID_ARGUMENT;

  426.     }

  427.     currentHz = (uint32_t)(state->frequencyQ32 >> 32U);

  428.     if (newTargetFrequencyHz == state->targetFrequencyHz)

  429.     {

  430.         return PLSR_RESULT_OK;

  431.     }

  432.     state->targetFrequencyHz = newTargetFrequencyHz;

  433. 

  434.     if (newTargetFrequencyHz > currentHz)

  435.     {

  436.         /* 升频：加速/匀速 → 加速；减速中 → 取消减速转加速。 */

  437.         if ((state->phase == PLSR_PROFILE_PHASE_DECEL)

  438.             || (state->phase == PLSR_PROFILE_PHASE_CRUISE)

  439.             || (state->phase == PLSR_PROFILE_PHASE_DONE))

  440.         {

  441.             PlsrProfileBeginAccel(state);

  442.         }

  443.     }

  444.     else

  445.     {

  446.         /* 降频：先减速到新目标，再转匀速继续（最终仍减速到终止速度）。 */

  447.         if ((state->phase == PLSR_PROFILE_PHASE_ACCEL)

  448.             || (state->phase == PLSR_PROFILE_PHASE_CRUISE))

  449.         {

  450.             state->decelTargetHz = newTargetFrequencyHz;

  451.             PlsrProfileBeginDecel(state);

  452.         }

  453.     }

  454.     return PLSR_RESULT_OK;

  455. }

  456. 

  457. PLSR_RESULT PlsrProfilePlan(const PLSR_PROFILE_REQUEST *request,

  458.                             int64_t pulses,

  459.                             PLSR_PROFILE_PLAN *plan)

  460. {

  461.     double target;

  462.     double start;

  463.     double stop;

  464.     double accelSlope;

  465.     double decelSlope;

  466.     double accelTime;

  467.     double decelTime;

  468.     double accelPulses;

  469.     double decelPulses;

  470.     double cruisePulses;

  471.     double cruiseTime;

  472.     double peak;

  473. 

  474.     if ((request == NULL) || (plan == NULL) || (pulses <= 0))

  475.     {

  476.         return PLSR_RESULT_INVALID_ARGUMENT;

  477.     }

  478.     (void)memset(plan, 0, sizeof(*plan));

  479. 

  480.     target = (double)request->targetFrequencyHz;

  481.     if (target > (double)request->maxFrequencyHz)

  482.     {

  483.         target = (double)request->maxFrequencyHz;

  484.     }

  485.     start = (double)request->startFrequencyHz;

  486.     if (start > target)

  487.     {

  488.         start = target;

  489.     }

  490.     stop = (double)request->stopFrequencyHz;

  491.     accelSlope = (double)request->accelSlopeHzPerMs;

  492.     decelSlope = (double)request->decelSlopeHzPerMs;

  493. 

  494.     accelTime = (target > start) ? (target - start) / accelSlope : 0.0;

  495.     decelTime = (target > stop) ? (target - stop) / decelSlope : 0.0;

  496.     accelPulses = (start + target) * accelTime / 2000.0;

  497.     decelPulses = (target + stop) * decelTime / 2000.0;

  498. 

  499.     if ((accelPulses + decelPulses) >= (double)pulses)

  500.     {

  501.         /* 三角曲线：求峰值频率。 */

  502.         double sum = (double)pulses * 1000.0

  503.                      + start * start / (2.0 * accelSlope)

  504.                      + stop * stop / (2.0 * decelSlope);

  505.         double denom = 1.0 / (2.0 * accelSlope)

  506.                        + 1.0 / (2.0 * decelSlope);

  507. 

  508.         peak = (denom > 0.0) ? sqrt(sum / denom) : target;

  509.         accelTime = (peak > start) ? (peak - start) / accelSlope : 0.0;

  510.         decelTime = (peak > stop) ? (peak - stop) / decelSlope : 0.0;

  511.         accelPulses = (start + peak) * accelTime / 2000.0;

  512.         decelPulses = (peak + stop) * decelTime / 2000.0;

  513.         plan->peakFrequencyHz = (uint32_t)peak;

  514.         plan->triangular = 1U;

  515.     }

  516.     else

  517.     {

  518.         cruisePulses = (double)pulses - accelPulses - decelPulses;

  519.         cruiseTime = (target > 0.0) ? cruisePulses * 1000.0 / target : 0.0;

  520.         plan->cruiseTimeMs = (uint32_t)cruiseTime;

  521.         plan->peakFrequencyHz = (uint32_t)target;

  522.         plan->triangular = 0U;

  523.     }

  524. 

  525.     plan->accelTimeMs = (uint32_t)accelTime;

  526.     plan->decelTimeMs = (uint32_t)decelTime;

  527.     plan->totalTimeMs = plan->accelTimeMs + plan->cruiseTimeMs

  528.                         + plan->decelTimeMs;

  529.     plan->totalPulses = pulses;

  530.     return PLSR_RESULT_OK;

  531. }