【.NET 与树莓派】气压传感器——BMP180

BMP180 是一款数字气压计传感器，实际可读出温度和气压值。此模块使用 IIC（i2c）协议。模块体积很小，比老周的大拇指指甲还小；也很便宜，一般是长这样的。螺丝孔只开一个，也有开两个孔的。

 这货基本上没有焊接排针的，买回来得自己焊。以前提过，老周的焊工比较差，注定成不了焊武帝。所以在焊接的时候，第一次是温度没调高，280度居然化不了锡（锡丝说明上说180-254度均可），然后调到300度，OK。然而一时手残，有两个焊盘被我弄成“连锡”，于是很无奈地用烙铁头拼命地刮锡。总算焊好了，只是长相实在丑陋，看着像四抔鸡 Shi 在上面。也罢，反正自己用，管他呢，能导电就行。

做实验时其实不焊接也行，把它放在面包板上，然后用面包板线直接插在模块的接口上、这样做能用，只是容易接触不良。当然了，你找四根铁丝（或剥了皮的电线）穿过焊盘上的孔，用手拧紧也行，反正能让其导电就行。

-----------------------------------------------------------------------------------------------------------------------

BMP180 模块其实操作起来不算难，就是读出来的数据换算过程比较长。这个可以直接抄数据手册上的，只是抄的时候要专心，很容易抄错步骤。

首先，它的 IIC 从机地址是 0x77。

const int DEV_ADDR = 0x77;

它有四种工作方式，由过采样率（OSRS）表示，值分别为0，1，2，3。

1、超低功耗（ultra low power）= 0；

2、标准（standard） = 1；

3、高精度（high）= 2；

4、超高精度（ultra high resolution)）= 3。

由于这些值是固定的，咱们可以用一个枚举类型来定义。

    public enum OSRS
    {
        UltraLowPower = 0,
        Standard = 1,
        High = 2,
        UltraHighResolution = 3
    }

一、初始化校准变量

在模块上电后，需要从一系列寄存器中读出一堆 16 位整数，用于模块自身的校准。因为每个寄存器中的值是 8 位，所以，每个校准变量都要用到两个寄存器，高字节先读，再读低字节。

下面是数据手册上的截图。

 编程的时候，直接按这个来就是了。比如，AC1 变量，读的寄存器为 0xAA 和 0xAB。其中，只有 AC4、AC5、AC6 是无符号整数（ushort），其他都是有符号的（short）。

        short AC1, AC2, AC3;
        ushort AC4, AC5,AC6;
        short B1, B2;
        short MB, MC, MD;

读寄存器的方法是先向 IIC 从机写入（发送）寄存器的地址，然后再读，这样就会返回对应寄存器的值。

1、write address ----->

2、read value <-------

        private byte ReadByteFromReg(byte regaddr)
        {
            byte r = 0;
            // 1、写入要读的寄存器地址
            _dev.WriteByte(regaddr);
            // 2、读内容
            r = _dev.ReadByte();
            return r;
        }

读16位整数就是读两个寄存器，然后把两个字节组成一个16位整数值，这里它采用的是“大端”格式（Big Endian）。可以使用一个辅助类——

BinaryPrimitives ，位于 System.Buffers.Binary 命名空间。

        private UInt16 ReadUint16(byte addr1, byte addr2)
        {
            UInt16 r = 0;
            Span<byte> data = stackalloc byte[2];
            // 读第一个字节
            data[0] = ReadByteFromReg(addr1);
            // 读第二个字节
            data[1] = ReadByteFromReg(addr2);
            // 字节顺序为“大端”（BE）
            r = BinaryPrimitives.ReadUInt16BigEndian(data);
            return r;
        }

这个方法统一返回无符号整数，需要时可以强制转换为有符号的。比如，用下面代码来初始化校准变量。

            AC1 = (short)ReadUint16(0xaa, 0xab);
            AC2 = (short)ReadUint16(0xac, 0xad);
            AC3 = (short)ReadUint16(0xae, 0xaf);
            AC4 = ReadUint16(0xb0, 0xb1);
            AC5 = ReadUint16(0xb2, 0xb3);
            AC6 = ReadUint16(0xb4, 0xb5);
            B1 = (short)ReadUint16(0xb6, 0xb7);
            B2 = (short)ReadUint16(0xb8, 0xb9);
            MB = (short)ReadUint16(0xba, 0xbb);
            MC = (short)ReadUint16(0xbc, 0xbd);
            MD = (short)ReadUint16(0xbe, 0xbf);

