Vibration Analysis for Condition Monitoring: ISO 20816, FFT and ML Pipelines (2026)

A rolling-element bearing rarely fails without warning. Weeks or months before it seizes, a microscopic spall on a race starts producing a tiny impact every time a ball rolls over it, and those impacts ring the machine structure at frequencies you can measure from the outside. Yet most plants still watch a single overall number on a handheld meter, and most machine-learning projects that claim 99% fault accuracy collapse the moment they leave the benchmark dataset they were trained on.

Good vibration analysis condition monitoring sits between those two extremes. It needs the right sensor, a sampling plan that respects physics, a spectrum and envelope analysis that localises the fault, severity limits you can defend to an auditor, and a data pipeline that does not drown the network. This guide builds that stack end to end: ISO 20816 severity zones, accelerometer selection, FFT and envelope code you can run, bearing defect frequency arithmetic, feature engineering, anomaly detection, and the edge-to-cloud architecture that ties it together.

What this covers: accelerometer choice (IEPE vs MEMS), sampling and Nyquist, ISO 20816 zones, FFT and envelope analysis in Python, BPFO/BPFI/BSF/FTF formulas with worked numbers, time-domain features, ML pitfalls including the CWRU dataset, edge vs cloud design, OPC UA and MQTT transport, and failure modes.

Context and Background

Condition monitoring means measuring a physical symptom of machine health and acting on its trend instead of on a calendar. Vibration is the dominant symptom for rotating equipment because almost every mechanical degradation mode changes how a machine shakes. Unbalance adds energy at one times running speed. Misalignment adds energy at two times running speed and often axially. Looseness produces harmonics and sub-harmonics. A damaged rolling bearing produces repetitive impacts at a rate set purely by its geometry and shaft speed.

The discipline has two layers that are often confused. The first is severity assessment: is the overall vibration level acceptable for this class of machine? That is the job of the ISO 20816 family, which sets zone boundaries on broadband velocity. The second is diagnosis: what is wrong and how long do we have? That is the job of spectrum, envelope and trend analysis, and increasingly of machine learning. Severity tells you that something is wrong; diagnosis tells you what to order from stores.

For the wider system view, including how asset health scores feed work orders, see our condition monitoring machinery health architecture guide. For the analytics and lifecycle side, the predictive maintenance IoT and machine learning architecture guide covers remaining-useful-life modelling and CMMS integration. This post stays closer to the signal: what you measure, how you transform it, and what the numbers legitimately tell you.

On the standards side, ISO 20816-1:2016 provides the general guidelines for measuring and evaluating machine vibration on rotating and non-rotating parts. ISO’s own catalogue entry describes it as covering absolute and relative radial shaft vibration and applying to both routine monitoring and acceptance testing (ISO 20816-1:2016). The machine-class specific parts replaced the older ISO 10816 and ISO 7919 series, a transition we unpack below because many plants still quote the old numbers.

The industry context in 2026 is a split between two worlds. Permanently installed, high-end systems on critical turbomachinery have used proximity probes and API 670 style protection for decades. Meanwhile, low-cost wireless and wired MEMS sensors have pushed vibration monitoring down to the thousands of “second-tier” motors, pumps and fans that previously got a monthly walk-around. The engineering challenge in that second tier is not hardware cost, it is making the data trustworthy and the alerts actionable at scale.

Reference Architecture for Vibration-Based Condition Monitoring

Short answer: a production vibration pipeline has five stages. A sensor converts acceleration to voltage, an analog front end filters and digitises it above twice the highest frequency of interest, an edge node computes spectra and features and applies ISO-style thresholds, a transport layer ships features and occasional raw bursts, and a cloud or plant historian trends, models and alerts.

Figure 1: Reference architecture. Raw waveforms stay at the edge by default; features, spectra snapshots and alarms travel upstream.

The diagram shows the central design decision: where the data volume collapses. A single triaxial sensor sampling at 25.6 kHz with 16-bit samples generates about 150 KB per second, or roughly 13 GB per day. Multiply by a few hundred sensors and shipping raw waveforms continuously is neither affordable nor useful. The edge node therefore reduces each acquisition window to tens of numbers and a coarse spectrum, and uploads raw data only on demand or on alarm.

Stage 1: Sensing and the measurement chain

The accelerometer is the foundation, and its limits cap everything downstream. Two families dominate.

IEPE (Integrated Electronics Piezo-Electric) sensors use a piezoelectric crystal with built-in charge amplification, powered by a constant-current source, typically 2 to 20 mA, that also carries the signal on the same coax. They offer wide bandwidth, often to 10 kHz or beyond, low noise, a wide dynamic range and long track record. The cost is the signal conditioning: you need a constant-current supply, AC coupling that introduces a low-frequency roll-off, and a data acquisition front end that supports IEPE.

