PHM念叨叨系列--轴承与齿轮故障频率分析全流程指南

1. 故障频率理论

1.1 轴承故障特征频率

假设轴承参数：

• Z = 滚动体数量
• D = 滚动体直径 (mm)
• d = 节圆直径 (mm)
• α = 接触角 (°)

其中 Fs = 旋转频率 (Hz) = RPM / 60

1.2 齿轮故障特征频率

• 啮合频率 (Mesh Frequency): Fm = Z_gear * Fs (Z_gear = 齿数)
• 故障调制边频带: 在 Fm 两侧出现间隔为轴频 Fs 的边频带
• 常见故障：断齿、磨损、偏心 → 在 Fm 处幅值异常增高，边频带明显

2. 全流程分析步骤

数据采集 → 预处理 → 频谱分析 → 包络解调(轴承) → 阶次跟踪(可选) → 诊断决策

3. Python 代码实现

3.1 环境准备

pip install numpy scipy matplotlib pandas tqdm

3.2 完整分析脚本

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
轴承/齿轮故障频率分析全流程
支持：时域波形 → 频谱 → 包络谱 → 自动选择包络频段 → 故障特征检测
"""

import numpy as np
import matplotlib.pyplot as plt
from scipy import signal, fft
import pandas as pd
from pathlib import Path
from typing import Dict, Tuple, Optional, List
import warnings
warnings.filterwarnings('ignore')

class FaultFrequencyAnalyzer:
"""故障频率分析器"""

def __init__(self, fs: float, rpm: float, bearing_params: Optional[Dict] = None, gear_params: Optional[Dict] = None):
"""
初始化分析器

Parameters:
———–
fs : float
采样频率 (Hz)
rpm : float
转速 (RPM)
bearing_params : dict
轴承参数: {'Z': 12, 'D': 10, 'd': 50, 'alpha': 0} (alpha 弧度)
gear_params : dict
齿轮参数: {'Z_gear': 60}
"""
self.fs = fs
self.rpm = rpm
self.Fs = rpm / 60.0 # 旋转频率 Hz

self.bearing_params = bearing_params
self.gear_params = gear_params

# 计算特征频率
self._calc_bearing_freqs()
self._calc_gear_freqs()

def _calc_bearing_freqs(self):
"""计算轴承故障特征频率"""
if not self.bearing_params:
self.bpfo = self.bpfi = self.bsf = self.ftf = None
return

Z = self.bearing_params['Z']
D = self.bearing_params['D']
d = self.bearing_params['d']
alpha = self.bearing_params.get('alpha', 0) # 弧度，默认0

# 频率系数
factor_d = d / D
cos_alpha = np.cos(alpha)

self.bpfo = (Z / 2) * (1 – factor_d * cos_alpha) * self.Fs
self.bpfi = (Z / 2) * (1 + factor_d * cos_alpha) * self.Fs
self.bsf = (D / d) * (1 – factor_d**2 * cos_alpha**2) * self.Fs / 2
self.ftf = (1 / 2) * (1 – factor_d * cos_alpha) * self.Fs

print(f"[轴承特征频率] BPFO={self.bpfo:.2f}Hz, BPFI={self.bpfi:.2f}Hz, "
f"BSF={self.bsf:.2f}Hz, FTF={self.ftf:.2f}Hz")

def _calc_gear_freqs(self):
"""计算齿轮故障特征频率"""
if not self.gear_params:
self.Fm = None
return

Z_gear = self.gear_params['Z_gear']
self.Fm = Z_gear * self.Fs
print(f"[齿轮特征频率] 啮合频率 Fm={self.Fm:.2f}Hz, 轴频={self.Fs:.2f}Hz")

def load_signal(self, data: np.ndarray, channel: int = 0) –> np.ndarray:
"""加载振动信号"""
if data.ndim > 1:
self.signal = data[:, channel]
else:
self.signal = data
self.N = len(self.signal)
self.t = np.arange(self.N) / self.fs
print(f"[数据] 长度={self.N}, 时长={self.N/self.fs:.2f}s, fs={self.fs}Hz")
return self.signal

def preprocess(self, hp_order: int = 2, hp_cutoff: float = 10.0,
lp_order: int = 4, lp_cutoff: float = 1000.0) –> np.ndarray:
"""
预处理：去趋势 + 带通滤波

