Rational Resample — Control Systems/Resampling

Rational Resample

Control Systems / Resampling

MATLAB's resample on a stream: a rate change by P/Q through one anti-aliasing filter that the block designs for you, exactly as resample(x, P, Q, n, beta) designs it. The ratio is reduced to lowest terms p/q, and the filter is a Kaiser-windowed least-squares low-pass h = firls(2·n·max(p,q), [0 2f_c 2f_c 1], [1 1 0 0]) · kaiser(L, beta) with f_c = 1/(2·max(p,q)), scaled so its taps sum to p. The output is upfirdn(u, [0…0 h], p, q): the input stuffed with p−1 zeros per sample, filtered once, and one sample in every q kept and held until the next.

How it relates to resample. resample puts n_Z = floor(q − mod((L−1)/2, q)) zeros in front of h so that the filter's delay is a whole number D = floor(ceil((L−1)/2 + n_Z)/q) of output samples, and then drops the first D samples of its answer so that output 0 lines up with input 0. Dropping them needs the input D samples ahead, which a stream does not have, so this block emits them: its kept sample m IS resample's sample m − D, and its first D kept samples are the filter filling up. At the defaults D = 16 output samples (10.7 input samples).

The block runs at the fast rate – P times the input's – so drive it from a source running at P times this block's "Sampling Time (s)". A new input sample is taken on every Pth tick (k mod P = 0) and a sample is published on every Qth (k mod Q = 0), with k counting from 0 at the start of the run and the filter starting empty.

Ports

• Input – the signal u to resample, of any size [m,n]. Every entry is resampled on the same ticks through its own delay line; the entries do not interact.
• Output – the resampled-and-held signal y, the SAME size [m,n] as the input, at the block's own (fast) rate.

Parameters

• Upsampling Factor – P, the number of ticks per input sample, a whole number of 1 or more. Defaults to 3.
• Downsampling Factor – Q, the number of ticks per kept sample, a whole number of 1 or more. Defaults to 2. P and Q set the tick grid as typed; the filter is designed from p/q, their ratio in lowest terms, as resample designs it – so P = 4, Q = 2 computes what P = 2, Q = 1 computes, on a grid twice as fine. When the ratio reduces to 1/1 there is no filter and no delay: the block passes the input straight through.
• Neighbor Term Number – n, resample's own n: each output sample is computed from about n input samples on each side, and the filter has 2·n·max(p,q) + 1 taps. A whole number of 0 or more; at 0 the filter is ones(1,p), a hold rather than a low-pass. Defaults to 10.
• Kaiser Window Beta – beta, the Kaiser window's shape: 0 is a rectangular window, larger values trade a wider transition band for a lower stopband. A finite number of 0 or more. Defaults to 5.
• Sampling Time (s) – zero or less inherits the solver's rate; a positive value runs the block at that period. On this block that is the fast rate: a new input sample is taken every Pth step of it and a sample is published every Qth.

Code export

All ten targets: Python, MATLAB, Java, Rust, C, C++, VHDL, Verilog, SystemVerilog and PLC Structured Text. The filter is designed at export time and its taps are baked into the core as constants, together with both factors: the tap count fixes how many state words the core carries, so none of the four is a tunable parameter on a built core.

The filter is realized in polyphase form: the delay line holds INPUT samples, not stuffed zeros, and on a publishing tick only the taps that meet a real sample are summed – the phase is chosen by which tick it is. At the defaults that is 21 state words per signal entry where a line over the stuffed stream would need 62. Taps that are exactly zero (every max(p,q)-th tap of the designed filter, and the front padding) are left out of the emitted sums.

The three HDL targets are not simulation-only: the arithmetic is a multiply-accumulate over constant taps, which the Q16.16 datapath carries; the small taps at the filter's edges are quantized to that format along with everything else. Because the sum is emitted unrolled, the designed filter is limited to 1025 taps (n = 10 at a reduced max(p,q) of 51), which keeps every generated function inside the size a Java method may have. A longer design is refused with that reason rather than exported.

Simulink bridge

Neither imported nor exported. MATLAB's resample is a Signal Processing Toolbox function, and no Simulink block designs its filter. The Simulink block that computes the same arithmetic once the taps are given is dspmlti4/FIR Rate Conversion with FilterSource set to its dialog and the coefficients set to [0…0 h] – the counterpart of this family's Upfirdn – and it has no sample-based mode: it is frame-based, and refuses a one-element signal. An ICore wire carries one sample per tick, so there is no configuration of it for a bridge to name.

Notes

• Stateful: the last input samples each phase of the filter needs, the retained sample, and two phase counters – one mod P for which tick takes a sample, one mod Q for which tick publishes. All start from zero at the beginning of every run, so a re-run reproduces the stream exactly.
• Discrete by nature – the phases advance once per sample, so the block always takes its period from its own "Sampling Time (s)".
• Direct feedthrough only when the padded filter's first tap is nonzero. With n of 1 or more it never is – the front padding is at least one zero – so the output on a tick never depends on the input on the same tick. It can be at a 1/1 ratio (a pass-through) and for some n = 0 holds with an even p, and the block declares it exactly when it is.
• No state space, deliberately: which taps meet a sample depends on WHEN it arrives, so the block is periodically time-varying.
• Rational Resample vs. Upfirdn. Upfirdn computes the same stream from a filter you supply; this block designs resample's filter and pads it. To reproduce resample(x, p, q, b) with your own filter b, use Upfirdn with [0…0 b] as its coefficients.