MEMS accelerometers use a micro-machined proof mass and capacitive sensing. They are cheaper, small, DC-responsive and easy to integrate with digital interfaces. Modern industrial parts have narrowed the gap considerably. For example, Analog Devices lists the ADXL1002 as a single-axis, analog-output MEMS accelerometer with a ±50 g range, a flat response from DC to 11 kHz (3 dB point), a resonance at 21 kHz and a noise density of 25 micro-g per root hertz (ADXL1002 product page). That is credible for bearing monitoring on small and medium machines.

The trade-off is noise floor and bandwidth at the extreme. Early bearing faults generate very low amplitude, very high frequency content, and a noisier sensor buries it. A rule of thumb many practitioners use, which you should treat as heuristic and validate on your own machines, is that MEMS suits general machine health and mid-frequency bearing tones, while IEPE remains the safer choice for gearboxes with high mesh frequencies and for the earliest bearing defect detection.

Mounting matters as much as the sensor. A stud mount gives the best high-frequency transmission; adhesive is a fair compromise; a magnet is convenient but its mounted resonance can sit in the low kilohertz range and distort the spectrum; a handheld probe is only suitable for rough checks. A sensor with a 10 kHz datasheet bandwidth attached with a poor mount behaves like a 2 kHz sensor.

Stage 2: Sampling, anti-aliasing and Nyquist

The Nyquist criterion says you must sample at more than twice the highest frequency component, otherwise higher frequencies fold back as false lower ones. In practice, an anti-alias low-pass filter sits before the ADC, and because real filters roll off gradually, instruments use a ratio of about 2.56 between sample rate and usable bandwidth. A 25.6 kHz sample rate therefore gives a clean 10 kHz usable bandwidth. This is why vibration analyzers show odd-looking sample rates.

Two further parameters define the spectrum. Frequency resolution equals the sample rate divided by the number of samples: at 25.6 kHz and 65,536 samples (2.56 seconds), resolution is 0.39 Hz. Record length also sets how well you separate closely spaced lines, such as running speed sidebands. Choose the record length from the lowest frequency of interest, not from convenience.

Aliasing is the classic silent failure. A MEMS sensor with a digital output that does its own internal decimation is usually fine, but a cheap analog front end with no anti-alias filter, sampled at 5 kHz, will happily fold a 7 kHz bearing resonance into the 2 kHz region and create a “fault” that is only an artefact. Always confirm the filter corner and the sample rate together.

Stage 3: Edge computation

The edge node, a gateway or a smart sensor MCU, does four jobs: windowed FFT, envelope extraction, feature calculation and rule-based severity classification. This keeps latency low, reduces bandwidth by two to three orders of magnitude, and lets alarms fire even when the uplink is down. We return to the compute options, including WebAssembly runtimes for portable edge analytics, in the architecture section later and in our WASM edge runtime architecture guide.

Stage 4 and 5: Transport and analytics

Features and alarms travel over MQTT or OPC UA to a time-series store; raw bursts go to object storage. The cloud tier trends features per asset, trains models on fleet data, and issues work orders. The time-series layer is a design decision in its own right, and our Azure time-series database comparison of Data Explorer and Cosmos DB walks through retention and query trade-offs for exactly this feature-and-burst workload.

ISO 20816 Severity Zones: What the Standard Actually Says

The ISO 20816 series, “Mechanical vibration: Measurement and evaluation of machine vibration”, is the current framework for judging whether overall machine vibration is acceptable. Its parts split by machine class. According to ISO’s catalogue entry for Part 3, edition ISO 20816-3:2022 covers industrial machinery above 15 kW with operating speeds from 120 to 30,000 r/min, including electric motors with flexible coupling, fans, blowers, compressors, conveyors and smaller steam and gas turbines. The same page directs other machines elsewhere: large land-based turbines and generators above 40 MW at the standard synchronous speeds to Part 2, gas turbine sets above 3 MW to Part 4, hydropower sets to Part 5, and reciprocating compressor systems to Part 8 (ISO 20816-3:2022).

The supersession story, stated carefully

