ADC 采样总是跳：5 种滤波算法从原理到实测对比

一句话结论：ADC 读数跳，先别怪硬件——用「尖峰抑制 + 滑动平均」串联，噪声可以降一个数量级，且几乎不增加延迟。

一、完整工程下载

压缩包内含全部源码、platformio.ini、Makefile、README.md，解压即用，不需要额外配置。

下载 adc-filter.zip　（8.0 KB，共 7 个文件）

.gitignore
Makefile
README.md
include/
  filter.h
platformio.ini
src/
  filter.c
test/
  test_filter.c

先搞清楚噪声长什么样

ADC 的噪声分两类，处理手段完全不同：

噪声类型	表现	对策
白噪声（随机抖动）	每次读数在真值附近±几 LSB 抖动	求平均最有效
脉冲噪声（尖刺）	偶发一次跳几十 LSB，马上恢复	中值/限幅最有效

所以工业做法是两级串联：

原始 ADC --> [ 限幅滤波（砍尖刺）] --> [ 滑动平均（压白噪声）] --> 使用值

五种算法逐一说明

1. 算术平均（均值滤波）

每采样 N 次求平均。噪声标准差降到 σ/√N。 N=16 时噪声降到 1/4，但延迟 N 个采样周期，动态信号会被严重扭曲。

2. 中值滤波（取中间值）

排序后取中间那个。对尖刺几乎是完美的免疫，但对连续白噪声的效果不如平均。N 只能取奇数。

3. 滑动窗口平均

维护最近 N 个点的和（加减法增量更新），每个采样点都输出一个平均值：

sum -= buf[idx];
buf[idx] = sample;
sum += sample;
idx = (idx + 1) % N;
return sum / N;

优点：输出连续、实现简单、延迟只有 N/2。缺点：窗口里混入一个尖刺，会被"分摊"到 N 个输出上（这也是它需要配合限幅的原因）。

4. 一阶 IIR（指数加权平均）

y(k) = α·x(k) + (1-α)·y(k-1)

α 越小越平滑、越滞后。它的地位相当于"模拟世界的 RC 低通"， 只需一个变量，非常适合高频采样（如 1kHz 电流环）。 α 和时间常数的关系：τ ≈ Ts·(1-α)/α。

5. 限幅滤波（尖峰抑制）

if (fabsf(sample - last) > THRESHOLD) {
    return last;    /* 变化太快，判定为干扰，丢弃 */
}

关键在于 THRESHOLD 怎么取：小于这个系统物理上可能的最大变化率。比如温度传感器每秒最多变 0.5℃，采样 10Hz，那阈值就是 0.05℃。

工程内容

filter.c/h：五种算法全部实现，统一 filter_* 接口，可级联
每个结构体都不用 malloc，直接静态分配
test/test_filter.c：用确定性的伪随机噪声（含植入的尖刺）跑完整对比，

打印「原始标准差 / 滤波后标准差 / 降噪倍数 / 群延迟」

怎么用

static adc_pipeline_t adc;

void adc_init_pipeline(void) {
    adc_pipeline_init(&adc, /*window=*/8, /*alpha=*/0.2f, /*spike_limit=*/30);
}

/* 每毫秒调用一次 */
uint16_t adc_read_filtered(void) {
    return adc_pipeline_push(&adc, adc_raw_read());
}

调试要点

别把滤波当万能药。如果噪声是 50Hz 工频串进来的（电源/地线问题），

滤波只会把它涂开，根源要改 PCB 走线、加 RC、用差分输入

先看原始数据。把未滤波的数据画成波形，判断是白噪声还是尖刺，

再决定用哪一级

算一下你需要的带宽。滤波一定会带来延迟，

控制环里积分这个延迟可能导致振荡

ADC 自身配置也要对：采样时间太短（转换不充分）、

参考电压不稳、DMA 与 CPU 争总线都会引入噪声

进阶方向

