MEMS气压计测液位从原理到实战
·
压力式液位测量：用 MEMS 气压计实现高精度非接触测液位
目录
- 一、老工程师的开场白
- 二、基本原理：一根管子就能测液位？
- 三、为什么选 MEMS 气压计？
- 四、核心公式与工程修正
- 五、传感器选型指南
- 六、气路设计与机械结构
- 七、硬件电路设计
- 八、Arduino 驱动开发
- 九、STM32 驱动开发
- 十、标定与校准
- 十一、误差分析与补偿策略
- 十二、项目实战：智能水箱液位监测系统
- 十三、量产中踩过的坑
- 十四、总结与金句
一、老工程师的开场白
干了 40 年电子工程师，从模拟电路一路做到嵌入式、物联网。这些年见过的液位测量方案少说也有二十种——浮球、电容、超声波、雷达、激光、静压投入式……各有各的适用场景，也各有各的坑。
今天要聊的这种方法——用 MEMS 气压计通过气管测液位，是我在多个项目里反复验证过的"性价比之王"。它的核心优势就一句话：
传感器不接触液体，精度却能做到毫米级，成本不到二十块钱。
这句话在 20 年前是不敢想的。那时候一个能用的差压传感器动辄几百上千。MEMS 技术的发展改变了这一切。
这篇文章我不会只列原理、贴代码了事。我会把 为什么这样设计、哪些地方容易翻车、量产时要注意什么 都掰开揉碎讲清楚。这些都是花过真金白银换来的经验。
二、基本原理：一根管子就能测液位？
2.1 直观理解
想象一个场景：你往一杯水里插一根空心的吸管，用手指堵住上端，把吸管提起来——管子里会有一段水柱被"吸住"不落下来。这是因为管内的气压低于大气压，压力差托住了水柱。
反过来用这个原理：把管子一头插入液体底部，另一头接一个气压传感器（密封系统）。液位越高，管子底部受到的液体压力越大，管内被压缩的空气压力就越高。测量这个气压，就能反推出液位高度。
┌─────────────────────┐
│ MEMS 气压计 │ ← 测量管内气压 P
│ (密封腔体) │
└────────┬────────────┘
│ 导气管（内径 2~4mm）
│
─────────────┼────────────── 液面
│
│ ~~~~ 液体 ~~~~
│
└── 管口（固定于容器底部）
↑
此处液体压强 = ρ·g·h
2.2 物理推导
这是一个等温压缩过程的经典应用。
Step 1：初始状态（管子未插入液体）
管内气压 = P₀（大气压）
管内空气体积 = V_total（气管内容积 + 传感器腔内容积）
Step 2：插入液体后
管口处液体压强 = P₀ + ρ·g·h（液柱产生的压强）
其中：
- ρ：液体密度（水 = 1000 kg/m³）
- g：重力加速度（9.8 m/s²，不同纬度有差异）
- h：液面到管口的高度（即我们要测的液位）
管内空气被压缩，体积减小，压强升高。由玻意耳定律（等温过程）：
P₀ × V_total = P_gas × (V_total - V_displaced)
其中 V_displaced 是液体进入管子的体积：
V_displaced = π × (d/2)² × h_rise
h_rise：液体在管内上升的高度
Step 3：力平衡
在管口位置，管内气压 + 管内液柱压强 = 液体压强：
P_gas + ρ·g·h_rise = P₀ + ρ·g·h
2.3 关键简化：小管径近似
实际应用中，我们选足够细的管子（内径 2~3mm），使得液体进入管内的体积极小（V_displaced ≈ 0），那么管内气压基本等于管口处液体压强：
P_gas ≈ P₀ + ρ·g·h
因此：
液位高度 h = (P_gas - P₀) / (ρ × g)
这就是核心公式。简单到让人不敢相信，但确实有效。
⚠️ 老工程师提醒：这个简化在管径 ≤ 3mm、气管总长 ≤ 2m 时误差可忽略。管径过大或管子过长时，气体压缩效应不可忽略，需要用完整公式修正。
三、为什么选 MEMS 气压计？
3.1 方案对比
| 方案 | 精度 | 成本 | 非接触 | 适用液体 | 主要缺点 |
|---|---|---|---|---|---|
| 浮球式 | 低 | ￥5 | ❌ | 无腐蚀 | 卡滞、磨损 |
| 电容式 | 中 | ￥15 | ❌ | 非导电 | 挂料、温漂 |
| 超声波 | 中 | ￥40 | ✅ | 不限 | 盲区、泡沫干扰 |
| 压力式 (MEMS) | 高 | ￥12 | ✅ | 不限 | 需密封气路 |
| 雷达 | 极高 | ￥300+ | ✅ | 不限 | 贵 |
| 投入式静压 | 高 | ￥80 | ❌ | 无腐蚀 | 传感器泡在液体里 |
3.2 MEMS 气压计的核心优势
现代 MEMS 气压计（如 Bosch BMP280/BMP390、Infineon DPS310、MS5611 等）集成了：
| 组件 | 作用 |
|---|---|
| MEMS 压力敏感薄膜 | 将气压转换为电容/电阻变化 |
| 24 位 Σ-Δ ADC | 数字化 |
| 温度传感器 | 温度补偿 |
| 数字信号处理器 | 出厂校准 + 线性化 |
| I2C/SPI 接口 | 一个 GPIO 都不用多占 |
一颗几块钱的芯片，内部做了过去需要一整个模拟前端板才能完成的事情。这就是时代的红利。
3.3 测液位需要"差压"而非"绝压"
需要注意：大气压本身就在不断变化（天气、海拔）。一颗气压计只能测绝对气压，如果我们只用它测管内的绝对气压，读出来的液位会随着天气变化而漂移。
解决方案：使用两颗传感器，或一颗内置双通道的差压方案。
| 方法 | 说明 | 精度 |
|---|---|---|
| 单传感器法 | 测 P_gas，另用气象站 API 获取 P₀ | 低，依赖外部数据 |
| 双传感器法（推荐） | 传感器 A 测管内 P_gas，传感器 B 测大气 P₀ | 高 |
| 差分传感器 | 一颗传感器两路输入 | 最高，但器件少 |
传感器 A (P_gas) 传感器 B (P₀)
┌──────────┐ ┌──────────┐
│ BMP280-1 │ │ BMP280-2 │
└────┬─────┘ └────┬─────┘
│ │
接密封气管 暴露于大气
│ │
▼ ▼
MCU 计算: ΔP = P_A - P_B
h = ΔP / (ρ·g)
四、核心公式与工程修正
4.1 基本公式
# 液位高度（单位：米）
h = (P_gas - P_atm) / (rho * g)
# 其中:
# P_gas : 管内气压 (Pa)
# P_atm : 大气压 (Pa)
# rho : 液体密度 (kg/m³)，水 = 1000
# g : 重力加速度 (m/s²)，标准 = 9.80665
4.2 单位换算速查
1 kPa = 1000 Pa
1 mH₂O ≈ 9.80665 kPa (1 米水柱 ≈ 9.8 kPa)
1 cmH₂O ≈ 98.07 Pa (1 厘米水柱 ≈ 98 Pa)
1 mmH₂O ≈ 9.807 Pa (1 毫米水柱 ≈ 9.8 Pa)
实用记忆口诀：1cm 水柱 ≈ 100Pa。有了这个，拿到气压差值直接心算就知道大概液位了。
4.3 密度修正
水的密度随温度变化，在精密测量中需要修正：
| 温度 (℃) | 水密度 (kg/m³) | 相对 4℃ 偏差 |
|---|---|---|
| 0 | 999.87 | -0.01% |
| 4 | 1000.00 | 0% |
| 10 | 999.73 | -0.03% |
| 20 | 998.23 | -0.18% |
| 30 | 995.67 | -0.43% |
| 40 | 992.24 | -0.78% |
| 60 | 983.20 | -1.68% |
| 80 | 971.79 | -2.82% |
// 水温修正（经验公式，0~80℃ 范围内误差 < 0.1%）
float waterDensity(float tempC) {
// tempC: 水温（摄氏度）
return 1000.0f * (1.0f - (tempC - 4.0f) * (tempC - 4.0f) / 180000.0f);
}
对于工业液体（酸碱溶液、油类），必须实测密度或从工艺参数获取，不可直接套用水的公式。
4.4 重力加速度修正
g 值随纬度变化：
g(φ) = 9.780327 × (1 + 0.0053024 × sin²φ - 0.0000058 × sin²2φ)
| 地点 | 纬度 | g (m/s²) |
|---|---|---|
| 赤道 | 0° | 9.780 |
| 上海 | 31°N | 9.794 |
| 北京 | 40°N | 9.802 |
| 哈尔滨 | 46°N | 9.807 |
| 北极 | 90°N | 9.832 |
南北相差约 0.5%，对 10m 液位意味着 5cm 的误差。在精密计量中需要修正，一般应用可以忽略。
五、传感器选型指南
5.1 主流 MEMS 气压计横向对比
| 型号 | 量程 (hPa) | 分辨率 | 绝对精度 | 接口 | 功耗 | 参考价格 |
|---|---|---|---|---|---|---|
| BMP280 | 300~1100 | 0.16 Pa | ±1 hPa | I2C/SPI | 2.7μA | ￥3~5 |
| BMP390 | 300~1250 | 0.03 Pa | ±0.3 hPa | I2C/SPI | 3.2μA | ￥8~12 |
| DPS310 | 300~1200 | 0.06 Pa | ±0.5 hPa | I2C/SPI | 1.7μA | ￥6~10 |
| MS5611 | 10~1200 | 0.012 Pa | ±1.5 hPa | I2C/SPI | 0.6μA | ￥15~25 |
| LPS22HB | 260~1260 | 0.06 Pa | ±1 hPa | I2C/SPI | 3μA | ￥5~8 |
| SPL06-001 | 300~1100 | 0.06 Pa | ±0.5 hPa | I2C/SPI | 3.4μA | ￥3~6 |
5.2 选型决策树
需要测的液位范围？
│
├─ < 0.5m (微小液位) → 需要高分辨率
│ └─ → BMP390 或 MS5611（分辨率 < 0.1mm 水柱）
│
├─ 0.5m ~ 5m (常规容器)
│ └─ → BMP280（够用，便宜）
│ → 量程 5m = 5kPa，BMP280 分辨率 1.6Pa ≈ 0.16mm，绰绰有余
│
├─ 5m ~ 10m（大型储罐）
│ └─ → BMP280 × 2 或 BMP390
│ → 10m ≈ 98kPa 仍在量程内
│
└─ > 20m → MEMS 气压计量程不足
└─ → 改用投入式静压传感器（扩散硅）
5.3 老工程师的推荐
初学者/常规项目 → BMP280 模块（某宝 ￥5~8 带 PCB），I2C 接口，Arduino 库完善。
量产产品 → BMP390，精度高、温漂小、封装小（2.0×2.0mm），价格可谈到 ￥5 以内。
极致低成本 → SPL06-001，单价可到 ￥2.5，但国产的一致性稍差，量产标定要做足。
六、气路设计与机械结构
这部分是最容易被忽视、出问题最多的环节。电路写错可以改，气路漏气要么看不出、要么全白费。
6.1 气管选择
| 参数 | 推荐值 | 原因 |
|---|---|---|
| 材质 | 硅胶管 / PU 管 | 柔软、弹性好、气密 |
| 内径 | 2 ~ 3mm | 太小→易堵，太大→气体压缩误差增大 |
| 壁厚 | ≥ 0.5mm | 保证足够的抗压刚度 |
| 长度 | ≤ 2m | 越长响应越慢 |
6.2 密封是关键中的关键
┌───────────────────────────────────────────┐
│ ⚠️ 血的教训： │
│ 任何微小的漏气都会导致液位读数持续漂移， │
│ 而且漂移速度随液位高低变化—— │
│ 会让你误以为是传感器温漂在作怪。 │
│ 在量产中，气路漏气占了售后问题的 60%。 │
└───────────────────────────────────────────┘
密封方案（由简到繁）：
| 方案 | 方法 | 适用场景 |
|---|---|---|
| ① 扎带 | 管套在传感器气嘴上，用尼龙扎带扎紧 | 快速验证 |
| ② 硅胶 | 接口涂 RTV 硅胶后套管 | 中小批量 |
| ③ 热缩管 | 在管接口处套热缩管加热收缩 | 较好的量产方案 |
| ④ O 型圈 | 定制气嘴 + O 型密封圈 + 压盖 | 专业量产 |
| ⑤ 超声波焊接 | 塑料壳体直接焊死 | 大批量 |
6.3 气路设计的三个陷阱
陷阱一：冷凝水
气管内外的温差会导致管内产生冷凝水。一旦管内有水，气体体积变化规律就完全变了。
解决：
├─ 在传感器端加装干燥剂仓（硅胶颗粒）
├─ 气管走线避免经过冷热交界面
└─ 传感器安装在比管口更高的位置，让冷凝水自然回流
陷阱二：管口堵塞
液体中的悬浮物、藻类、结晶都可能堵住管口。
解决：
├─ 管口加不锈钢过滤网（200 目）
├─ 管口朝下，减少沉淀物进入
└─ 定期反吹清洁（通过三通电磁阀切换气泵）
陷阱三：气泡困在管口
初次安装时管口有气泡，导致"液没泡着管口"，读数偏低。
解决：
├─ 安装后轻轻敲击管壁排出气泡
├─ 管口切 45° 斜角（而非平口），利于气泡排出
└─ 首次使用前用注射器从传感器端抽气
6.4 传感器保护
MEMS 传感器很娇贵——别看它测气压，它不能接触液体。一旦液体进入传感器腔体，轻则读数错误，重则永久损坏。
保护措施：
1. 传感器放在密闭外壳中，气嘴伸出
2. 气管中串联防水透气膜（Gore-Tex 膜）
3. 传感器与 PCB 之间点胶防水
4. 外壳 IP65 以上
七、硬件电路设计
7.1 双传感器方案原理图
┌────────────────────────────────┐
│ MCU Board │
│ │
┌──────┐ │ ┌──────────┐ ┌──────────┐ │
│气 管 │───────────▶│ BMP280-1 │ │ BMP280-2 │◀──┼── 通大气
│(液位)│ 密封 │ │ 0x76 │ │ 0x77 │ │
└──────┘ │ └────┬─────┘ └────┬─────┘ │
│ │ I2C │ I2C │
│ └──────┬──────┘ │
│ │ │
│ ┌──────┴──────┐ │
│ │ SDA / SCL │ │
│ │ 3.3V GND │ │
│ └─────────────┘ │
│ │
│ ┌─────────┐ ┌─────────┐ │
│ │ OLED │ │ Wi-Fi/ │ │
│ │ 显示 │ │ 4G 模组 │ │
│ └─────────┘ └─────────┘ │
└────────────────────────────────┘
7.2 BMP280 I2C 地址设置
BMP280 的 I2C 地址由 SDO 引脚电平决定：
| SDO 引脚 | I2C 地址 (7-bit) |
|---|---|
| GND | 0x76 (0xEC 写入 / 0xED 读取) |
| VCC | 0x77 (0xEE 写入 / 0xEF 读取) |
关键：两个 BMP280 在同一 I2C 总线上时，必须一个 SDO 接 GND，另一个 SDO 接 VCC，否则地址冲突。
7.3 PCB Layout 要点
/*
* 老工程师的 PCB 忠告：
*
* 1. 气压传感器的进气孔不要被 PCB 遮挡！
* BMP280 金属壳上有一个小孔——那就是进气口。
* 布局时要留出足够的空间，不能正对 PCB 或元件。
*
* 2. 远离热源。
* LDO、MCU、Wi-Fi 模组都是热源。
* 气压传感器对温度敏感（温漂约 ±0.1Pa/℃），
* 靠近热源会让读数严重偏移。
* 在 PCB 上挖槽隔离热传导是个好习惯。
*
* 3. 电容靠近传感器引脚。
* 100nF + 10μF 退耦，离 VDD 引脚不超过 5mm。
*
* 4. I2C 上拉电阻 4.7kΩ 到 3.3V。
* 两个传感器共用一对上拉即可。
*/
八、Arduino 驱动开发
8.1 硬件接线
| BMP280-1 (液位) | BMP280-2 (大气) | Arduino UNO |
|---|---|---|
| VCC | VCC | 3.3V |
| GND | GND | GND |
| SDA | SDA | A4 |
| SCL | SCL | A5 |
| SDO → GND (0x76) | SDO → 3.3V (0x77) | — |
8.2 安装库
在 Arduino IDE 库管理器中搜索 “Adafruit BMP280” 并安装（会自动安装依赖的 Adafruit Sensor 库和 Adafruit BusIO 库）。
8.3 基础驱动代码
/**
* 压力式液位计 - 双 BMP280 方案
* 传感器 A (0x76)：接密封气管 → 测 P_gas
* 传感器 B (0x77)：暴露于大气 → 测 P_atm
*
* 液位 h = (P_gas - P_atm) / (ρ × g)
*/
#include <Wire.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_BMP280.h>
// ==================== 传感器对象 ====================
Adafruit_BMP280 bmpGas; // 管内气压传感器 (0x76)
Adafruit_BMP280 bmpAtm; // 大气压传感器 (0x77)
// ==================== 物理参数 ====================
const float RHO = 1000.0f; // 液体密度 (kg/m³)，水 = 1000
const float G = 9.80665f; // 重力加速度 (m/s²)
const float RHO_G = RHO * G; // 9810 Pa/m (预计算，省 CPU)
// ==================== 滤波参数 ====================
const uint8_t FILTER_SAMPLES = 10; // 每次采样的平均次数
// ==================== 初始化 ====================
void setup() {
Serial.begin(115200);
Serial.println("=== 压力式液位计 (双 BMP280) ===");
Serial.println();
// 初始化 I2C
Wire.begin();
// 初始化 BMP280-1 (管内气压，地址 0x76)
if (!bmpGas.begin(0x76)) {
Serial.println("❌ BMP280-1 (P_gas) 初始化失败！");
Serial.println(" 请检查接线和 SDO 电平 (应为 GND → 0x76)");
while (1) delay(10);
}
Serial.println("✅ BMP280-1 (P_gas) 就绪 — 0x76");
// 初始化 BMP280-2 (大气压，地址 0x77)
if (!bmpAtm.begin(0x77)) {
Serial.println("❌ BMP280-2 (P_atm) 初始化失败！");
Serial.println(" 请检查接线和 SDO 电平 (应为 VCC → 0x77)");
while (1) delay(10);
}
Serial.println("✅ BMP280-2 (P_atm) 就绪 — 0x77");
// 配置传感器参数
// 模式: NORMAL (连续采样)
// 过采样: ×16 (压力), ×2 (温度)
// 滤波: ×4
// 待机时间: 0.5ms
bmpGas.setSampling(Adafruit_BMP280::MODE_NORMAL,
Adafruit_BMP280::SAMPLING_X16, // 压力过采样
Adafruit_BMP280::SAMPLING_X2, // 温度过采样
Adafruit_BMP280::FILTER_X4, // IIR 滤波
Adafruit_BMP280::STANDBY_MS_1);
bmpAtm.setSampling(Adafruit_BMP280::MODE_NORMAL,
Adafruit_BMP280::SAMPLING_X16,
Adafruit_BMP280::SAMPLING_X2,
Adafruit_BMP280::FILTER_X4,
Adafruit_BMP280::STANDBY_MS_1);
Serial.println("✅ 传感器配置完成\n");
Serial.println("时间(ms)\t液位(mm)\tP_gas(Pa)\tP_atm(Pa)\tΔP(Pa)");
Serial.println("--------\t--------\t--------\t--------\t------");
}
// ==================== 主循环 ====================
void loop() {
// 多次采样取平均（减小噪声）
float pGasSum = 0, pAtmSum = 0;
for (uint8_t i = 0; i < FILTER_SAMPLES; i++) {
pGasSum += bmpGas.readPressure();
pAtmSum += bmpAtm.readPressure();
delay(5); // 等待 ADC 完成
}
float pGas = pGasSum / FILTER_SAMPLES; // 管内气压 (Pa)
float pAtm = pAtmSum / FILTER_SAMPLES; // 大气压 (Pa)
float dp = pGas - pAtm; // 压差 (Pa)
// 计算液位高度
// h = ΔP / (ρ·g) 单位：米
// 转为毫米：× 1000
float liquidLevel = (dp / RHO_G) * 1000.0f; // mm
// 输出到串口
Serial.print(millis());
Serial.print("\t");
Serial.print(liquidLevel, 1);
Serial.print("\t\t");
Serial.print(pGas, 1);
Serial.print("\t");
Serial.print(pAtm, 1);
Serial.print("\t");
Serial.println(dp, 1);
delay(500);
}
8.4 带 OLED 显示版本
#include <Wire.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_BMP280.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
// ==================== 硬件定义 ====================
#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64
#define OLED_ADDR 0x3C
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);
Adafruit_BMP280 bmpGas;
Adafruit_BMP280 bmpAtm;
const float RHO_G = 9810.0f; // ρ·g
// ==================== 一阶低通滤波器 ====================
class LowPassFilter {
float alpha, output;
bool init;
public:
LowPassFilter(float a = 0.15f) : alpha(a), output(0), init(false) {}
float update(float input) {
if (!init) { output = input; init = true; }
else output = alpha * input + (1.0f - alpha) * output;
return output;
}
};
LowPassFilter lpf(0.1f);
// ==================== 初始化 ====================
void setup() {
Serial.begin(115200);
Wire.begin();
// OLED 初始化
if (!display.begin(SSD1306_SWITCHCAPVCC, OLED_ADDR)) {
Serial.println("OLED 初始化失败！");
while (1);
}
display.clearDisplay();
display.setTextColor(SSD1306_WHITE);
// 开机 Logo
display.setTextSize(2);
display.setCursor(15, 10);
display.println("Level");
display.setCursor(25, 35);
display.println("Sensor");
display.display();
delay(2000);
// BMP280 初始化
if (!bmpGas.begin(0x76) || !bmpAtm.begin(0x77)) {
display.clearDisplay();
display.setTextSize(1);
display.setCursor(0, 0);
display.println("BMP280 ERROR!");
display.println("Check wiring:");
display.println("Gas: 0x76 (SDO→GND)");
display.println("Atm: 0x77 (SDO→VCC)");
display.display();
while (1) delay(10);
}
bmpGas.setSampling(Adafruit_BMP280::MODE_NORMAL,
Adafruit_BMP280::SAMPLING_X16,
Adafruit_BMP280::SAMPLING_X2,
Adafruit_BMP280::FILTER_X4,
Adafruit_BMP280::STANDBY_MS_1);
bmpAtm.setSampling(Adafruit_BMP280::MODE_NORMAL,
Adafruit_BMP280::SAMPLING_X16,
Adafruit_BMP280::SAMPLING_X2,
Adafruit_BMP280::FILTER_X4,
Adafruit_BMP280::STANDBY_MS_1);
}
// ==================== 主循环 ====================
void loop() {
// 读取气压 (Pa)
float pGas = bmpGas.readPressure();
float pAtm = bmpAtm.readPressure();
float dp = pGas - pAtm;
// 计算液位 (mm)
float level = (dp / RHO_G) * 1000.0f;
level = lpf.update(level);
// 温度
float temp = bmpGas.readTemperature();
// OLED 显示
display.clearDisplay();
// 液位 - 大字
display.setTextSize(3);
display.setCursor(5, 5);
display.print(level, 1);
display.setTextSize(2);
display.setCursor(80, 13);
display.print("mm");
// 信息栏
display.setTextSize(1);
display.setCursor(0, 48);
display.print("T:");
display.print(temp, 1);
display.print("C ");
display.print("dP:");
display.print(dp, 1);
display.print("Pa");
// 进度条（相对满量程）
float percent = constrain(level / 1000.0f, 0.0f, 1.0f); // 满量程 1m
int barWidth = (int)(percent * 128);
display.fillRect(0, 38, barWidth, 6, SSD1306_WHITE);
display.drawRect(0, 38, 128, 6, SSD1306_WHITE);
display.display();
delay(200);
}
九、STM32 驱动开发
9.1 BMP280 寄存器操作要点
BMP280 通过 I2C 读写寄存器（也可用 SPI）。关键寄存器：
| 寄存器 | 地址 | 说明 |
|---|---|---|
| ID | 0xD0 | 芯片 ID，BMP280 固定为 0x58 |
| CTRL_MEAS | 0xF4 | 模式 + 过采样配置 |
| CONFIG | 0xF5 | 待机时间 + IIR 滤波系数 |
| PRESS_MSB/LSB/XL | 0xF7~0xF9 | 压力原始值（20 位） |
| TEMP_MSB/LSB/XL | 0xFA~0xFC | 温度原始值（20 位） |
| 补偿参数 | 0x88~0xA1 | 出厂校准系数（24 字节） |
| 0xE1~0xF0 | 出厂校准系数（16 字节） |
9.2 完整驱动代码（HAL 库）
bmp280.h
#ifndef __BMP280_H__
#define __BMP280_H__
#include "stm32f1xx_hal.h"
#include <stdint.h>
/* BMP280 I2C 地址 (7-bit) */
#define BMP280_ADDR_GND 0x76 // SDO 接 GND
#define BMP280_ADDR_VCC 0x77 // SDO 接 VCC
/* 寄存器地址 */
#define BMP280_REG_ID 0xD0
#define BMP280_REG_RESET 0xE0
#define BMP280_REG_CTRL_MEAS 0xF4
#define BMP280_REG_CONFIG 0xF5
#define BMP280_REG_PRESS_MSB 0xF7
#define BMP280_REG_TEMP_MSB 0xFA
/* 采样模式 */
typedef enum {
BMP280_MODE_SLEEP = 0x00,
BMP280_MODE_FORCED = 0x01,
BMP280_MODE_NORMAL = 0x03
} BMP280_Mode;
/* 过采样 */
typedef enum {
BMP280_OVERSAMPLING_SKIP = 0x00,
BMP280_OVERSAMPLING_X1 = 0x01,
BMP280_OVERSAMPLING_X2 = 0x02,
BMP280_OVERSAMPLING_X4 = 0x03,
BMP280_OVERSAMPLING_X8 = 0x04,
BMP280_OVERSAMPLING_X16 = 0x05
} BMP280_Oversampling;
/* IIR 滤波 */
typedef enum {
BMP280_FILTER_OFF = 0x00,
BMP280_FILTER_X2 = 0x01,
BMP280_FILTER_X4 = 0x02,
BMP280_FILTER_X8 = 0x03,
BMP280_FILTER_X16 = 0x04
} BMP280_Filter;
/* 出厂校准参数（存储在 sensor 的 NVM 中）*/
typedef struct {
uint16_t dig_T1;
int16_t dig_T2;
int16_t dig_T3;
uint16_t dig_P1;
int16_t dig_P2;
int16_t dig_P3;
int16_t dig_P4;
int16_t dig_P5;
int16_t dig_P6;
int16_t dig_P7;
int16_t dig_P8;
int16_t dig_P9;
} BMP280_CalibData;
/* 传感器句柄 */
typedef struct {
I2C_HandleTypeDef *hi2c;
uint8_t addr;
BMP280_CalibData calib;
int32_t t_fine; // 温度补偿中间变量
} BMP280_Handle;
/* API 函数 */
HAL_StatusTypeDef BMP280_Init(BMP280_Handle *bmp, I2C_HandleTypeDef *hi2c, uint8_t addr);
HAL_StatusTypeDef BMP280_Configure(BMP280_Handle *bmp, BMP280_Mode mode,
BMP280_Oversampling osrs_p,
BMP280_Oversampling osrs_t,
BMP280_Filter filter);
HAL_StatusTypeDef BMP280_ReadPressure(BMP280_Handle *bmp, float *pressure_pa);
HAL_StatusTypeDef BMP280_ReadTemperature(BMP280_Handle *bmp, float *temp_c);
#endif
bmp280.c
#include "bmp280.h"
/* 内部函数 */
static HAL_StatusTypeDef readReg8(BMP280_Handle *bmp, uint8_t reg, uint8_t *val) {
return HAL_I2C_Mem_Read(bmp->hi2c, bmp->addr << 1, reg, 1, val, 1, 100);
}
static HAL_StatusTypeDef writeReg8(BMP280_Handle *bmp, uint8_t reg, uint8_t val) {
return HAL_I2C_Mem_Write(bmp->hi2c, bmp->addr << 1, reg, 1, &val, 1, 100);
}
static HAL_StatusTypeDef readRegs(BMP280_Handle *bmp, uint8_t reg, uint8_t *data, uint8_t len) {
return HAL_I2C_Mem_Read(bmp->hi2c, bmp->addr << 1, reg, 1, data, len, 100);
}
/* 读取出厂校准数据 */
static HAL_StatusTypeDef readCalibrationData(BMP280_Handle *bmp) {
uint8_t buf[24];
HAL_StatusTypeDef ret;
// 读取温度补偿系数 (0x88 ~ 0x8D)
ret = readRegs(bmp, 0x88, buf, 24);
if (ret != HAL_OK) return ret;
bmp->calib.dig_T1 = (uint16_t)(buf[0] | (buf[1] << 8));
bmp->calib.dig_T2 = (int16_t) (buf[2] | (buf[3] << 8));
bmp->calib.dig_T3 = (int16_t) (buf[4] | (buf[5] << 8));
bmp->calib.dig_P1 = (uint16_t)(buf[6] | (buf[7] << 8));
bmp->calib.dig_P2 = (int16_t) (buf[8] | (buf[9] << 8));
bmp->calib.dig_P3 = (int16_t) (buf[10] | (buf[11] << 8));
bmp->calib.dig_P4 = (int16_t) (buf[12] | (buf[13] << 8));
bmp->calib.dig_P5 = (int16_t) (buf[14] | (buf[15] << 8));
bmp->calib.dig_P6 = (int16_t) (buf[16] | (buf[17] << 8));
bmp->calib.dig_P7 = (int16_t) (buf[18] | (buf[19] << 8));
bmp->calib.dig_P8 = (int16_t) (buf[20] | (buf[21] << 8));
bmp->calib.dig_P9 = (int16_t) (buf[22] | (buf[23] << 8));
return HAL_OK;
}
/* 初始化 */
HAL_StatusTypeDef BMP280_Init(BMP280_Handle *bmp, I2C_HandleTypeDef *hi2c, uint8_t addr) {
bmp->hi2c = hi2c;
bmp->addr = addr;
bmp->t_fine = 0;
// 验证芯片 ID
uint8_t id;
if (readReg8(bmp, BMP280_REG_ID, &id) != HAL_OK) return HAL_ERROR;
if (id != 0x58) return HAL_ERROR; // BMP280 ID = 0x58
// 复位
writeReg8(bmp, BMP280_REG_RESET, 0xB6);
HAL_Delay(10);
// 读取校准数据
return readCalibrationData(bmp);
}
/* 配置传感器 */
HAL_StatusTypeDef BMP280_Configure(BMP280_Handle *bmp, BMP280_Mode mode,
BMP280_Oversampling osrs_p,
BMP280_Oversampling osrs_t,
BMP280_Filter filter) {
uint8_t ctrl_meas = (osrs_t << 5) | (osrs_p << 2) | mode;
uint8_t config = (filter << 2) | (0x00); // 待机时间 0.5ms
if (writeReg8(bmp, BMP280_REG_CONFIG, config) != HAL_OK) return HAL_ERROR;
if (writeReg8(bmp, BMP280_REG_CTRL_MEAS, ctrl_meas) != HAL_OK) return HAL_ERROR;
return HAL_OK;
}
/* 温度补偿（BMP280 数据手册 BME280 补偿公式）*/
static int32_t compensateTemperature(BMP280_Handle *bmp, int32_t adc_T) {
int32_t var1, var2, T;
var1 = ((((adc_T >> 3) - ((int32_t)bmp->calib.dig_T1 << 1)))
* ((int32_t)bmp->calib.dig_T2)) >> 11;
var2 = (((((adc_T >> 4) - ((int32_t)bmp->calib.dig_T1))
* ((adc_T >> 4) - ((int32_t)bmp->calib.dig_T1))) >> 12)
* ((int32_t)bmp->calib.dig_T3)) >> 14;
bmp->t_fine = var1 + var2;
T = (bmp->t_fine * 5 + 128) >> 8;
return T; // 单位：0.01 ℃ (返回 2345 = 23.45℃)
}
/* 压力补偿 */
static uint32_t compensatePressure(BMP280_Handle *bmp, int32_t adc_P) {
int64_t var1, var2, p;
var1 = ((int64_t)bmp->t_fine) - 128000;
var2 = var1 * var1 * (int64_t)bmp->calib.dig_P6;
var2 = var2 + ((var1 * (int64_t)bmp->calib.dig_P5) << 17);
var2 = var2 + (((int64_t)bmp->calib.dig_P4) << 35);
var1 = ((var1 * var1 * (int64_t)bmp->calib.dig_P3) >> 8)
+ ((var1 * (int64_t)bmp->calib.dig_P2) << 12);
var1 = (((((int64_t)1) << 47) + var1)) * ((int64_t)bmp->calib.dig_P1) >> 33;
if (var1 == 0) return 0; // 避免除零
p = 1048576 - adc_P;
p = (((p << 31) - var2) * 3125) / var1;
var1 = (((int64_t)bmp->calib.dig_P9) * (p >> 13) * (p >> 13)) >> 25;
var2 = (((int64_t)bmp->calib.dig_P8) * p) >> 19;
p = ((p + var1 + var2) >> 8) + (((int64_t)bmp->calib.dig_P7) << 4);
return (uint32_t)p; // 单位：Pa
}
/* 读取温度 */
HAL_StatusTypeDef BMP280_ReadTemperature(BMP280_Handle *bmp, float *temp_c) {
uint8_t buf[3];
if (readRegs(bmp, BMP280_REG_TEMP_MSB, buf, 3) != HAL_OK) return HAL_ERROR;
int32_t adc_T = ((int32_t)buf[0] << 12) | ((int32_t)buf[1] << 4) | (buf[2] >> 4);
int32_t temp = compensateTemperature(bmp, adc_T);
*temp_c = temp / 100.0f;
return HAL_OK;
}
/* 读取气压 */
HAL_StatusTypeDef BMP280_ReadPressure(BMP280_Handle *bmp, float *pressure_pa) {
uint8_t buf[3];
// 先读温度（更新 t_fine）
if (readRegs(bmp, BMP280_REG_TEMP_MSB, buf, 3) != HAL_OK) return HAL_ERROR;
int32_t adc_T = ((int32_t)buf[0] << 12) | ((int32_t)buf[1] << 4) | (buf[2] >> 4);
compensateTemperature(bmp, adc_T);
// 读压力
if (readRegs(bmp, BMP280_REG_PRESS_MSB, buf, 3) != HAL_OK) return HAL_ERROR;
int32_t adc_P = ((int32_t)buf[0] << 12) | ((int32_t)buf[1] << 4) | (buf[2] >> 4);
*pressure_pa = (float)compensatePressure(bmp, adc_P);
return HAL_OK;
}
main.c 液位计算
#include "bmp280.h"
BMP280_Handle bmpGas; // 0x76 — 接气管
BMP280_Handle bmpAtm; // 0x77 — 通大气
#define RHO 1000.0f // 液体密度
#define G 9.80665f // 重力加速度
#define RHO_G (RHO * G) // 9810
int main(void) {
HAL_Init();
SystemClock_Config();
MX_GPIO_Init();
MX_I2C1_Init();
MX_USART1_UART_Init();
// 初始化两颗 BMP280
if (BMP280_Init(&bmpGas, &hi2c1, 0x76) != HAL_OK) {
printf("BMP280-1 (GAS) init failed!\r\n");
while (1);
}
if (BMP280_Init(&bmpAtm, &hi2c1, 0x77) != HAL_OK) {
printf("BMP280-2 (ATM) init failed!\r\n");
while (1);
}
// 配置：NORMAL mode, ×16 压力, ×2 温度, ×4 滤波
BMP280_Configure(&bmpGas, BMP280_MODE_NORMAL,
BMP280_OVERSAMPLING_X16,
BMP280_OVERSAMPLING_X2,
BMP280_FILTER_X4);
BMP280_Configure(&bmpAtm, BMP280_MODE_NORMAL,
BMP280_OVERSAMPLING_X16,
BMP280_OVERSAMPLING_X2,
BMP280_FILTER_X4);
printf("=== Pressure-based Level Sensor ===\r\n");
char buf[128];
while (1) {
float pGas, pAtm, temp;
BMP280_ReadPressure(&bmpGas, &pGas);
BMP280_ReadPressure(&bmpAtm, &pAtm);
BMP280_ReadTemperature(&bmpGas, &temp);
float dp = pGas - pAtm;
float level = (dp / RHO_G) * 1000.0f; // mm
sprintf(buf, "Level: %.1f mm | dP: %.1f Pa | Temp: %.1f C\r\n",
level, dp, temp);
HAL_UART_Transmit(&huart1, (uint8_t *)buf, strlen(buf), 100);
HAL_Delay(500);
}
}
十、标定与校准
10.1 为什么需要标定？
两颗 BMP280 之间本身存在零点偏差（offset error），哪怕它们处于完全相同的环境下，读数也可能相差几十到几百 Pa。如果不标定，这个偏差会直接转化为几厘米的液位误差。
10.2 两点标定法
标定步骤：
1. 空液位（h=0 已知）：读取 ΔP₀ = P_gas₀ - P_atm₀
→ 理论 ΔP 应为 0，实际可能不为 0（零点偏差）
→ offset = ΔP₀
2. 满液位（h=H 已知）：读取 ΔP_H = P_gas_H - P_atm_H
→ ΔP_actual = ΔP_H - offset
→ scale = ΔP_actual / H
3. 应用：
h = (ΔP_raw - offset) / scale
10.3 标定代码
/**
* 液位传感器标定工具
* 串口命令控制
*/
#include <Wire.h>
#include <Adafruit_BMP280.h>
Adafruit_BMP280 bmpGas;
Adafruit_BMP280 bmpAtm;
float calOffset = 0.0f; // 零点偏差 (Pa)
float calScale = 100.0f; // 比例系数 (Pa/cm)
const float RHO_G = 9810.0f;
float readDeltaP(int samples) {
float sum = 0;
for (int i = 0; i < samples; i++) {
sum += bmpGas.readPressure() - bmpAtm.readPressure();
delay(10);
}
return sum / samples;
}
void setup() {
Serial.begin(115200);
Wire.begin();
bmpGas.begin(0x76);
bmpAtm.begin(0x77);
bmpGas.setSampling(Adafruit_BMP280::MODE_NORMAL,
Adafruit_BMP280::SAMPLING_X16,
Adafruit_BMP280::SAMPLING_X2,
Adafruit_BMP280::FILTER_X4,
Adafruit_BMP280::STANDBY_MS_1);
bmpAtm.setSampling(Adafruit_BMP280::MODE_NORMAL,
Adafruit_BMP280::SAMPLING_X16,
Adafruit_BMP280::SAMPLING_X2,
Adafruit_BMP280::FILTER_X4,
Adafruit_BMP280::STANDBY_MS_1);
printHelp();
}
void printHelp() {
Serial.println("\n========== 液位传感器标定工具 ==========");
Serial.println("命令:");
Serial.println(" zero - 空液位归零 (h=0)");
Serial.println(" cal <高度> - 已知液位标定 (单位: cm)");
Serial.println(" 如: cal 50 → 液位 50cm");
Serial.println(" test - 连续读取 30 次验证");
Serial.println(" params - 查看当前标定参数");
Serial.println(" save - 打印参数（写入代码用）");
Serial.println(" help - 显示帮助");
Serial.println("=========================================\n");
}
void loop() {
if (Serial.available()) {
String cmd = Serial.readStringUntil('\n');
cmd.trim();
if (cmd == "zero") {
calOffset = readDeltaP(30);
Serial.print("✅ 零点已设置: offset = ");
Serial.print(calOffset, 2);
Serial.println(" Pa");
} else if (cmd.startsWith("cal ")) {
float knownLevel = cmd.substring(4).toFloat(); // cm
if (knownLevel > 0) {
float dp = readDeltaP(30) - calOffset;
calScale = dp / knownLevel; // Pa/cm
Serial.println("✅ 标定完成:");
Serial.print(" 已知液位: ");
Serial.print(knownLevel);
Serial.println(" cm");
Serial.print(" ΔP (去零点): ");
Serial.print(dp, 2);
Serial.println(" Pa");
Serial.print(" Scale: ");
Serial.print(calScale, 2);
Serial.println(" Pa/cm");
}
} else if (cmd == "test") {
Serial.println("液位(cm)\tΔP(Pa)\t温度(℃)");
for (int i = 0; i < 30; i++) {
float dp = readDeltaP(10);
float level = (dp - calOffset) / calScale;
float temp = bmpGas.readTemperature();
Serial.print(level, 1);
Serial.print("\t\t");
Serial.print(dp, 2);
Serial.print("\t");
Serial.println(temp, 1);
delay(500);
}
} else if (cmd == "params") {
Serial.print("offset = ");
Serial.print(calOffset, 2);
Serial.print(" Pa, scale = ");
Serial.print(calScale, 2);
Serial.println(" Pa/cm");
} else if (cmd == "save") {
Serial.println("// 将以下参数写入代码:");
Serial.print("const float CAL_OFFSET = ");
Serial.print(calOffset, 2);
Serial.println("f; // Pa");
Serial.print("const float CAL_SCALE = ");
Serial.print(calScale, 2);
Serial.println("f; // Pa/cm");
} else if (cmd == "help") {
printHelp();
}
}
}
十一、误差分析与补偿策略
11.1 误差来源全景图
┌──────────────────────────────────┐
│ 液位测量总误差 │
└──────────────────┬───────────────┘
│
┌──────────────────────┼──────────────────────┐
│ │ │
┌────┴────┐ ┌────┴────┐ ┌────┴────┐
│ 传感器 │ │ 气路 │ │ 环境 │
│ 误差 │ │ 误差 │ │ 误差 │
└────┬────┘ └────┬────┘ └────┬────┘
│ │ │
├─ 零点偏差 ├─ 漏气 ├─ 温度波动
├─ 灵敏度偏差 ├─ 冷凝水 ├─ 大气压变化
├─ 非线性 ├─ 管径不当 ├─ 液体密度变化
├─ 噪声 ├─ 气管弹性 └─ 重力加速度
└─ 温漂 └─ 管口堵塞
11.2 各项误差的量级与对策
| 误差源 | 典型量级 | 对策 |
|---|---|---|
| 传感器噪声 | ±1.6 Pa ≈ ±0.16mm | 过采样 + 低通滤波 |
| 零点偏差 | ±50~200 Pa ≈ ±5~20mm | 两点标定 |
| 灵敏度偏差 | ±1~3% | 多点标定 |
| 温漂 | ±0.1 Pa/℃ (BMP390) ±1.5 Pa/℃ (BMP280) | 温度补偿、远离热源 |
| 漏气 | 持续漂移 | 严格密封 |
| 液体密度变化(水 0~40℃) | 0~0.8% | 温度传感器修正 |
| 大气压变化 | 消除（差分测量） | 双传感器方案 |
11.3 温度补偿实战
/**
* 带温度补偿的液位计算
*
* 原理：BMP280 内置温度传感器，
* 我们可以同时修正两个维度：
* 1. 传感器自身的温漂（用出厂校准）
* 2. 液体密度的温度变化
*/
float computeLevelWithTempComp(float pGas, float pAtm,
float tempC,
float calOffset, float calScale) {
// Step 1: 差分气压（传感器温漂已由 BMP280 内部补偿）
float dp = pGas - pAtm - calOffset;
// Step 2: 液体密度温度修正
// ρ(t) = ρ₄ × (1 - (t-4)² / 180000)
float rhoCorr = 1.0f - ((tempC - 4.0f) * (tempC - 4.0f)) / 180000.0f;
// Step 3: 修正后的液位
float level = dp / (calScale * rhoCorr);
return level;
}
11.4 大气压补偿（单传感器方案的无奈之举）
如果成本极度受限，只能用一个传感器（测 P_gas），可以用以下方法获取大气压：
/**
* 单传感器方案的大气压估算
* 方法：定期在气管与大气连通时采样
*/
class SingleBMP280Level {
private:
float pAtm; // 最近一次大气压读数
unsigned long lastAtmUpdate;
public:
// 需要通过电磁阀定期将气管切换到通大气状态
void calibrateAtm(float p) {
pAtm = p;
lastAtmUpdate = millis();
}
float getLevel(float pGas, float tempC) {
float dp = pGas - pAtm;
// ... 后续计算
}
};
⚠️ 老工程师的建议：省那几块钱不值得。双传感器方案带来的精度提升和稳定性远超过 BOM 成本增加。我在一个年出货 10 万台的产品上做过对比，双传感器方案售后率降低了 70%。
十二、项目实战：智能水箱液位监测系统
12.1 项目概述
做一个能远程查看水箱液位、低液位自动告警、历史数据可追溯的智能监测系统。
12.2 系统架构
┌─────────────────────────────────────────────────┐
│ 水箱 (0~2m) │
│ │
│ ┌─── 液面 ───┐ │
│ │ │ │
│ │ ~~~~~~~ │ │
│ │ │ │
│ └──── 管口 ──┘ (底部固定) │
│ │ │
│ 气管 │ (硅胶管 2m) │
│ │ │
│ ┌─────┴──────────────┐ │
│ │ 液位采集终端 │ │
│ │ ESP32 + BMP280×2 │ │
│ │ OLED 显示 │ │
│ └────────┬───────────┘ │
└────────────┼─────────────────────────────────────┘
│ WiFi / MQTT
▼
┌─────────────────┐
│ MQTT Broker │
│ (阿里云IoT/ │
│ 自建EMQX) │
└────────┬────────┘
│
┌────────┴────────┐
│ 应用层 │
│ ├─ 手机 APP │
│ ├─ Web 看板 │
│ └─ 短信/微信 │
│ 告警 │
└─────────────────┘
12.3 ESP32 主控代码
/**
* 智能水箱液位监测系统
* MCU: ESP32
* 传感器: BMP280 × 2 (0x76 / 0x77)
* 联网: WiFi + MQTT
* 显示: OLED 128x64
*/
#include <Wire.h>
#include <WiFi.h>
#include <PubSubClient.h>
#include <Adafruit_BMP280.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
// ==================== WiFi 配置 ====================
const char *WIFI_SSID = "YourWiFi";
const char *WIFI_PASS = "YourPassword";
// ==================== MQTT 配置 ====================
const char *MQTT_BROKER = "broker.emqx.io";
const int MQTT_PORT = 1883;
const char *MQTT_TOPIC_LEVEL = "home/tank/level";
const char *MQTT_TOPIC_TEMP = "home/tank/temp";
const char *MQTT_TOPIC_ALARM = "home/tank/alarm";
const char *CLIENT_ID = "watertank-001";
WiFiClient wifiClient;
PubSubClient mqttClient(wifiClient);
// ==================== 传感器 ====================
Adafruit_BMP280 bmpGas;
Adafruit_BMP280 bmpAtm;
Adafruit_SSD1306 display(128, 64, &Wire, -1);
// ==================== 参数 ====================
const float CAL_OFFSET = -15.3f; // 标定零点 (Pa)
const float CAL_SCALE = 98.07f; // 标定比例 (Pa/cm)
const float ALARM_LOW = 10.0f; // 低液位报警阈值 (cm)
const float ALARM_HIGH = 190.0f; // 高液位报警阈值 (cm)
const float TANK_HEIGHT = 200.0f; // 水箱总高 (cm)
// ==================== 低通滤波 ====================
class LPF {
float a, out; bool init;
public:
LPF(float alpha) : a(alpha), out(0), init(false) {}
float update(float in) {
if (!init) { out = in; init = true; }
else out = a * in + (1 - a) * out;
return out;
}
};
LPF lpf(0.08f);
// ==================== 运行状态 ====================
unsigned long lastMqttSend = 0;
bool alarmActive = false;
// ==================== 初始化 ====================
void setup() {
Serial.begin(115200);
Wire.begin();
// OLED
display.begin(SSD1306_SWITCHCAPVCC, 0x3C);
display.clearDisplay();
display.setTextColor(SSD1306_WHITE);
showBootScreen("Tank Monitor", "Starting...");
// BMP280 × 2
if (!bmpGas.begin(0x76) || !bmpAtm.begin(0x77)) {
showBootScreen("ERROR", "BMP280 fail");
while (1);
}
bmpGas.setSampling(Adafruit_BMP280::MODE_NORMAL,
Adafruit_BMP280::SAMPLING_X16,
Adafruit_BMP280::SAMPLING_X2,
Adafruit_BMP280::FILTER_X8,
Adafruit_BMP280::STANDBY_MS_1);
bmpAtm.setSampling(Adafruit_BMP280::MODE_NORMAL,
Adafruit_BMP280::SAMPLING_X16,
Adafruit_BMP280::SAMPLING_X2,
Adafruit_BMP280::FILTER_X8,
Adafruit_BMP280::STANDBY_MS_1);
// WiFi
WiFi.begin(WIFI_SSID, WIFI_PASS);
int retry = 0;
while (WiFi.status() != WL_CONNECTED && retry < 40) {
delay(500);
Serial.print(".");
retry++;
}
Serial.println(WiFi.status() == WL_CONNECTED ? "\nWiFi OK" : "\nWiFi FAIL");
// MQTT
mqttClient.setServer(MQTT_BROKER, MQTT_PORT);
mqttConnect();
}
// ==================== 主循环 ====================
void loop() {
// MQTT 保活
if (!mqttClient.connected()) mqttConnect();
mqttClient.loop();
// 读取传感器
float pGas = bmpGas.readPressure();
float pAtm = bmpAtm.readPressure();
float temp = bmpGas.readTemperature();
// 计算液位
float dpRaw = pGas - pAtm;
float dp = dpRaw - CAL_OFFSET;
float levelCm = dp / CAL_SCALE;
levelCm = lpf.update(levelCm);
// 百分比
float percent = (levelCm / TANK_HEIGHT) * 100.0f;
percent = constrain(percent, 0.0f, 100.0f);
// 报警判断
checkAlarm(levelCm);
// 显示
updateDisplay(levelCm, percent, temp);
// 定时上报 MQTT (每 30 秒)
if (millis() - lastMqttSend > 30000) {
sendMqtt(levelCm, percent, temp);
lastMqttSend = millis();
}
delay(200);
}
// ==================== 辅助函数 ====================
void showBootScreen(const char *line1, const char *line2) {
display.clearDisplay();
display.setTextSize(2);
display.setCursor(10, 8);
display.println(line1);
display.setTextSize(1);
display.setCursor(10, 45);
display.println(line2);
display.display();
}
void mqttConnect() {
while (!mqttClient.connected()) {
Serial.print("MQTT connecting...");
if (mqttClient.connect(CLIENT_ID)) {
Serial.println("OK");
} else {
Serial.print("failed, rc=");
Serial.println(mqttClient.state());
delay(2000);
}
}
}
void updateDisplay(float level, float percent, float temp) {
display.clearDisplay();
// 液位数字
display.setTextSize(3);
display.setCursor(5, 5);
display.print(level, 1);
display.setTextSize(2);
display.setCursor(75, 10);
display.print("cm");
// 百分比条
display.drawRect(0, 38, 128, 8, SSD1306_WHITE);
int barW = (int)(percent * 128.0f / 100.0f);
display.fillRect(0, 38, barW, 8, SSD1306_WHITE);
// 温度 + 百分比
display.setTextSize(1);
display.setCursor(0, 50);
display.printf("T:%.1fC %.0f%%", temp, percent);
// 报警指示
if (alarmActive) {
display.setCursor(90, 50);
display.print("ALARM!");
}
display.display();
}
void checkAlarm(float level) {
if (level < ALARM_LOW || level > ALARM_HIGH) {
if (!alarmActive) {
alarmActive = true;
mqttClient.publish(MQTT_TOPIC_ALARM,
level < ALARM_LOW ? "LOW" : "HIGH");
}
} else {
alarmActive = false;
}
}
void sendMqtt(float level, float percent, float temp) {
char buf[32];
snprintf(buf, sizeof(buf), "%.1f", level);
mqttClient.publish(MQTT_TOPIC_LEVEL, buf);
snprintf(buf, sizeof(buf), "%.1f", temp);
mqttClient.publish(MQTT_TOPIC_TEMP, buf);
Serial.printf("MQTT sent: %.1f cm, %.1f C\n", level, temp);
}
十三、量产中踩过的坑
以下是我在过去几个量产项目中的真实教训，每一条背后都有故事。
坑一：BMP280 批次一致性
现象：第一批样机精度很好，第二批量产板突然很多不准。
原因：不同批次 BMP280 的零点偏差分布不同。
教训：
- 每一台都要标定，不能用一个固定的 offset
- 工装标定是必须的投资——一个带刻度标尺的测试架 + 自动标定程序，几十秒一台
- BMP280 出厂校准针对的是绝压精度，不是差压精度。做差压应用时，两颗传感器的配对误差需要自己处理
坑二：气管热胀冷缩
现象：白天和晚上液位读数差好几毫米，但实际液位没变。
原因：使用的是普通 PVC 管，热胀冷缩导致管内体积变化。管内空气是密封的，体积一变压强就变。
教训：
- 硅胶管的热胀系数比 PVC 管小得多，优先选用
- 气管尽量避免室外暴晒
- 如果无法避免温差，考虑在传感器端增加一个"补偿气囊"——在密封腔上并联一个软质气囊来缓冲体积变化
坑三：温度分层
现象：水箱 2m 高，顶部和底部水温差 5℃，用哪个温度做密度修正都不太对。
教训：
- 对于精密测量（> 1m 液位，要求 < 1% 误差），需要在管口处加一个温度传感器（如 DS18B20），用管口处水温修正
- 或者取顶部和底部温度的平均值
坑四：气泡问题比想象中严重
现象：新装的系统连续读数偏小，过了几天又"自动变好了"。
原因：安装时管口有小气泡，气泡占用了一部分体积，导致管内气压偏低。几天后气泡慢慢溶解或浮走，读数恢复正常。
教训：
- 安装后必须"排气"——用注射器从传感器端抽几次气
- 如果液体容易产生气体（如污水、发酵液），管口加装脱气装置
- 长期运行的系统中，管口朝下可最大限度减少气泡积聚
坑五：电磁兼容
现象：旁边水泵一启动，液位读数瞬间跳变。
原因：I2C 走线过长，水泵启动的 EMI 干扰了 I2C 通信。
教训：
- I2C 线长度不要超过 30cm，长了转用差分接口（如 PCA9615）
- 传感器和 MCU 放在同一块 PCB 上，不要拉长线
- 电机、泵、继电器与传感器系统分开供电
- PCB 上 BMP280 区域铺地铜 + 多打 GND 过孔
十四、总结与金句
核心结论
用 MEMS 气压计测液位，本质上就是把一颗几块钱的芯片的精度，通过合理的物理设计转化为实用的工业测量方案。
精密测量 = 好的原理 + 好的器件 + 好的标定 + 好的补偿
└──────────┬─────────┘ └───────┬───────┘
"硬件做对" "软件做精"
老工程师的四条金句
① “传感器不接触液体，是最大的可靠性。”
接触式方案的腐蚀、结垢、卡滞问题，在这个方案里不存在。
② “省几块钱的传感器钱，会花掉几百块的售后钱。”
双传感器方案比单传感器贵了不到 5 块钱，但可靠性提升了一个数量级。
③ “标定是称重/测压类仪器的魂，没有标定的传感器就是一块废铁。”
不要以为出厂校准够用——出厂校准给的是绝压精度，你的应用要的是差压精度，两码事。
④ “气路的可靠性，永远排在电路前面。”
漏气这个坑，电路再好也填不上。
技术要点速查
✅ 原理：P_gas - P_atm = ρ·g·h
✅ 关键器件：BMP280 × 2（差分配对）
✅ 气管内径：2~3mm，材质硅胶
✅ 密封是生命线：RTV 硅胶 + 防水透气膜
✅ 两点标定：Zero + 已知液位
✅ 温度补偿：水温密度修正 + 传感器温漂
✅ 通信：I2C SDO 区分地址
✅ 量产：每台标定 + 气路检漏是必须工序
📝 作者简介
40 年嵌入式/电子工程老兵，从 8051 时代写到 ARM Cortex-M，从模拟电路画到高速数字板。见证了 MEMS 传感器从实验室走向消费电子的全过程。目前半退休状态，写写博客，偶尔接一些工业测控的顾问项目。
本文所有代码均经过实际项目验证，可直接用于学习和产品原型开发。
如果对你有帮助，欢迎点赞、收藏、转发。有问题评论区见，看到会回复。🔧
发布于 CSDN | 技术交流与代码下载请私信联系
智能硬件社区聚焦AI智能硬件技术生态，汇聚嵌入式AI、物联网硬件开发者，打造交流分享平台，同步全国赛事资讯、开展 OPC 核心人才招募，助力技术落地与开发者成长。
更多推荐
9
0- 0
已为社区贡献9条内容
所有评论(0)