Many plant specifications still cite ISO 10816-3. ISO’s page for the 2022 edition lists ISO 10816-3:2009 (with its 2017 amendment) and ISO 7919-3:2009 among withdrawn predecessors, which is the clearest primary-source signal that Part 3 of the 20816 series replaces them. Not every part has migrated at the same pace: the same page still refers to ISO 10816-6 for reciprocating machines, ISO 10816-7 for rotordynamic pumps and ISO 10816-21 for wind turbines, so old numbers coexist with new ones for some machine classes. The practical rule is to check the catalogue entry for your specific machine class and edition before quoting a clause in a contract. ISO’s page also marks the 2022 edition as under revision, so expect further change.

Because both the old housing-vibration part and the old shaft-vibration part are listed as withdrawn, the 2022 edition appears to take over both roles for the covered machines; confirm the exact clause structure in your licensed copy.

Evaluation criteria and zones

The standard evaluates two things: the magnitude of broadband vibration, commonly RMS velocity in mm/s over a band of roughly 10 Hz to 1 kHz (confirm the band in your edition), and changes in that magnitude over time. Magnitude falls in one of four zones:

Zone A: typical of newly commissioned machines.
Zone B: acceptable for unrestricted long-term operation.
Zone C: generally unsatisfactory for long-term continuous operation; the machine can run for a limited period until remedial action is scheduled.
Zone D: vibration severe enough to likely cause damage.

Boundaries depend on machine group (by power or shaft height) and on whether the support is rigid or flexible. A support counts as rigid in a direction when the lowest natural frequency of machine plus support is at least 25% above the main excitation frequency. The table below reproduces the boundary values for the two common electrical machine groups as published in a secondary industry summary. These figures are not taken from the standard text, which is paywalled, so verify them against your licensed copy before using them for acceptance or contractual limits.

Group	Typical machines	Support	A/B (mm/s RMS)	B/C (mm/s RMS)	C/D (mm/s RMS)
1	Above 300 kW; shaft height 315 mm or more	Rigid	2.3	4.5	7.1
1	Above 300 kW; shaft height 315 mm or more	Flexible	3.5	7.1	11.0
2	15 to 300 kW; shaft height 160 to under 315 mm	Rigid	1.4	2.8	4.5
2	15 to 300 kW; shaft height 160 to under 315 mm	Flexible	2.3	4.5	7.1

Source of table values: Fabrico summary of ISO 20816 zones. Treat as indicative.

Why zones alone are not condition monitoring

Here is the original angle worth internalising: ISO zones are a severity gate, not a fault detector. An early bearing defect can sit comfortably inside Zone A for months because broadband velocity is dominated by low-frequency content such as unbalance and misalignment, while the defect lives in the kilohertz band at a tiny amplitude. A machine can be in Zone A and weeks from failure. Conversely a machine in Zone C might simply have a soft foot that a shim cures.

This produces a two-tier alarm design that works well in practice. Tier one applies ISO-derived limits to overall velocity, which keeps you honest against the standard and gives operators a familiar green-amber-red view. Tier two watches high-frequency indicators (envelope spectrum lines, kurtosis, high-band acceleration RMS) and trend slope, which catch faults earlier. Tier one answers “may we keep running”; tier two answers “what is changing, and how fast”.

Remember the unit conversion trap too. Velocity in mm/s RMS relates to acceleration and displacement by frequency: for a sinusoid, velocity amplitude equals acceleration amplitude divided by 2pif. A 1 g (9.81 m/s²) acceleration at 100 Hz corresponds to a peak velocity of 9.81 / (2pi100) = 15.6 mm/s, but the same 1 g at 5 kHz is only 0.31 mm/s. That is why velocity is a good severity measure for low-frequency mechanical problems and why bearing faults, which radiate at high frequency, hide in it.

From Waveform to Spectrum: A Runnable FFT and Envelope Pipeline

Short answer: compute an FFT of a windowed acceleration record to see frequency content, but for bearing faults you usually do not look at the raw spectrum. You band-pass around a structural resonance, take the Hilbert envelope, and FFT the envelope, where the repetition rate of impacts appears as a clean line at the defect frequency.

Figure 2: Two parallel analysis paths. The plain spectrum serves unbalance and misalignment; the envelope path serves rolling-element bearing faults.

Why the raw spectrum misses early bearing faults

When a ball rolls over a spall, it produces a short impulse. That impulse excites resonances of the bearing housing and sensor mount, which ring at several kilohertz and decay quickly. The impulses repeat at the defect frequency, say 107 Hz, but the energy sits around the resonance, say 3 to 5 kHz. In a plain FFT, the repetition rate appears only as weak sidebands buried in noise, while the resonance carries the energy. Amplitude modulation of the resonance at the defect rate is what envelope analysis demodulates.

The code