上 卡尔曼滤波：需要噪声模型，效果优于任何固定参数滤波（本站另有专文）
用 过采样 + 抽取（Oversampling）：STM32 的 ADC 支持硬件过采样，

16 倍过采样 + 4 位右移直接白赚 2 位有效分辨率

做 多点校准：分段线性插值，把系统误差也消掉（本站另有专文）

完整代码

`Makefile`

CC      ?= gcc
CFLAGS  ?= -std=c99 -Wall -Wextra -O2 -Iinclude
LDLIBS  ?= -lm
SRC      = src/filter.c
TEST     = test/test_filter.c

ifeq ($(OS),Windows_NT)
EXT = .exe
endif
BIN = build/test$(EXT)

all: run

$(BIN): $(SRC) $(TEST)
	@mkdir -p build
	$(CC) $(CFLAGS) $(SRC) $(TEST) -o $(BIN) $(LDLIBS)

run: $(BIN)
	@$(BIN)

clean:
	rm -rf build

.PHONY: all run clean

`include/filter.h`

/**
 * filter.h - 常用 ADC 滤波算法集合（全部静态分配，零 malloc）
 */
#ifndef FILTER_H
#define FILTER_H

#include <stdbool.h>
#include <stdint.h>

#ifdef __cplusplus
extern "C" {
#endif

/* ---------- 1. 均值滤波：每 N 次输出一次 ---------- */
typedef struct {
    uint32_t sum;
    uint16_t n;      /* 目标样本数 */
    uint16_t cnt;
} mean_filter_t;

void mean_filter_init(mean_filter_t *f, uint16_t n);
/** @return true 表示凑满 N 个样本，out 有效 */
bool mean_filter_update(mean_filter_t *f, uint16_t sample, uint16_t *out);

/* ---------- 2. 中值滤波：奇数长度窗口 ---------- */
#define MEDIAN_MAX 9
typedef struct {
    uint16_t buf[MEDIAN_MAX];
    uint8_t n;       /* 必须是奇数 */
    uint8_t idx;
    uint8_t filled;
} median_filter_t;

void median_filter_init(median_filter_t *f, uint8_t n);
uint16_t median_filter_update(median_filter_t *f, uint16_t sample);

/* ---------- 3. 滑动窗口平均（增量更新） ---------- */
#define MOVAVG_MAX 32
typedef struct {
    uint16_t buf[MOVAVG_MAX];
    uint32_t sum;
    uint8_t n;       /* 窗口大小 */
    uint8_t idx;
    uint8_t filled;
} movavg_filter_t;

void movavg_filter_init(movavg_filter_t *f, uint8_t n);
uint16_t movavg_filter_update(movavg_filter_t *f, uint16_t sample);

/* ---------- 4. 一阶 IIR（指数加权平均） ---------- */
typedef struct {
    float y;         /* 上一次输出 */
    float alpha;     /* 0~1，越小越平滑 */
    bool inited;
} iir_filter_t;

void iir_filter_init(iir_filter_t *f, float alpha);
float iir_filter_update(iir_filter_t *f, float x);

/* ---------- 5. 限幅滤波（尖峰抑制） ---------- */
typedef struct {
    float last;
    float limit;     /* 单次允许的最大变化量 */
    bool inited;
    uint32_t reject_cnt;
} spike_filter_t;

void spike_filter_init(spike_filter_t *f, float limit);
float spike_filter_update(spike_filter_t *f, float x);

/* ---------- 级联流水线：限幅 -> 滑动平均（推荐默认组合） ---------- */
typedef struct {
    spike_filter_t spike;
    movavg_filter_t avg;
} adc_pipeline_t;

void adc_pipeline_init(adc_pipeline_t *p, uint8_t window, float spike_limit);
uint16_t adc_pipeline_push(adc_pipeline_t *p, uint16_t raw);

#ifdef __cplusplus
}
#endif

#endif /* FILTER_H */

`platformio.ini`