Parameters:
———–
hp_cutoff : float
高通截止频率 (Hz)，去除非周期分量
lp_cutoff : float
低通截止频率 (Hz)，保留故障频段
"""
# 1) 去趋势（移除直流和低频趋势）
self.signal_detrended = signal.detrend(self.signal, type='linear')

# 2) 带通滤波
nyq = self.fs / 2
b, a = signal.butter(N=2, Wn=hp_cutoff/nyq, btype='high')
self.signal_hp = signal.filtfilt(b, a, self.signal_detrended)

b, a = signal.butter(N=lp_order, Wn=lp_cutoff/nyq, btype='low')
self.signal_filtered = signal.filtfilt(b, a, self.signal_hp)

print(f"[预处理] 去趋势 + 带通[{hp_cutoff:.1f}–{lp_cutoff:.1f}]Hz")
return self.signal_filtered

def compute_spectrum(self, nperseg: int = 2048, noverlap: int = 1024) –> Tuple[np.ndarray, np.ndarray]:
"""计算功率谱密度 (PSD)"""
self.f, self.Pxx = signal.welch(
self.signal_filtered,
fs=self.fs,
nperseg=nperseg,
noverlap=noverlap,
window='hann',
scaling='density'
)
self.amp_spectrum = np.sqrt(self.Pxx) # 振幅谱
print(f"[频谱] 频率分辨率={self.f[1]–self.f[0]:.3f}Hz, bins={len(self.f)}")
return self.f, self.amp_spectrum

def _estimate_resonance_band(self, freq_range: Tuple[float, float] = (1000, 10000),
band_width: float = 1000.0, step: float = 200.0) –> Tuple[float, float]:
"""
自动估计高频共振带（用于包络解调的载波频段）

原理：在高频段滑动窗口，计算每个窗口的能量或峰度，选择能量最集中（或峰度最高）的区间

Parameters:
———–
freq_range : tuple
搜索频率范围 (min, max)
band_width : float
候选带宽度
step : float
滑动步长

Returns:
——–
best_band : tuple
(lower, upper) 最佳共振带
"""
# 确保已计算频谱
if not hasattr(self, 'amp_spectrum'):
raise RuntimeError("请先调用 compute_spectrum() 计算频谱")

# 截取搜索范围
mask = (self.f >= freq_range[0]) & (self.f <= freq_range[1])
f_search = self.f[mask]
amp_search = self.amp_spectrum[mask]

if len(f_search) == 0:
print("[警告] 搜索范围内无频率点，使用默认带")
return (2000, 5000)

# 滑动窗口评估
best_score = –np.inf
best_band = (freq_range[0], freq_range[0] + band_width)

for low in np.arange(freq_range[0], freq_range[1] – band_width, step):
high = low + band_width
# 窗口索引
win_mask = (f_search >= low) & (f_search <= high)
if not np.any(win_mask):
continue
window_amp = amp_search[win_mask]

# 评估指标：窗口内总能量 + 峰度（冲击性）
energy = np.sum(window_amp**2)
# 计算峰度（kurtosis）衡量冲击强度
if len(window_amp) > 4:
kurt = np.mean((window_amp – np.mean(window_amp))**4) / (np.var(window_amp)**2 + 1e-10)
else:
kurt = 0

# 综合得分（可调权重）
score = energy * (1 + 0.1 * kurt)

if score > best_score:
best_score = score
best_band = (low, high)

print(f"[自动包络带] 搜索范围{freq_range} → 最佳带 {best_band} (得分={best_score:.2f})")
return best_band

def envelope_demodulation(self, carrier_band: Optional[Tuple[float, float]] = None) –> np.ndarray:
"""
包络解调 (轴承故障关键步骤)

Parameters:
———–
carrier_band : tuple or None
带通滤波提取载波频段 (Hz)。如果为 None，则自动选择