The following Python is runnable with NumPy and SciPy. It synthesises a signal from a damaged outer race (impacts at 107 Hz exciting a 4 kHz resonance, plus running-speed content and noise) and recovers the defect frequency. The numbers are illustrative; they are not measured data.

import numpy as np
from scipy import signal

fs = 25_600            # sample rate in Hz (2.56 x 10 kHz usable band)
T = 4.0                # seconds
t = np.arange(int(fs * T)) / fs
rng = np.random.default_rng(7)

# --- synthetic outer-race defect -------------------------------------
shaft_hz = 29.95       # about 1797 rpm
bpfo = 3.5848 * shaft_hz            # about 107.4 Hz
f_res, zeta = 4000.0, 0.05          # structural resonance and damping

x = 0.5 * np.sin(2 * np.pi * shaft_hz * t)              # unbalance
x += 0.2 * np.sin(2 * np.pi * 2 * shaft_hz * t)          # misalignment
impact_times = np.arange(0, T, 1.0 / bpfo)
impulse = np.zeros_like(t)
impulse[(impact_times * fs).astype(int)] = 1.0
tau = np.arange(0, 0.004, 1 / fs)
ring = np.exp(-zeta * 2 * np.pi * f_res * tau) * np.sin(2 * np.pi * f_res * tau)
x += 3.0 * np.convolve(impulse, ring, mode="same")
x += 0.3 * rng.standard_normal(t.size)                   # sensor noise

# --- 1. plain amplitude spectrum with Hann window --------------------
def amp_spectrum(sig, fs):
    w = np.hanning(sig.size)
    X = np.fft.rfft(sig * w)
    f = np.fft.rfftfreq(sig.size, 1 / fs)
    amp = 2 * np.abs(X) / w.sum()        # coherent-gain corrected
    return f, amp

f, A = amp_spectrum(x, fs)

# --- 2. envelope analysis -------------------------------------------
band = (2500, 6000)                       # chosen around the resonance
sos = signal.butter(4, band, btype="bandpass", fs=fs, output="sos")
xb = signal.sosfiltfilt(sos, x)
env = np.abs(signal.hilbert(xb))
env -= env.mean()                         # remove DC before FFT
fe, Ae = amp_spectrum(env, fs)

# --- 3. find the dominant low-frequency envelope line ----------------
mask = (fe > 20) & (fe < 500)
peak = fe[mask][np.argmax(Ae[mask])]
print(f"expected BPFO {bpfo:.1f} Hz, envelope peak {peak:.1f} Hz")

Run it and the envelope spectrum shows its dominant line within about 0.25 Hz of the 107.4 Hz target (the resolution is 1/4 s = 0.25 Hz), with harmonics at multiples. The plain spectrum, by contrast, shows strong lines at 29.95 and 59.9 Hz and a broad hump near 4 kHz but nothing definitive at 107 Hz.

Three implementation details cause most real-world mistakes. First, apply a window (Hann here) before the FFT to reduce spectral leakage, and correct amplitude by the window’s coherent gain. Second, choose the band-pass from data, not from a textbook: find the resonance with a spectral kurtosis map or a quick impact test and set the band around it. Third, remove the DC component of the envelope before transforming, otherwise a giant zero-frequency bin masks low-frequency lines.

Averaging and resolution in practice

A single 4-second FFT is noisy. Welch’s method splits the record into overlapping segments, windows each, and averages the power spectra, trading frequency resolution for variance reduction. For stationary machines average eight to sixteen records. For variable-speed machines, use order tracking instead: resample the signal at constant angle increments using a tachometer or a speed estimate so that bearing orders stay fixed at, for instance, 3.58 orders, regardless of rpm. Without order tracking, a 3% speed wander smears a 107 Hz line across about 3 Hz, enough to blur adjacent sidebands.

Bearing Fault Frequencies: Formulas and Worked Numbers

Every rolling-element bearing has four characteristic frequencies determined by geometry and shaft speed. They are kinematic: they assume pure rolling with no slip, so real machines deviate by one to two percent. Use them to place cursors on the envelope spectrum and see which defect, if any, is present.

Define n as the number of rolling elements, d as the rolling element diameter, D as the pitch diameter, theta as the contact angle, and fr as the shaft rotation frequency in Hz. Then:

BPFO (ball pass frequency, outer race) = (n / 2) * fr * (1 – (d / D) * cos theta)
BPFI (ball pass frequency, inner race) = (n / 2) * fr * (1 + (d / D) * cos theta)
FTF (fundamental train frequency, or cage frequency) = (fr / 2) * (1 – (d / D) * cos theta)
BSF (ball spin frequency) = (D / (2 d)) * fr * (1 – ((d / D) * cos theta)^2)