二、读出温度和气压的原始数据（未经过OSRS补偿）

在读出数据后需要进行一堆运算，其中会用到这些变量。

        int B3, B5, B6;
        uint B4, B7;
        int X1, X2, X3;

        float _temper, _pressure;

最后一行的两个浮点数，表示经过运算后真实的温度和气压值。温度单位为摄氏度，气压单位为帕。温度精度是 0.1 摄氏度，即 290 表示 29.0 度；气压精度是帕，一般我们看天气预报用的是百帕（hPa），所以结果要乘以 0.01。

下面两个方法读出温度和气压的原始值，类型为整型。

        // 私有方法：读出未经OSRS补偿的温度
        private int ReadUncompensatedTemper()
        {
            // 1、先向0xF4寄存器写入0x2e
            WriteByteToReg(0xf4, 0x2e);
            // 2、坐和等待
            Thread.Sleep(5);
            // 3、从两个寄存器中读出数据
            return (int)ReadUint16(0xf6, 0xf7);
        }
        // 私有方法：读出未作补偿的气压
        // 这个读出来是24位的，所以用int
        private int ReadUncompensatedPressure()
        {
            // 写寄存器
            byte wv = (byte)(0x34 + ((byte)_osrs << 6)); // 注意这里
            WriteByteToReg(0xf4, wv);
            // 等待时间由OSRS决定
            // 精度越高，所需要的时间越长
            switch(_osrs)
            {
                case OSRS.UltraLowPower:
                    Thread.Sleep(5);
                    break;
                case OSRS.Standard:
                    Thread.Sleep(8);
                    break;
                case OSRS.High:
                    Thread.Sleep(14);
                    break;
                case OSRS.UltraHighResolution:
                    Thread.Sleep(26);
                    break;
            }
            // 读出
            byte[] data = new byte[3];
            data[0] = ReadByteFromReg(0xf6);
            data[1] = ReadByteFromReg(0xf7);
            data[2] = ReadByteFromReg(0xf8);
            return ((data[0] << 16) + (data[1] << 8) + data[2]) >> (8 - (byte)_osrs);
        }

在写完寄存器后，因为模块要采集数据，所以要等待十到几十毫秒，精度越高，等待的时间越长。这是数据手册上的表格。

三、补偿运算（得出真正的结果）

这个过程是连续的，先算出真实的温度，再算气压；计算气压时也会用到温度的计算结果，所以说这个过程其实是连起来的。这个过程没什么特殊技巧的，完全就是抄手册。流程如下

运算的代码如下：

        public void MeasureDatas()
        {
            int ut = ReadUncompensatedTemper();
            int up = ReadUncompensatedPressure();
            X1 = (ut - AC6) * AC5 / 32768;
            X2 = MC * 2048 / (X1 + MD);
            B5 = X1 + X2;
            // 温度已算出
            _temper = ((B5 + 8) / 16) * 0.1f;
            B6 = B5 - 4000;
            X1 = (B2 * (B6 * B6 / 4096)) / 2048;
            X2 = AC2 * B6 / 2048;
            X3 = X1 + X2;
            B3 = (((AC1 * 4 + X3) << (byte)_osrs) + 2) / 4;
            X1 = AC3 * B6 / 8192;
            X2 = (B1 * (B6 * B6 / 4096)) / 65536;
            X3 = ((X1 + X2) + 2) / 4;
            B4 = AC4 * (uint)(X3 + 32768) / 32768;
            B7 = (uint)(up - B3) * (uint)(50000 >> (byte)_osrs);
            int p = B7 < 0x80000000 ? (int)((B7*2)/B4) : (int)((B7/B4)*2);
            X1 = (p * p) / 65536;
            X1 = (X1 * 3038) / 65536;
            X2 = (-7357 * p) / 65536;
            p = p + (X1 + X2 + 3791) / 16;
            // 气压已算出
            _pressure = p * 0.01f;
        }

抄手册时要小心，因为太长，一不小心就会抄错。整个文件的代码如下：

using System;
using System.Device.I2c;
using System.Buffers.Binary;
using System.Threading;

namespace Device
{
    // 过采样率
    public enum OSRS
    {
        UltraLowPower = 0,
        Standard = 1,
        High = 2,
        UltraHighResolution = 3
    }

