RPM Order Map — Control Systems/Vibration

RPM-Order Map

Control Systems / Vibration

The order map versus speed of a machine that is running up or down – MATLAB's rpmordermap, one column at a time. An order is a multiple of the shaft rate, so a component locked to the shaft stays on one row of this map while the machine changes speed, where on a frequency map it would smear across many. The block resamples the signal into the angular domain – a fixed number of samples per revolution, however fast the shaft is turning – and publishes the spectrum of the last L angular samples every hop of them:

O_max = f_s·30/rpm_max,   f_sp = 8·O_max angular samples per revolution; the signal is upsampled 15 times, the speed integrated into a phase (φ = ∫rpm/60 dt) and the signal read off at every 1/f_sp of a revolution; then

column_j[m] = c(m)·|Σ_n w[n]·x_p[j·hop+n]·e^−i2πmn/N|,   N = max(256, L),   rows m = 0 … the first order past O_max,

with the window normalized to sum 1 and c the one-sided fold: 1 at DC, √2 above it. Row m is order m·f_sp/N.

Ports

• u – the sampled signal, scalar: one channel and its own window.
• rpm – the shaft speed in revolutions per minute at the same instant, scalar and positive. It is what the angular resampling integrates, so this block uses it in the arithmetic rather than only as an axis.
• map – the current column, one entry per order row (the first order past O_max, so [N/8+2, 1] at the usual N). It changes only when a column completes and holds in between.
• rpm – scalar: the speed at that column's centre, interpolated at the centre's own phase; the map's horizontal axis.
• t – scalar: the time of that centre in seconds from the run's first sample. Unlike a frequency map's, it is not a fixed multiple of the hop: a column covers a fixed number of REVOLUTIONS, which take less time the faster the shaft turns.

Parameters

• Sample Rate (Hz) – f_s, the rate the signal was sampled at. Positive; defaults to 1000.
• Maximum RPM – the largest speed the run will reach. It sets the angular sampling rate f_sp and the largest order the map carries, O_max = f_s·30/rpm_max; a signal component above that order cannot be resolved at this sampling rate at all. Positive; defaults to 3000. This is the one number rpmordermap takes from the record and this block takes from you – it uses max(rpm) over the whole signal, which no stream knows in advance, and the two agree exactly when this parameter equals that maximum. Set it too high and the map is finer and shorter than MATLAB's; set it below the speed actually reached and orders above O_max alias.
• Resolution (Orders) – the order resolution asked for, which is what sets the window length L in angular samples, through the same iteration on the window's equivalent noise bandwidth that rpmordermap uses. Defaults to 0.3125, which is that function's own default of f_sp/256 at the default rate and maximum speed. A resolution too fine for a window of 1024 angular samples, or too coarse for one of 4, is clamped to that window rather than refused. The resolution and the overlap together must leave a hop of at least five angular samples, because one sample of the signal can advance the shaft by four; a configuration that does not is reported.
• Window – the shape the frame is multiplied by, normalized to sum 1:
  • Flat Top – rpmordermap's default: amplitude-accurate on an order that falls between rows, at the cost of the widest main lobe.
  • Hann – rpmfreqmap's default, and the shortest window of the four at a given resolution.
  • Hamming – a lower first sidelobe, a wider main lobe.
  • Rectangular – no window at all.
  rpmordermap also takes Kaiser and Chebyshev windows, which need a second parameter each; those two are not offered here.
• Overlap Percent – how much of one frame the next one repeats, 0 to 100, in ANGULAR samples. The overlap is min(ceil(percent/100·L), L−1) and the hop is L minus that. Defaults to 50.
• Amplitude – what a row carries:
  • RMS – the root-mean-square amplitude of that order: the default.
  • Peak – the peak amplitude, √2 times the RMS one.
  • Power – the square of the RMS value.
• Scale – Linear, or dB: 20·log₁₀ of an amplitude, 10·log₁₀ of a power.
• Sampling Time (s) – zero or less inherits the solver's rate; a positive value runs the block at that period.

Latency, and what a stream cannot reach

The angular resampling is zero-phase: MATLAB reads the middle of a 301-tap filter, which is 10 input samples after the sample it belongs to. This block therefore starts publishing 10 samples late, and it never publishes the columns rpmordermap would build out of a record's last 10 samples – the ones where it pads the filter with zeros and extrapolates the speed past the end. Everything before them is the same map: measured against R2026a on a 600-sample ramp from 1500 to 3000 rpm, 57 of 59 columns at max |error| 8.3e-15, the speed axis to 4.6e-13 and the time axis to 1.1e-16. A column also arrives when the SHAFT has turned far enough rather than on a fixed tick, so the gap between columns shortens as the machine speeds up.

Code export

All ten targets: Python, MATLAB, Java, Rust, C, C++, VHDL, Verilog, SystemVerilog and PLC Structured Text. The window and the 301 resampling taps are computed once at export time and carried as numbers; the resampler, the phase integration, the angular interpolation, the transform and the scaling run as loops in the core. Every parameter is structural – re-export after changing one.

⚠ The three HDL targets run those loops in simulation-only real arithmetic, quantizing only at the port boundaries: a phase integrated over a whole run, a division by an interpolation interval and a square root do not belong in a Q16.16 datapath. They are not offered as synthesizable.

Simulink bridge

None (Support::None). rpmordermap is a Signal Processing Toolbox function and that toolbox ships no Simulink library, so there is no path a diagram could name. The bridge reports this block rather than dropping it silently, and it therefore has no parity testbench; code export verification still covers it across all ten languages.

Notes

• Stateful, and discrete by nature (setDiscreteOnlyBlock(true)): 21 samples of signal and speed history for the resampler, a phase accumulator, the angular ring of L samples, a short queue of column centres and the held column.
• The speed must be positive and should be smooth. The phase is the integral of it, so a speed that goes to zero stalls the map and a negative one is meaningless. Feed it from a tachometer block (Tacho Pulse RPM) or a recorded speed channel.
• Not RPM-Frequency Map. That block's rows are hertz and a shaft-locked component walks across them as the machine runs up; here the rows are orders and it stays put, which is the whole reason to pay for the resampling.
• No state space. A magnitude is not linear in the window, so model reduction correctly declines to merge it.