BPFO and BPFI have a handy sum: BPFO + BPFI = n * fr, because every rolling element passes both races once per relative revolution. Use it as a sanity check on any calculation.

Figure 3: Where each defect frequency originates and how it appears in the envelope spectrum, including the modulation sidebands that tell inner race, outer race and ball faults apart.

Worked example: a 6205 deep-groove ball bearing

The drive-end bearing in the widely used Case Western Reserve University (CWRU) test rig is a 6205-2RS JEM SKF deep-groove bearing. Its geometry as commonly tabulated is n = 9 balls, d = 0.3126 in (7.94 mm) and D = 1.537 in (39.04 mm) pitch diameter, with a contact angle of about zero. Take these as the commonly quoted values and confirm them on the dataset’s own documentation. The ratio d / D = 0.2034. At 1,797 rpm, fr = 29.95 Hz. Then:

BPFO = 4.5 * 29.95 * (1 – 0.2034) = 4.5 * 29.95 * 0.7966 = 107.4 Hz, or 3.585 times running speed.
BPFI = 4.5 * 29.95 * 1.2034 = 162.2 Hz, or 5.415 times running speed.
Check: 107.4 + 162.2 = 269.6 Hz, and n * fr = 9 * 29.95 = 269.6 Hz.
FTF = 0.5 * 29.95 * 0.7966 = 11.93 Hz, or 0.398 times running speed.
BSF = (1.537 / 0.6252) * 29.95 * (1 – 0.0414) = 2.458 * 29.95 * 0.9586 = 70.6 Hz, or 2.357 times running speed.

A ball defect strikes both the inner and the outer race once per spin, so the dominant envelope line for a ball fault usually appears at twice BSF, about 141 Hz or 4.71 times running speed. This factor of two trips up many first attempts. Published CWRU tables list 4.714 for the ball defect for this reason.

Reading the envelope spectrum like a diagnostician

Each defect leaves a signature beyond the base line. An outer race defect is stationary relative to the load zone, so impact amplitude is steady and the envelope shows BPFO and its harmonics, usually without strong sidebands. An inner race defect rotates through the load zone once per revolution, so impact amplitude is modulated at running speed and the envelope shows BPFI flanked by sidebands spaced at fr. A rolling-element defect rotates with the cage, so amplitude is modulated at FTF and you see 2*BSF with sidebands at FTF spacing. A cage defect appears at FTF and its harmonics, often with a low-frequency burst.

Two cautions apply. First, kinematic formulas assume known geometry, and bearing manufacturers publish the multipliers for specific part numbers; use those over hand calculation when available. Second, a spectrum line at the right frequency is evidence, not proof. Gear mesh sidebands, electrical line frequency and its harmonics, and belt frequencies can alias onto the same numbers. Confirm with trend, harmonics and sidebands before you stop a machine.

Features, Thresholds and the Move to Machine Learning

Time-domain and band features

Edge nodes typically compute a compact set of features per window per axis. They fall into groups with different diagnostic meaning.

Feature	What it measures	Typical use
RMS (velocity band)	Overall energy, links to ISO zones	Severity gate
RMS (acceleration, high band)	Energy above 2 to 5 kHz	Early bearing and lubrication trend
Peak and crest factor	Peak divided by RMS	Impulsiveness, early spalls
Kurtosis	Fourth statistical moment, 3 for Gaussian	Impact detection
Envelope band energy at BPFO, BPFI, BSF, FTF	Narrow-band amplitude at defect orders	Fault localisation
Spectral band energies	Energy in 1x, 2x, 3x and sub-harmonic bands	Unbalance, looseness, misalignment
Temperature or current	Correlated process variables	Context and false alarm suppression

Crest factor and kurtosis behave non-monotonically. They rise when isolated impacts appear, then fall again as damage spreads and the signal becomes continuously noisy, so a fixed upper threshold can miss an advanced fault. Always combine them with RMS trend. The healthy baseline is also machine-specific: a gearbox has a naturally higher crest factor than a pump, so thresholds must be relative to each asset’s own baseline rather than universal.

The following snippet computes the common feature set from a window and an envelope, ready to run on the signal generated earlier:

from scipy import stats