    public class Bmp180 : IDisposable
    {
        // 默认地址
        private const int DEV_ADDR = 0x77;
        // 过采样系数
        OSRS _osrs;
        // IIC 设备引用
        I2cDevice _dev = null;

        // 下面这一组变量都是根据数据手册定义的
        short AC1, AC2, AC3;
        ushort AC4, AC5,AC6;
        short B1, B2;
        short MB, MC, MD;
        int B3, B5, B6;
        uint B4, B7;
        int X1, X2, X3;

        float _temper, _pressure;

        // 构造函数
        public Bmp180(OSRS oss = OSRS.Standard)
        {
            _osrs = oss;
            // 初始化IIC设备
            // 总线ID（BUS ID）可以自己根据实际来改
            // 我这里用的是4，一般默认是1
            I2cConnectionSettings cs = new(4, DEV_ADDR);
            _dev = I2cDevice.Create(cs);
            // 读入校准数据
            ReadCalibration();
        }

        // 私有方法：向寄存器写入字节
        private void WriteByteToReg(byte regaddr, byte val)
        {
            Span<byte> data = stackalloc byte[2];
            data[0] = regaddr; //寄存器地址
            data[1] = val;      //要写的值
            _dev.Write(data);
        }
        // 私有方法：从寄存器读出字节
        private byte ReadByteFromReg(byte regaddr)
        {
            byte r = 0;
            // 1、写入要读的寄存器地址
            _dev.WriteByte(regaddr);
            // 2、读内容
            r = _dev.ReadByte();
            return r;
        }

        // 私有方法：从寄存器中读出16位整数
        // 16位整数有两个字节，分布在两个寄存器中
        private UInt16 ReadUint16(byte addr1, byte addr2)
        {
            UInt16 r = 0;
            Span<byte> data = stackalloc byte[2];
            // 读第一个字节
            data[0] = ReadByteFromReg(addr1);
            // 读第二个字节
            data[1] = ReadByteFromReg(addr2);
            // 字节顺序为“大端”（BE）
            r = BinaryPrimitives.ReadUInt16BigEndian(data);
            return r;
        }
        // 私有方法：读校准数据
        // 这个没啥技术含量，完全按照手册上来
        private void ReadCalibration()
        {
            AC1 = (short)ReadUint16(0xaa, 0xab);
            AC2 = (short)ReadUint16(0xac, 0xad);
            AC3 = (short)ReadUint16(0xae, 0xaf);
            AC4 = ReadUint16(0xb0, 0xb1);
            AC5 = ReadUint16(0xb2, 0xb3);
            AC6 = ReadUint16(0xb4, 0xb5);
            B1 = (short)ReadUint16(0xb6, 0xb7);
            B2 = (short)ReadUint16(0xb8, 0xb9);
            MB = (short)ReadUint16(0xba, 0xbb);
            MC = (short)ReadUint16(0xbc, 0xbd);
            MD = (short)ReadUint16(0xbe, 0xbf);
        }
        // 私有方法：读出未经OSRS补偿的温度
        private int ReadUncompensatedTemper()
        {
            // 1、先向0xF4寄存器写入0x2e
            WriteByteToReg(0xf4, 0x2e);
            // 2、坐和等待
            Thread.Sleep(5);
            // 3、从两个寄存器中读出数据
            return (int)ReadUint16(0xf6, 0xf7);
        }
        // 私有方法：读出未作补偿的气压
        // 这个读出来是24位的，所以用int
        private int ReadUncompensatedPressure()
        {
            // 写寄存器
            byte wv = (byte)(0x34 + ((byte)_osrs << 6)); // 注意这里
            WriteByteToReg(0xf4, wv);
            // 等待时间由OSRS决定
            // 精度越高，所需要的时间越长
            switch(_osrs)
            {
                case OSRS.UltraLowPower:
                    Thread.Sleep(5);
                    break;
                case OSRS.Standard:
                    Thread.Sleep(8);
                    break;
                case OSRS.High:
                    Thread.Sleep(14);
                    break;
                case OSRS.UltraHighResolution:
                    Thread.Sleep(26);
                    break;
            }
            // 读出
            byte[] data = new byte[3];
            data[0] = ReadByteFromReg(0xf6);
            data[1] = ReadByteFromReg(0xf7);
            data[2] = ReadByteFromReg(0xf8);
            return ((data[0] << 16) + (data[1] << 8) + data[2]) >> (8 - (byte)_osrs);
        }