[platformio]
default_envs = bluepill

[env:bluepill]
platform = ststm32
board = bluepill_f103c8
framework = arduino
upload_protocol = stlink
monitor_speed = 115200
build_flags =
    -Wall
    -Wextra
    -Isrc
lib_ldf_mode = deep+

`src/filter.c`

#include "filter.h"

#include <string.h>

/* ================= 1. 均值滤波 ================= */
void mean_filter_init(mean_filter_t *f, uint16_t n)
{
    f->sum = 0;
    f->cnt = 0;
    f->n = (n == 0) ? 1 : n;
}

bool mean_filter_update(mean_filter_t *f, uint16_t sample, uint16_t *out)
{
    f->sum += sample;
    f->cnt++;
    if (f->cnt >= f->n) {
        if (out != NULL) {
            *out = (uint16_t)(f->sum / f->cnt);
        }
        f->sum = 0;
        f->cnt = 0;
        return true;
    }
    return false;
}

/* ================= 2. 中值滤波 ================= */
void median_filter_init(median_filter_t *f, uint8_t n)
{
    if (n == 0 || n > MEDIAN_MAX) {
        n = 3;
    }
    if ((n & 1u) == 0u) {
        n--; /* 强制奇数 */
    }
    memset(f->buf, 0, sizeof(f->buf));
    f->n = n;
    f->idx = 0;
    f->filled = 0;
}

uint16_t median_filter_update(median_filter_t *f, uint16_t sample)
{
    uint16_t tmp[MEDIAN_MAX];
    uint8_t i;
    uint8_t j;

    f->buf[f->idx] = sample;
    f->idx = (uint8_t)((f->idx + 1u) % f->n);
    if (f->filled < f->n) {
        f->filled++;
    }

    /* 样本少时直接返回当前值，避免排序未初始化数据 */
    if (f->filled < f->n) {
        return sample;
    }

    memcpy(tmp, f->buf, sizeof(uint16_t) * f->n);
    /* 插入排序：n<=9，开销极小 */
    for (i = 1; i < f->n; i++) {
        uint16_t key = tmp[i];
        j = i;
        while (j > 0 && tmp[j - 1] > key) {
            tmp[j] = tmp[j - 1];
            j--;
        }
        tmp[j] = key;
    }
    return tmp[f->n / 2];
}

/* ================= 3. 滑动窗口平均 ================= */
void movavg_filter_init(movavg_filter_t *f, uint8_t n)
{
    if (n == 0 || n > MOVAVG_MAX) {
        n = 8;
    }
    memset(f->buf, 0, sizeof(f->buf));
    f->sum = 0;
    f->n = n;
    f->idx = 0;
    f->filled = 0;
}

uint16_t movavg_filter_update(movavg_filter_t *f, uint16_t sample)
{
    if (f->filled < f->n) {
        f->buf[f->idx] = sample;
        f->sum += sample;
        f->filled++;
    } else {
        f->sum -= f->buf[f->idx];   /* 减去被挤出的旧值 */
        f->buf[f->idx] = sample;
        f->sum += sample;
    }
    f->idx = (uint8_t)((f->idx + 1u) % f->n);
    return (uint16_t)(f->sum / f->filled);
}

/* ================= 4. 一阶 IIR ================= */
void iir_filter_init(iir_filter_t *f, float alpha)
{
    if (alpha <= 0.0f) {
        alpha = 0.01f;
    } else if (alpha > 1.0f) {
        alpha = 1.0f;
    }
    f->alpha = alpha;
    f->y = 0.0f;
    f->inited = false;
}

float iir_filter_update(iir_filter_t *f, float x)
{
    if (!f->inited) {
        f->y = x; /* 首次直接取测量值，避免从 0 缓慢爬升 */
        f->inited = true;
        return f->y;
    }
    f->y = f->alpha * x + (1.0f - f->alpha) * f->y;
    return f->y;
}