def features(x, env, fs, bpfo, shaft_hz):
    rms = float(np.sqrt(np.mean(x**2)))
    peak = float(np.max(np.abs(x)))
    f = {
        "rms": rms,
        "peak": peak,
        "crest": peak / rms,
        "kurtosis": float(stats.kurtosis(x, fisher=False)),
        "skew": float(stats.skew(x)),
    }
    fe, Ae = amp_spectrum(env - env.mean(), fs)
    def band_amp(center, width=1.0):
        m = (fe > center - width) & (fe < center + width)
        return float(Ae[m].max())
    f["env_bpfo"] = band_amp(bpfo)
    f["env_bpfo_2x"] = band_amp(2 * bpfo)
    f["env_1x"] = band_amp(shaft_hz)
    return f

print(features(x, env, fs, bpfo, shaft_hz))

Anomaly detection beats classification for most plants

The first instinct is supervised learning: label healthy, inner race, outer race, ball faults and train a classifier. The obstacle is data. Real plants have few labelled failures, and the failures they do have are specific to one machine, speed and load. The more robust strategy is unsupervised or semi-supervised anomaly detection per asset or per asset class: learn what “normal” looks like across operating states, then flag departures and let the envelope spectrum explain them.

A practical recipe: standardise features per asset, condition them on operating state (speed bucket and load bucket), fit an Isolation Forest, a one-class SVM or a small autoencoder on weeks of healthy data, and score new windows. Smooth the score with an exponentially weighted moving average and alarm on a sustained rise rather than a single exceedance. This cuts false positives far more than any model tweak.

from sklearn.ensemble import IsolationForest
from sklearn.preprocessing import StandardScaler
import pandas as pd

def fit_baseline(df: pd.DataFrame, cols: list[str]):
    sc = StandardScaler().fit(df[cols])
    model = IsolationForest(n_estimators=300, contamination="auto",
                            random_state=0).fit(sc.transform(df[cols]))
    return sc, model

def score(sc, model, df, cols, alpha=0.2):
    raw = -model.score_samples(sc.transform(df[cols]))   # higher = stranger
    return pd.Series(raw, index=df.index).ewm(alpha=alpha).mean()

The CWRU dataset trap

Almost every academic bearing-fault paper benchmarks on the CWRU bearing dataset, and many report accuracy above 99%. Be sceptical. The dataset contains seeded faults introduced by electro-discharge machining, at nominal diameters of 7, 14, 21 and 28 mils, in the inner race, outer race and ball, recorded at motor loads of 0 to 3 horsepower. Most records use 12 kHz sampling and some use 48 kHz. This is a clean laboratory with artificial damage, a handful of bearings and a very short list of operating conditions.

The deeper problem is evaluation. A recent study from the Federal University of Santa Catarina reports that a prior review found 40 of 41 CWRU-based studies published between 2008 and 2020 used experimental designs prone to data leakage, typically by splitting segments of the same recording into both training and test sets (Vieira et al., arXiv 2509.22267). A companion benchmarking paper notes that even load-based splits leak because the same physical faulty bearings are reused across loads, and that fault-size splits still must share the single healthy bearing pair across partitions (Rosa et al., arXiv 2407.14625).

The lesson for practitioners is to split by physical bearing or by machine, never by time segment within a recording, and to test on a different rig or plant before trusting any accuracy figure. A model that scores 99% on CWRU with random segment splits has demonstrated memorisation, not generalisation. If your vendor quotes only CWRU accuracy, ask for cross-machine results.

Edge vs Cloud Placement and Transport: OPC UA and MQTT

The compute placement question has a clean answer once you separate by latency, volume and learning horizon. Anything that must run every acquisition (FFT, envelope, features, ISO zone classification, hard alarms) belongs at the edge. Anything that learns across assets or time (fleet baselines, model training, remaining useful life, cross-plant benchmarking) belongs in the cloud or plant data centre. The edge applies the model; the cloud trains it.

Figure 4: Message flow. Features stream continuously, raw bursts upload on demand or on alarm, and model updates flow back down to the edge.

What to send, and how often

Think in three data classes. Features (RMS, kurtosis, crest, envelope line amplitudes, 5 to 30 numbers per axis per window) are tiny and go every acquisition, commonly every 1 to 10 minutes for slow-changing assets. Spectrum snapshots (a few hundred bins) go hourly or on state change, so analysts can inspect lines without pulling raw data. Raw bursts (seconds of waveform) go on alarm, on analyst request, or on a daily schedule for forensic record. This three-class split typically reduces uplink volume by several orders of magnitude compared with streaming everything, though the exact ratio depends on your acquisition cadence.

MQTT or OPC UA?