Returns:
——–
env_amp : np.ndarray
包络谱幅值
"""
# 自动选择
if carrier_band is None:
carrier_band = self._estimate_resonance_band()
print(f"[包络解调] 使用自动选择的载波频段: {carrier_band}")

# 1) 带通滤波提取高频共振区
nyq = self.fs / 2
b, a = signal.butter(N=6,
Wn=(carrier_band[0]/nyq, carrier_band[1]/nyq),
btype='bandpass')
signal_bp = signal.filtfilt(b, a, self.signal_filtered)

# 2) 希尔伯特变换获取包络
analytic_signal = signal.hilbert(signal_bp)
envelope = np.abs(analytic_signal)

# 3) 包络谱分析
self.env_f, self.env_amp = self._compute_spectrum(envelope)

print(f"[包络解调] 载波频段{carrier_band[0]:.0f}–{carrier_band[1]:.0f}Hz → 包络谱分辨率{self.env_f[1]–self.env_f[0]:.3f}Hz")
return self.env_amp

def _compute_spectrum(self, sig: np.ndarray, nperseg: int = 8192) –> Tuple[np.ndarray, np.ndarray]:
"""辅助：计算单边谱"""
N = len(sig)
Y = fft.rfft(sig * np.hanning(N))
freq = fft.rfftfreq(N, 1/self.fs)
amp = 2 * np.abs(Y) / N
return freq, amp

def find_peaks_near(self, target_freqs: list, tolerance: float = 0.5,
min_prominence: float = 0.1) –> Dict[float, Dict]:
"""
在频谱中查找接近目标频率的峰值

Returns:
——–
peaks_info : dict
{target_freq: {'peak_freq':实际频率, 'amp':幅值, 'diff':差值, 'order':阶次}}
"""
peaks_info = {}

# 峰值检测
peaks, props = signal.find_peaks(
self.amp_spectrum,
height=None,
prominence=min_prominence * np.max(self.amp_spectrum),
distance=int(self.fs / 100) # 最小间隔10Hz
)

peak_freqs = self.f[peaks]
peak_amps = self.amp_spectrum[peaks]

for tf in target_freqs:
# 查找附近峰值
nearby = np.where(np.abs(peak_freqs – tf) <= tolerance)[0]
if len(nearby) > 0:
idx = nearby[np.argmax(peak_amps[nearby])]
real_f = peak_freqs[idx]
amp = peak_amps[idx]
diff = real_f – tf
order = real_f / self.Fs if self.Fs > 0 else 0

peaks_info[tf] = {
'peak_freq': float(real_f),
'amp': float(amp),
'diff': float(diff),
'order': float(order)
}
return peaks_info

def diagnose_bearing(self, env_carrier_band: Optional[Tuple[float, float]] = None) –> Dict:
"""
轴承故障诊断全流程

Parameters:
———–
env_carrier_band : tuple or None
包络解调载波频段。None=自动选择

Returns:
——–
result : dict
诊断结果，包含各特征频率峰值信息
"""
print("\\n=== 轴承故障诊断流程 ===")

# 1. 预处理
self.preprocess(hp_cutoff=10, lp_cutoff=env_carrier_band[1]*1.5 if env_carrier_band else 10000)

# 2. 普通频谱
f, amp = self.compute_spectrum(nperseg=4096)

# 3. 包络解调
self.envelope_demodulation(carrier_band=env_carrier_band)

# 4. 查找特征频率峰值 (在包络谱中)
if self.bpfo:
targets = [self.bpfo, self.bpfi, self.bsf, self.ftf]
peaks = self.find_peaks_near(targets, tolerance=0.5, min_prominence=0.05)

print("\\n[诊断结果] 包络谱特征频率峰值:")
for tf, info in peaks.items():
type_name = {self.bpfo: 'BPFO', self.bpfi: 'BPFI',
self.bsf: 'BSF', self.ftf: 'FTF'}.get(tf, '未知')
print(f" {type_name:6s} 理论={tf:6.1f}Hz 实际={info['peak_freq']:6.1f}Hz "
f"幅值={info['amp']:.4f} 阶次={info['order']:.2f}")

# 5. 简单决策逻辑
max_amp = max([p['amp'] for p in peaks.values()], default=0)
if max_amp > 0.01 * np.max(self.env_amp):
dominant = max(peaks.items(), key=lambda x: x[1]['amp'])
print(f"\\n>>> 检测到 { {self.bpfo:'外圈', self.bpfi:'内圈', self.bsf:'滚动体', self.ftf:'保持架'}.get(dominant[0]) } 故障特征")
else:
print("\\n>>> 未检测到明显轴承故障特征")

return {
'bearing_freqs': {'BPFO': self.bpfo, 'BPFI': self.bpfi, 'BSF': self.bsf, 'FTF': self.ftf},
'peaks': peaks,
'envelope_spectrum': (self.env_f, self.env_amp)
}

def diagnose_gear(self, sideband_width: float = 5.0) –> Dict:
"""
齿轮故障诊断（基于啮合频率边频带分析）