/* ================= 5. 限幅滤波 ================= */
void spike_filter_init(spike_filter_t *f, float limit)
{
    f->last = 0.0f;
    f->limit = (limit <= 0.0f) ? 1e9f : limit;
    f->inited = false;
    f->reject_cnt = 0;
}

float spike_filter_update(spike_filter_t *f, float x)
{
    float diff;

    if (!f->inited) {
        f->last = x;
        f->inited = true;
        return f->last;
    }
    diff = x - f->last;
    if (diff > f->limit || diff < -f->limit) {
        f->reject_cnt++;
        return f->last; /* 变化超限，判为干扰 */
    }
    f->last = x;
    return x;
}

/* ================= 级联流水线 ================= */
void adc_pipeline_init(adc_pipeline_t *p, uint8_t window, float spike_limit)
{
    spike_filter_init(&p->spike, spike_limit);
    movavg_filter_init(&p->avg, window);
}

uint16_t adc_pipeline_push(adc_pipeline_t *p, uint16_t raw)
{
    float a = spike_filter_update(&p->spike, (float)raw);
    return movavg_filter_update(&p->avg, (uint16_t)a);
}

`test/test_filter.c`

/**
 * 主机端对比测试：同一段「白噪声 + 尖刺」数据，比较五种滤波效果
 * gcc -std=c99 -Wall -Wextra -Iinclude src/filter.c test/test_filter.c -o build/test -lm
 */
#include <math.h>
#include <stdio.h>

#include "filter.h"

#define N 2000
#define TRUE_VALUE 2048.0f

static uint32_t rng_state = 12345u;

/* 确定性伪随机（xorshift32），保证每次运行结果一致，便于对比 */
static uint32_t rng(void)
{
    rng_state ^= rng_state << 13;
    rng_state ^= rng_state >> 17;
    rng_state ^= rng_state << 5;
    return rng_state;
}

/* 生成 [-1,1) 的均匀噪声 */
static float noise(void)
{
    return ((float)(rng() % 2000u) / 1000.0f) - 1.0f;
}

static float g_raw[N];
static float g_clean[N];

static void gen_signal(void)
{
    rng_state = 12345u;
    for (int i = 0; i < N; i++) {
        float v = TRUE_VALUE + noise() * 8.0f;   /* 白噪声 ±8 LSB */
        /* 每 100 个点插入一次尖刺（模拟电机换向/继电器动作干扰） */
        if ((i % 100) == 37) {
            v += 200.0f;
        }
        g_raw[i] = v;
        g_clean[i] = TRUE_VALUE;
    }
}

static float stddev(const float *a, const float *b, int n, int start)
{
    double acc = 0.0;
    int cnt = 0;
    for (int i = start; i < n; i++) {
        double d = a[i] - b[i];
        acc += d * d;
        cnt++;
    }
    return (float)sqrt(acc / cnt);
}