Both are widely used, and they fit different jobs. MQTT is a lightweight publish-subscribe protocol well suited to constrained devices and unreliable links; a retained “last value” and quality-of-service levels let a gateway reconnect without data loss. OPC UA gives a typed, browsable information model with built-in security, which is why the machinery vendors and PLC ecosystems favour it; its Pub/Sub extension can map to MQTT as a transport. A common 2026 pattern is OPC UA inside the plant for interoperability with the control system and MQTT, with Sparkplug-style or custom topics, from the plant edge to the cloud.

A sample MQTT payload for the feature class, with explicit units and a quality field, avoids a whole category of downstream parsing bugs:

{
  "asset": "pump-17",
  "point": "DE-horizontal",
  "ts": "2026-10-14T01:10:30Z",
  "fs": 25600,
  "window_s": 4.0,
  "speed_rpm": 1797,
  "load_pct": 82,
  "features": {
    "vel_rms_mm_s": 2.1,
    "acc_hf_rms_g": 0.31,
    "crest": 3.9,
    "kurtosis": 3.4,
    "env_bpfo_g": 0.012
  },
  "iso_zone": "B",
  "quality": "good"
}

Always include speed and load in every message. Without them, a rise in vibration cannot be told apart from a change in operating state, and the anomaly model will either flood you with alarms or learn to ignore real ones.

Edge runtime choices

On a Linux gateway, Python with NumPy and SciPy is sufficient, and the FFT of a 65,536-point record takes only milliseconds on a modern ARM core. On a microcontroller smart sensor you are limited to fixed-point or single-precision FFT libraries and small feature sets. A middle path gaining ground is compiling analytics modules to WebAssembly so the same feature code runs on gateways from different vendors with sandboxing and remote update; we cover the runtime options and their maturity in the WASM edge runtime architecture guide. Whatever the runtime, version the feature code and stamp the version into every message, because comparing features computed by two different algorithm versions silently corrupts your trend history.

Storage and the model lifecycle

Features land in a time-series database keyed by asset, measurement point and timestamp, with retention tiers: high-resolution for weeks, downsampled for years. Raw bursts go to cheap object storage with metadata in the time-series store. Model training reads features, not raw data, so retraining is cheap and reproducible. Ship a new model to the edge as a versioned artefact with a shadow period: run it in parallel for a week, compare its scores with the incumbent, and only then let it alarm. This mirrors the dark-launch discipline used for other safety-relevant detection systems.

Capacity planning, with illustrative numbers

Suppose a site has 400 measurement points, each producing a 4-second, 25.6 kHz, 16-bit record every 5 minutes. Raw volume is about 205 KB per record, so 400 points yield 288 records per day each, around 23.6 GB per day if everything were uploaded. Features-only at roughly 300 bytes per message come to about 35 MB per day. Add hourly spectrum snapshots of 800 bins at 4 bytes (about 3.2 KB) for around 31 MB per day. The edge-first design therefore moves tens of megabytes instead of tens of gigabytes. These are back-of-envelope figures to size a design, not measurements from a deployment.

Trade-offs, Gotchas, and What Goes Wrong

Sensor and mounting failures dominate real deployments. A loosened magnet mount, a cable with intermittent IEPE bias, or a sensor saturating on a large shock all produce plausible-looking spectra. Build sensor-health checks into the pipeline: monitor the IEPE bias voltage or a DC offset, flag flat-lined signals, and reject windows with clipping before they reach the model.

Variable speed breaks naive thresholds. Vibration amplitude scales with speed, and a drive running between 900 and 1,800 rpm will cross any fixed limit as a matter of course. Condition features on speed, track orders instead of hertz, and keep ISO zone checks tied to the speed range for which the standard applies.

Structural resonance and operating deflection shapes. A machine at the wrong speed excites its own resonance, producing large vibration that no bearing replacement will fix. If trending shows a rise only at a particular speed, suspect resonance before suspecting damage.

Trending beats absolute values, but trends need context. A 30% rise in high-band RMS over a month is more informative than a single value. But a lubrication event, a change of load or a re-greasing can each cause a step change that looks like a fault. Annotate maintenance events in the same store as the features.

Alarm fatigue is the actual failure of most programmes. If operators receive ten spurious alerts a week, they will ignore the eleventh, which is the real bearing. Prefer fewer, explained alarms: each should carry the feature that tripped it, the envelope spectrum with defect cursors, and the trend over the past month.

ISO limits apply to specific conditions. The standard’s evaluation applies to the covered machine classes under steady-state operating conditions, with measurement at defined locations and directions. Applying Group 2 rigid limits to a machine that is actually on a flexible foundation will mislabel it. Classify support stiffness properly, and do not use ISO zones for machines the standard excludes, such as large turbine generators, hydro sets or reciprocating machines, which fall under other parts.