Parameters:
———–
sideband_width : float
搜索边频带的宽度 (Hz)
"""
print("\\n=== 齿轮故障诊断流程 ===")

# 预处理（较大通带）
self.preprocess(hp_cutoff=5, lp_cutoff=5000)
f, amp = self.compute_spectrum(nperseg=8192)

if not self.Fm:
print("[错误] 未设置齿轮参数")
return {}

# 查找 Fm 及其整数倍频
harmonics = []
for h in range(1, 6): # 1-5次谐波
target = h * self.Fm
idx = np.argmin(np.abs(f – target))
if np.abs(f[idx] – target) < 1.0: # 接近
harmonics.append({
'harm': h,
'freq': float(f[idx]),
'amp': float(amp[idx])
})

print("\\n[啮合频率谐波]")
for h in harmonics:
print(f" {h['harm']}Fm = {h['freq']:.1f}Hz, 幅值={h['amp']:.4f}")

# 分析边频带 (在 Fm 附近搜索)
Fm_idx = np.argmin(np.abs(f – self.Fm))
sideband_range = int(sideband_width / (f[1]–f[0])) # 点数
search_start = max(0, Fm_idx – sideband_range)
search_end = min(len(f), Fm_idx + sideband_range + 1)

# 边频带峰值检测（相对 Fm 的偏移）
sideband_peaks = []
for offset in range(–sideband_range, sideband_range+1):
idx = Fm_idx + offset
if idx < 0 or idx >= len(f):
continue
# 要求峰值显著高于相邻谱线（简单边带检测）
if amp[idx] > 0.5 * amp[Fm_idx]: # 边频带幅值超过 Fm 50%
sideband_peaks.append({
'freq': float(f[idx]),
'amp': float(amp[idx]),
'offset_order': (f[idx] – self.Fm) / self.Fs
})

if sideband_peaks:
print(f"\\n[边频带检测] 发现 {len(sideband_peaks)} 条显著边频带:")
for sb in sorted(sideband_peaks, key=lambda x: x['amp'], reverse=True)[:5]:
print(f" {sb['freq']:.1f}Hz (偏移 {sb['offset_order']:.2f}阶), 幅值={sb['amp']:.4f}")
print("\\n>>> 齿轮可能存在局部故障（边频带明显）")
else:
print("\\n>>> 未发现显著边频带，齿轮状态可能正常")

return {
'mesh_freq': self.Fm,
'harmonics': harmonics,
'sidebands': sideband_peaks,
'spectrum': (f, amp)
}

def plot_results(self, bearing_result: Dict, gear_result: Dict, save_path: Optional[Path] = None):
"""可视化分析结果"""
fig, axes = plt.subplots(3, 2, figsize=(14, 10))
fig.suptitle(f'故障诊断分析 (RPM={self.rpm}, Fs={self.Fs:.2f}Hz)', fontsize=14)

# (1) 原始时域
axes[0,0].plot(self.t[:min(5000, self.N)], self.signal[:min(5000, self.N)], 'b-')
axes[0,0].set_xlabel('Time (s)'); axes[0,0].set_ylabel('Amplitude')
axes[0,0].set_title('原始信号 (前5k点)')
axes[0,0].grid(alpha=0.3)

# (2) 全频谱 (0-1000Hz)
f, amp = self.compute_spectrum()
axes[0,1].plot(f, amp, 'g-')
axes[0,1].set_xlabel('Frequency (Hz)'); axes[0,1].set_ylabel('Amplitude')
axes[0,1].set_title('全频谱 (0-1000Hz)')
axes[0,1].set_xlim(0, min(1000, self.fs/2))
axes[0,1].grid(alpha=0.3)

# (3) 包络谱 (轴承)
if 'envelope_spectrum' in bearing_result:
env_f, env_amp = bearing_result['envelope_spectrum']
axes[1,0].plot(env_f, env_amp, 'r-')
axes[1,0].set_xlabel('Frequency (Hz)'); axes[1,0].set_ylabel('Envelope Amp')
axes[1,0].set_title('包络谱 (轴承诊断)')
axes[1,0].set_xlim(0, 500)
# 标记特征频率
for name, freq in bearing_result['bearing_freqs'].items():
if freq:
axes[1,0].axvline(freq, color='orange', linestyle='–', alpha=0.7, label=name)
axes[1,0].legend(fontsize=8)
axes[1,0].grid(alpha=0.3)

# (4) 局部频谱 (齿轮啮合频率区域)
if self.Fm:
ax = axes[1,1]
f, amp = gear_result['spectrum']
ax.plot(f, amp, 'm-')
ax.set_xlabel('Frequency (Hz)'); ax.set_ylabel('Amplitude')
ax.set_title(f'啮合频率区域 (Fm={self.Fm:.1f}Hz)')
ax.axvline(self.Fm, color='red', linestyle='–', label='Fm')
ax.set_xlim(max(0, self.Fm–200), self.Fm+200)
ax.legend()
ax.grid(alpha=0.3)

# (5) 阶次图 (包络谱)
if 'envelope_spectrum' in bearing_result:
env_f, env_amp = bearing_result['envelope_spectrum']
order = env_f / max(self.Fs, 0.1)
axes[2,0].plot(order, env_amp, 'c-')
axes[2,0].set_xlabel('Order'); axes[2,0].set_ylabel('Envelope Amp')
axes[2,0].set_title('包络阶次谱')
axes[2,0].set_xlim(0, 20)
axes[2,0].grid(alpha=0.3)
# 标记常见阶次
for name, freq in bearing_result['bearing_freqs'].items():
if freq:
ord_val = freq / self.Fs
axes[2,0].axvline(ord_val, color='orange', linestyle='–', alpha=0.5, label=name)

# (6) 诊断摘要
ax = axes[2,1]
ax.axis('off')
summary = []
if bearing_result['peaks']:
dominant = max(bearing_result['peaks'].items(), key=lambda x: x[1]['amp'])
fault_type = {self.bpfo:'外圈', self.bpfi:'内圈', self.bsf:'滚动体', self.ftf:'保持架'}.get(dominant[0], '未知')
summary.append(f"轴承故障: {fault_type} ({dominant[0]:.1f}Hz, 幅值={dominant[1]['amp']:.4f})")
else:
summary.append("轴承: 未检测明显故障特征")

if gear_result.get('sidebands'):
summary.append(f"齿轮: 边频带显著 (Fm={self.Fm:.1f}Hz), 可能存在局部故障")
else:
summary.append("齿轮: 边频带不明显")

ax.text(0, 0.9, "\\n".join(summary), fontsize=12, verticalalignment='top')
ax.set_title('诊断结论')

plt.tight_layout()
if save_path:
plt.savefig(save_path, dpi=150)
print(f"\\n[图表] 已保存至 {save_path}")
plt.show()

# ==================== 使用示例 ====================

def generate_synthetic_data(fs=20000, duration=10, rpm=1500,
bearing_params={'Z': 12, 'D': 10, 'd': 50, 'alpha': 0},
add_noise=True, fault_type='outer'):
"""
生成合成轴承振动信号（用于演示）
"""
t = np.arange(int(fs*duration)) / fs
Fs = rpm / 60
Ts = 1 / Fs

# 计算特征频率
analyzer = FaultFrequencyAnalyzer(fs=fs, rpm=rpm, bearing_params=bearing_params)
bpfo, bpfi, bsf, ftf = analyzer.bpfo, analyzer.bpfi, analyzer.bsf, analyzer.ftf

# 冲击周期
if fault_type == 'outer':
fault_freq = bpfo
elif fault_type == 'inner':
fault_freq = bpfi
elif fault_type == 'ball':
fault_freq = bsf
else:
fault_freq = None

# 基础稳态振动（正弦）
base_freq = Fs * 2 # 2倍频
signal = 0.5 * np.sin(2*np.pi*base_freq*t)

# 添加周期性冲击（故障特征）
if fault_freq:
# 冲击响应（衰减正弦）
impulse_len = int(fs / 10) # 0.1s
impulse = np.exp(–np.arange(impulse_len) / (fs/500)) * np.sin(2*np.pi*5000*np.arange(impulse_len)/fs)
impulse = impulse / np.max(np.abs(impulse)) * 0.3

# 周期性叠加
T_fault = 1 / fault_freq
period_samples = int(T_fault * fs)
for i in range(0, len(t), period_samples):
end = min(i+impulse_len, len(t))
signal[i:end] += impulse[:end–i]

# 加噪声
if add_noise:
signal += 0.1 * np.random.randn(len(t))

return signal[:, None] # 二维数组模拟多通道

def main():
"""主流程演示"""
print("=== 轴承/齿轮故障频率分析 ===\\n")

# 1. 参数设置
fs = 20000 # 采样率 20kHz
rpm = 1500 # 转速 1500 RPM
duration = 5 # 信号时长 5秒

# 轴承参数（SKF 6205 示例）
bearing_params = {
'Z': 12, # 滚动体数
'D': 10, # 滚动体直径 mm
'd': 50, # 节圆直径 mm
'alpha': 0 # 接触角 弧度（0=径向）
}

# 2. 初始化分析器
analyzer = FaultFrequencyAnalyzer(fs=fs, rpm=rpm, bearing_params=bearing_params)

# 3. 生成/加载信号
print("\\n[步骤1] 数据采集与加载")
data = generate_synthetic_data(fs=fs, duration=duration, rpm=rpm,
bearing_params=bearing_params, fault_type='outer')
signal = analyzer.load_signal(data, channel=0)

# 4. 轴承诊断（自动选择包络频段）
bearing_result = analyzer.diagnose_bearing(env_carrier_band=None) # None = 自动

# 5. 齿轮诊断（示例：60齿齿轮）
analyzer.gear_params = {'Z_gear': 60}
gear_result = analyzer.diagnose_gear()

# 6. 可视化
analyzer.plot_results(bearing_result, gear_result, save_path=Path('fault_analysis_result.png'))

print("\\n=== 分析完成 ===")

if __name__ == "__main__":
main()

4. 自动选择包络频率段算法说明

4.1 算法原理

_estimate_resonance_band() 方法自动选择包络解调的载波频段：

4.2 调参建议

4.3 优缺点

优点：

• 无需人工经验，适配不同设备
• 基于数据驱动，选择客观

缺点：

• 计算量稍增（滑动窗口评估）
• 极端噪声下可能选错（建议结合时域 Kurtosis 判断）

5. 注意事项

5.1 数据采集

• 采样频率：至少为最高特征频率的 2.56 倍（建议 fs ≥ 10× BPFO）
• 记录长度：至少包含 10 个旋转周期，越长频谱分辨率越高
• 传感器：加速度计（高频）、转速计（同步采集）
• 触发方式：如果转速波动大，建议使用阶次跟踪（order tracking）

5.2 参数准确性

• 轴承参数必须精确（Z/D/d/α），否则特征频率计算偏差会导致误判
• 接触角 α 对 BPFO/BPFI 影响显著（深沟球轴承 α=0，角接触轴承 α≠0）
• 齿轮齿数必须正确，啮合频率才准确

5.3 包络解调关键

• 自动选择包络带可能不适应所有场景，可手动覆盖 env_carrier_band 参数
• 带通滤波器带宽需足够捕捉冲击成分，又避免噪声
• 包络谱的频率分辨率通常小于原始频谱（因单边谱点数少）

5.4 噪声与干扰

• 负载变化、滑动、转速波动会模糊特征谱线
• 强噪声下使用倒频谱 (cepstrum) 或同步平均（ synchronous averaging）增强周期冲击
• 其他机械振动可能掩盖轴承/齿轮特征，需结合时域指标（kurtosis, crest factor）综合判断

5.5 误判风险

• 特征频率附近无峰值 ≠ 无故障（可能冲击微弱）
• 有其他部件故障频率重叠时（如电机槽频率、泵叶片频率）需谨慎
• 建议多次测量，趋势对比比单点阈值更可靠

5.6 阶次分析

• 如果转速不均匀，传统频谱会扩散 → 改用 阶次谱（Order Domain）
• 需要转速脉冲（键相器）同步采集
• 使用 order_tracking 库或重采样（resample）方法

6. 总结

• 轴承：重点看包络谱中 BPFO/BPFI/BSF/FTF 峰值，冲击明显时包络谱幅值高
• 齿轮：重点看啮合频率 Fm 是否异常增高，以及两侧边频带（间隔轴频）是否显著
• 实际数据往往需多次尝试滤波器参数、包络频段才能得到清晰特征
• 最重要的：特征频率理论值只是参考，实际频谱可能受 manufacturing tolerance、load、滑差等影响，峰值可能在理论值 ±1-2Hz 内均算有效

使用建议：先运行示例生成合成数据进行测试，确认算法有效后，替换为真实采集数据即可。真实数据注意调整 preprocess 的滤波参数和 _estimate_resonance_band 的搜索范围。