int main(void)
{
    float out[N];
    mean_filter_t mean;
    median_filter_t med;
    movavg_filter_t mov;
    iir_filter_t iir;
    spike_filter_t spk;
    adc_pipeline_t pipe;
    float raw_sd;
    float s;

    printf("===== ADC 滤波算法对比（%d 个采样点，真值 %.0f）=====\n", N, TRUE_VALUE);
    printf("噪声构成：均匀白噪声 ±8 LSB + 每 100 点一个 +200 LSB 尖刺\n\n");

    gen_signal();
    raw_sd = stddev(g_raw, g_clean, N, 0);
    printf("原始信号标准差        : %8.3f  (基准)\n", raw_sd);
    printf("---------------------------------------------------------------\n");

    /* 1. 均值滤波 N=16 */
    mean_filter_init(&mean, 16);
    printf("1) 均值滤波 N=16      : ");
    {
        int k = 0;
        uint16_t o;
        for (int i = 0; i < N; i++) {
            if (mean_filter_update(&mean, (uint16_t)g_raw[i], &o)) {
                out[k++] = (float)o;
            }
        }
        for (int i = k; i < N; i++) {
            out[i] = out[k - 1];
        }
        s = stddev(out, g_clean, N, 0);
        printf("sd=%7.3f  降噪 %5.2fx  延迟=16 点（降噪最强，但每 16 点才出一次）\n",
               s, raw_sd / s);
    }

    /* 2. 中值滤波 N=5 */
    median_filter_init(&med, 5);
    printf("2) 中值滤波 N=5       : ");
    for (int i = 0; i < N; i++) {
        out[i] = (float)median_filter_update(&med, (uint16_t)g_raw[i]);
    }
    s = stddev(out, g_clean, N, 20);
    printf("sd=%7.3f  降噪 %5.2fx  延迟=2 点（抗尖刺最强）\n", s, raw_sd / s);

    /* 3. 滑动窗口平均 N=8 */
    movavg_filter_init(&mov, 8);
    printf("3) 滑动平均 N=8       : ");
    for (int i = 0; i < N; i++) {
        out[i] = (float)movavg_filter_update(&mov, (uint16_t)g_raw[i]);
    }
    s = stddev(out, g_clean, N, 20);
    printf("sd=%7.3f  降噪 %5.2fx  延迟=4 点（综合最优）\n", s, raw_sd / s);

    /* 4. 一阶 IIR alpha=0.1 */
    iir_filter_init(&iir, 0.1f);
    printf("4) 一阶IIR α=0.1     : ");
    for (int i = 0; i < N; i++) {
        out[i] = iir_filter_update(&iir, g_raw[i]);
    }
    s = stddev(out, g_clean, N, 100);
    printf("sd=%7.3f  降噪 %5.2fx  延迟≈9 点（省内存）\n", s, raw_sd / s);

    /* 5. 限幅滤波 limit=25 */
    spike_filter_init(&spk, 25.0f);
    printf("5) 限幅滤波 lim=25   : ");
    for (int i = 0; i < N; i++) {
        out[i] = spike_filter_update(&spk, g_raw[i]);
    }
    s = stddev(out, g_clean, N, 10);
    printf("sd=%7.3f  降噪 %5.2fx  剔除 %u 个尖刺\n", s, raw_sd / s, spk.reject_cnt);

    /* 6. 级联：限幅 + 滑动平均 */
    adc_pipeline_init(&pipe, 8, 25.0f);
    printf("6) 限幅+滑动平均（推荐）: ");
    for (int i = 0; i < N; i++) {
        out[i] = (float)adc_pipeline_push(&pipe, (uint16_t)g_raw[i]);
    }
    s = stddev(out, g_clean, N, 20);
    printf("sd=%7.3f  降噪 %5.2fx  ← 逐点连续输出 + 尖刺已剔除，工程首选\n", s, raw_sd / s);

    printf("---------------------------------------------------------------\n");
    printf("\n结论（按实测数据）：\n");
    printf("  * 只看降噪倍数      -> 均值 N=16 最强（16.85x），但输出不连续、延迟最大\n");
    printf("  * 要逐点连续输出    -> 滑动平均（2.89x）或一阶 IIR（4.33x）\n");
    printf("  * 要抗尖刺          -> 中值（6.87x）或限幅（剔除 20 个尖刺）\n");
    printf("  * 两者都要且要连续  -> 限幅 + 滑动平均串联（11.02x，工业标配）\n");
    printf("  * 内存最省          -> 一阶 IIR（只要 2 个 float）\n");

    printf("\n[滤波后的前 20 个点，看动态过程]\n");
    printf("  idx   raw    pipeline\n");
    {
        adc_pipeline_init(&pipe, 8, 25.0f);
        for (int i = 0; i < 20; i++) {
            float v = (float)adc_pipeline_push(&pipe, (uint16_t)g_raw[i]);
            printf("  %3d  %6.0f  %8.1f\n", i, g_raw[i], v);
        }
    }
    printf("\n===== 以上数据由本机 gcc 实编译实运行产生 =====\n");
    return 0;
}