Models drift. Bearings are replaced, motors rewound, process loads change. A model trained on last year’s baseline will drift. Plan a re-baselining workflow triggered by recorded maintenance events, and track alert precision over time as an operational metric.

Security and time. Vibration data is usually not secret, but the control path from edge to cloud is a foothold into the plant network. Use authenticated, encrypted transport (TLS for MQTT, OPC UA security policies), segment the monitoring network, and synchronise clocks with NTP or PTP; mis-timed windows across sensors make cross-axis and cross-machine comparison meaningless.

Practical Recommendations

Start from the failure modes that cost you money, not from the algorithm. Pick the twenty assets whose unplanned downtime is most expensive, instrument them properly, and prove the pipeline before scaling. A small number of well-mounted, well-understood sensors beats hundreds of poorly installed ones.

Use the standards for what they do well. Apply ISO 20816 to classify overall severity by machine group, confirm the edition and group for each asset in your licensed copy, and use the zones as your top-level gate. Layer envelope and trend analysis on top for early warning, and document which alarm comes from which layer so maintenance planners know whether to schedule a job or stop a machine.

Treat machine learning as an amplifier of good signal processing, not a substitute. Feed it clean, speed-conditioned features, train per asset class on healthy data, validate with splits by physical machine, and require every alert to be explainable by a spectrum or trend an engineer can read.

A short checklist to apply before go-live:

Sensor bandwidth and mount verified against the highest frequency of interest.
Sample rate at least 2.56 times the usable band, with a confirmed anti-alias filter.
Bearing geometry or manufacturer multipliers recorded per asset, defect frequencies computed and stored.
ISO 20816 part, edition, machine group and support stiffness documented per asset.
Speed and load attached to every feature message; feature code versioned.
Sensor-health and clipping checks upstream of the model.
Anomaly models validated with machine-wise splits, shadow-run before alarming.
Maintenance events logged next to the features, with a re-baseline procedure.

Frequently Asked Questions

What is vibration analysis in condition monitoring?

It is the practice of measuring machine vibration, usually with accelerometers, and analysing its amplitude, frequency content and trend to judge health. Overall levels are compared to standards such as ISO 20816 to classify severity, while spectrum and envelope analysis identify specific faults like bearing defects, unbalance or misalignment. The result feeds maintenance decisions so repairs are scheduled when evidence shows degradation rather than on a fixed calendar.

Does ISO 20816 replace ISO 10816?

For the machine classes it covers, yes in practice. ISO’s catalogue lists ISO 10816-3:2009 and ISO 7919-3:2009 as withdrawn predecessors of ISO 20816-3:2022. However, the same page still points to ISO 10816-6, -7 and -21 for reciprocating machines, rotordynamic pumps and wind turbines, so the transition is partial. Check the catalogue entry for your machine type and edition before citing a clause in a specification or contract.

How do I calculate bearing fault frequencies?

Use the bearing geometry: number of rolling elements n, ball diameter d, pitch diameter D, contact angle theta and shaft frequency fr. BPFO equals n/2 times fr times (1 minus d/D cos theta); BPFI uses plus instead of minus; FTF is half fr times (1 minus d/D cos theta). BSF is D/(2d) times fr times (1 minus (d/D cos theta) squared). Prefer manufacturer multipliers when available, and remember real values differ by a percent or two.

What sampling rate do I need for vibration monitoring?

Sample above twice the highest frequency you need, and in practice use about 2.56 times the usable bandwidth to leave room for the anti-alias filter roll-off. A 25.6 kHz rate gives a 10 kHz band, which suits most bearing work. Gearboxes with high mesh frequencies may need more. Record length sets resolution: resolution in hertz equals sample rate divided by sample count, so 4 seconds yields 0.25 Hz.

Why does my machine learning model fail outside the CWRU dataset?

CWRU is a laboratory dataset with seeded faults on a small number of bearings, and many studies split segments of the same recording between training and test sets, which leaks information. Research reviewing the literature found most CWRU-based studies used designs prone to this bias. Models then memorise recordings instead of learning fault physics. Split by physical bearing or machine, and validate on data from a different rig or plant.

Should I use IEPE or MEMS accelerometers?

Use IEPE where you need the widest bandwidth, lowest noise and the earliest bearing detection, such as critical machinery and gearboxes. Use MEMS when cost, size, digital integration and DC response matter and the fault frequencies of interest sit within the sensor’s bandwidth. A part like the ADXL1002, with a stated 11 kHz bandwidth and 25 micro-g per root hertz noise density, is credible for general bearing monitoring. Validate on your own machines.