        // 公共方法：处理所有数据
        public void MeasureDatas()
        {
            int ut = ReadUncompensatedTemper();
            int up = ReadUncompensatedPressure();
            X1 = (ut - AC6) * AC5 / 32768;
            X2 = MC * 2048 / (X1 + MD);
            B5 = X1 + X2;
            // 温度已算出
            _temper = ((B5 + 8) / 16) * 0.1f;
            B6 = B5 - 4000;
            X1 = (B2 * (B6 * B6 / 4096)) / 2048;
            X2 = AC2 * B6 / 2048;
            X3 = X1 + X2;
            B3 = (((AC1 * 4 + X3) << (byte)_osrs) + 2) / 4;
            X1 = AC3 * B6 / 8192;
            X2 = (B1 * (B6 * B6 / 4096)) / 65536;
            X3 = ((X1 + X2) + 2) / 4;
            B4 = AC4 * (uint)(X3 + 32768) / 32768;
            B7 = (uint)(up - B3) * (uint)(50000 >> (byte)_osrs);
            int p = B7 < 0x80000000 ? (int)((B7*2)/B4) : (int)((B7/B4)*2);
            X1 = (p * p) / 65536;
            X1 = (X1 * 3038) / 65536;
            X2 = (-7357 * p) / 65536;
            p = p + (X1 + X2 + 3791) / 16;
            // 气压已算出
            _pressure = p * 0.01f;
        }

        // 公共属性：获得真实的温度值
        public float GetTemper() => _temper;
        // 公共属性：获得真实的气压
        public float GetPressure() => _pressure;

        public void Dispose()
        {
            _dev?.Dispose();
        }
    }
}

【注】在实例化 I2cConnectionSettings 时，bus id 一般是 1，因为老周在树莓派上开了 i2c-4，所以总线是 4（因为默认的GPIO被外接的风扇插头挡住，插不进杜邦线）。

测试一下。

        static void Main(string[] args)
        {
            Bmp180 dev = new Bmp180();

            while(true)
            {
                dev.MeasureDatas();
                Console.Clear();
                float temp = dev.GetTemper();
                float pres = dev.GetPressure();
                Console.WriteLine("温度：{0:0.00} ℃，气压：{1:0.00} hPa", temp, pres);
                System.Threading.Thread.Sleep(1000);
            }
        }

结果如下图所示。

这个运算过程有个地方比较蛋疼，那就是误差。怎么说呢，比如一个表达式中同时存在乘法和除法时，你会发现先除再乘，与先乘再除之间所产生的结果是有差距的，得到的气压会接近 1015 hPa 到 1020 hPa。比如，有行代码：

 实际上这是个平方运算，但是，用  (p / 256) * (p / 256) 与  (p * p) / 65536 之间得到结果会有差距，这个真不好说哪个更准确了。

 ===========================================================================================

上面老周只是为了给大伙伴演示才自己动手写了个封装，其实微软团队已经在 Iot.Device.Bindings 库中提供了封装，可以直接拿来用。

在项目中添加 system.device.gpio 和 iot.device.bindings 这两个包包的引用。

dotnet add package System.Device.Gpio
dotnet add package Iot.Device.Bindings

然后就可以直接开局。

using System;
using System.Device.I2c;
using Iot.Device.Bmp180;
using System.Threading;
using UnitsNet;

namespace MyApp
{
    class Program
    {
        static void Main(string[] args)
        {
            // IIC 总线初始化
            I2cConnectionSettings iicset = new I2cConnectionSettings(4, Bmp180.DefaultI2cAddress);
            I2cDevice device= I2cDevice.Create(iicset);
            // BMP180对象初始化
            Bmp180 bmpobj = new Bmp180(device);
            // 设置采样模式
            bmpobj.SetSampling(Sampling.Standard);

            // 读数
            while(1 == 1)
            {
                // 温度
                Temperature tmp = bmpobj.ReadTemperature();
                // 气压
                Pressure prs = bmpobj.ReadPressure();
                // 输出
                string outstr = $"温度：{tmp.DegreesCelsius:0.00} ℃
气压：{prs.Hectopascals:0.00} hPa";
                Console.Clear();
                Console.WriteLine(outstr);
                Thread.Sleep(1000);
            }
        }
    }
}

注意 I2cConnectionSettings 初始化时，总线ID我这里用的是4，前面说过原因，如果你没修改过树莓派的配置，那默认是 1。

运行结果如下：

 因为刚刚下了一场大暴雨，所以温度比上午时低了 2 度。

好了，今天的博文就水到这里了。