实测输出

下面这段输出是把上面的核心算法用 本机 gcc 真编译、真运行得到的（不含任何硬件依赖）：

===== ADC 滤波算法对比（2000 个采样点，真值 2048）=====
噪声构成：均匀白噪声 ±8 LSB + 每 100 点一个 +200 LSB 尖刺

原始信号标准差        :   20.727  (基准)
---------------------------------------------------------------
1) 均值滤波 N=16      : sd=  1.230  降噪 16.85x  延迟=16 点（降噪最强，但每 16 点才出一次）
2) 中值滤波 N=5       : sd=  3.018  降噪  6.87x  延迟=2 点（抗尖刺最强）
3) 滑动平均 N=8       : sd=  7.165  降噪  2.89x  延迟=4 点（综合最优）
4) 一阶IIR α=0.1     : sd=  4.782  降噪  4.33x  延迟≈9 点（省内存）
5) 限幅滤波 lim=25   : sd=  4.562  降噪  4.54x  剔除 20 个尖刺
6) 限幅+滑动平均（推荐）: sd=  1.881  降噪 11.02x  ← 逐点连续输出 + 尖刺已剔除，工程首选
---------------------------------------------------------------

结论（按实测数据）：
  * 只看降噪倍数      -> 均值 N=16 最强（16.85x），但输出不连续、延迟最大
  * 要逐点连续输出    -> 滑动平均（2.89x）或一阶 IIR（4.33x）
  * 要抗尖刺          -> 中值（6.87x）或限幅（剔除 20 个尖刺）
  * 两者都要且要连续  -> 限幅 + 滑动平均串联（11.02x，工业标配）
  * 内存最省          -> 一阶 IIR（只要 2 个 float）

[滤波后的前 20 个点，看动态过程]
  idx   raw    pipeline
    0    2043    2042.0
    1    2054    2048.0
    2    2055    2050.0
    3    2040    2047.0
    4    2043    2046.0
    5    2044    2046.0
    6    2041    2045.0
    7    2049    2045.0
    8    2044    2046.0
    9    2053    2045.0
   10    2049    2045.0
   11    2042    2045.0
   12    2047    2045.0
   13    2056    2047.0
   14    2048    2048.0
   15    2047    2047.0
   16    2042    2047.0
   17    2053    2047.0
   18    2053    2047.0
   19    2052    2049.0

===== 以上数据由本机 gcc 实编译实运行产生 =====

菜单

分享

ADC 采样总是跳：5 种滤波算法从原理到实测对比

一、完整工程下载

先搞清楚噪声长什么样

五种算法逐一说明

1. 算术平均（均值滤波）

2. 中值滤波（取中间值）

3. 滑动窗口平均

4. 一阶 IIR（指数加权平均）

5. 限幅滤波（尖峰抑制）

工程内容

怎么用

调试要点

进阶方向

完整代码

`Makefile`

`include/filter.h`

`platformio.ini`

`src/filter.c`

`test/test_filter.c`

实测输出

评论

端到端测试

温度传感器不准？B 参数公式、Steinhart-Hart 与多点标定的误差实测

步进电机为什么会“丢步”：梯形与 S 曲线加减速的完整实现

裸机也该有“操作系统”：80 行写一个软定时器任务调度器

给单片机写个能用的命令行：行编辑、历史、Tab 补全、ANSI 转义全都要

PID 从公式到能跑：给直流电机写一个带抗积分饱和的速度环

手写 Modbus RTU 从站：03/06/16 功能码 + 异常响应，用测试用例逐字节验证

固定块内存池：为什么嵌入式该用它替掉 malloc（附真实碎片实测）

现场升级不翻车：手写一个带 A/B 双分区与自动回滚的串口 IAP

软件 I2C 实战：开漏总线、时钟延展、扫描与 9 时钟解锁