Interpolator

Interpolator fills in the gaps between values that arrive more slowly than the control loop runs. A trajectory point every 10 ms on a 1 ms task leaves nine cycles with nothing new to follow; this block generates those nine, so the controller downstream sees a continuous command instead of a staircase.

It offers two shapes. Straight-line segments are the default and cost one segment of delay. Cubic segments with matched slopes at the joins are smoother — the only interpolation here with no corner at a join — and cost two.

flowchart LR
    i1(["input — the slowly arriving value"]) --> B["Interpolator"]
    i2(["disable"]) --> B
    B --> o1(["output — interpolated value, every cycle"])
    B --> o2(["isEnabled"])

Set sampleFactor to the number of task cycles between arrivals: input every 10 ms on a 1 ms task means 10. Delay is sampleFactor × task period with lookAhead false, and twice that with lookAhead true — 10 ms and 20 ms in that example. With filterSamples at 0 the output passes exactly through every arrived value; above 0 it no longer does, and adds a lag of (filterSamples + 1) × task period on top.

Nothing here detects when a new value actually arrives. The block counts cycles, so sampleFactor must match the arrival rate — see the symptom table. outputFiltered no longer exists; if you are upgrading, see Limits and errors.

Signals

Inputs

Outputs

Parameters

All four parameters are persistent and survive a controller restart. The inputs and outputs do not. No parameters exist below this block.

Setup

1. Measure how often the source updates input, in task cycles. Divide the update period by the task period: a 10 ms source on a 1 ms task is 10.

2. Link the source into input and confirm on a trace that input moves in steps at the rate you measured.

3. Set enable false. output equals input sample for sample and isEnabled reads false.

4. Set sampleFactor to the number from step 1, filterSamples to 0, and lookAhead false. Read both numbers back to confirm they were accepted.

5. Set enable true. output should now move smoothly every cycle instead of in steps.

6. Overlay input and output on one trace. output should reach each arrived value exactly at the moment the next one arrives, and never hold flat mid-segment.

   Step 6 is the check that sampleFactor matches. A flat stretch at the end of each segment means the value is too low; output still moving in steps means it is too high. Get this right before tuning anything else.

7. Trace every element of input and output. An element that reads zero while the machine moves is an unwired channel.

Tuning

1. Get sampleFactor right first, with Setup step 6. Nothing else in this block works until the segment length matches the arrival rate.
2. Decide whether you need lookAhead. Leave it false unless the corner at each join is visibly reaching the machine — as a tick in the velocity, a bump in the torque, or audible roughness at the update rate.
3. If you enable lookAhead, re-measure your total delay. It doubles, and whatever loop consumes output pays for it in phase margin.
4. With lookAhead true, watch a sharp change of direction on a trace. Cubic segments overshoot on a corner — the output will go past the commanded value and come back. If that overshoot is beyond what the machine can accept, use straight segments instead.
5. Leave filterSamples at 0 unless you have residual noise the interpolation itself cannot handle. It costs lag on top of the interpolation delay and it stops the output passing through the arrived values exactly.
6. Re-check sampleFactor after any task-rate change. It counts cycles, so the same value is a different segment length in seconds — rescale it by the ratio of the task periods, and re-check that it still matches the arrival rate.

Read the delay off either curve as its horizontal offset from the dashed input.

A starting point for a 10 ms trajectory source on a 1 ms task, with straight segments and no extra smoothing:

sampleFactor  = 10
filterSamples = 0
lookAhead     = false
enable        = true

Limits and errors

The block raises no errors or warnings and logs nothing. Every failure above shows as a value on a trace, not as a message.

Verified against motorcortex-control3 3.30.0 (bc348fd).