mirror of https://github.com/periph/devices
Add i2c support for BME680 sensor driver
Divya Bhaskaran
3 months ago
parent
226f28bde0
commit
f0fd3799b8
@ -0,0 +1,334 @@
|
||||
// Copyright 2026 The Periph Authors. All rights reserved.
|
||||
// Use of this source code is governed under the Apache License, Version 2.0
|
||||
// that can be found in the LICENSE file.
|
||||
|
||||
package bme68x
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"testing"
|
||||
|
||||
"periph.io/x/conn/v3/i2c"
|
||||
"periph.io/x/conn/v3/i2c/i2ctest"
|
||||
"periph.io/x/conn/v3/physic"
|
||||
)
|
||||
|
||||
// TestDev_validateDeviceID tests the validateDeviceID method of the Dev struct.
|
||||
// It ensures that the device correctly validates both the chip ID and variant ID
|
||||
// over I2C and returns the expected errors for invalid cases.
|
||||
func TestDev_validateDeviceID(t *testing.T) {
|
||||
for _, test := range []struct {
|
||||
name string
|
||||
ops []i2ctest.IO
|
||||
expectErr error
|
||||
}{
|
||||
{
|
||||
name: "success",
|
||||
ops: []i2ctest.IO{
|
||||
{Addr: I2CAddr, W: []byte{byte(regID)}, R: []byte{ChipDeviceID}},
|
||||
{Addr: I2CAddr, W: []byte{byte(regVariantID)}, R: []byte{0x0}},
|
||||
},
|
||||
expectErr: nil,
|
||||
},
|
||||
{
|
||||
name: "chipIdFailure",
|
||||
ops: []i2ctest.IO{{Addr: I2CAddr, W: []byte{byte(regID)}, R: []byte{0x62}}},
|
||||
expectErr: ErrInvalidChipId,
|
||||
},
|
||||
{
|
||||
name: "variantIdFailure",
|
||||
ops: []i2ctest.IO{
|
||||
{Addr: I2CAddr, W: []byte{byte(regID)}, R: []byte{ChipDeviceID}},
|
||||
{Addr: I2CAddr, W: []byte{byte(regVariantID)}, R: []byte{0x4}},
|
||||
},
|
||||
expectErr: ErrInvalidVariantId,
|
||||
},
|
||||
} {
|
||||
t.Run(test.name, func(t *testing.T) {
|
||||
b := i2ctest.Playback{
|
||||
Ops: test.ops,
|
||||
DontPanic: true,
|
||||
}
|
||||
dev := Device{}
|
||||
dev.d = i2c.Dev{Bus: &b, Addr: I2CAddr}
|
||||
err := dev.validateDeviceID()
|
||||
if !errors.Is(err, test.expectErr) {
|
||||
t.Fatalf("Expected error: %v, got: %v", test.expectErr, err)
|
||||
}
|
||||
if err := b.Close(); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestNewI2cAddrErr tests that creating a new Dev with an invalid I2C address
|
||||
// returns the expected ErrI2cAddress error.
|
||||
func TestNewI2cAddrErr(t *testing.T) {
|
||||
var invalidI2cAddr uint16 = 0x60
|
||||
b := i2ctest.Playback{
|
||||
Ops: []i2ctest.IO{},
|
||||
DontPanic: true,
|
||||
}
|
||||
_, err := NewI2C(&b, invalidI2cAddr)
|
||||
if !errors.Is(err, ErrI2cAddress) {
|
||||
t.Fatalf("Expected error: %v, got: %v", ErrI2cAddress, err)
|
||||
}
|
||||
if err := b.Close(); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
|
||||
// TestDev_IsNewMeasurementReady tests the IsNewMeasurementReady method of Dev.
|
||||
// It verifies that the method correctly interprets the sensor status register.
|
||||
func TestDev_IsNewMeasurementReady(t *testing.T) {
|
||||
for _, test := range []struct {
|
||||
name string
|
||||
ops []i2ctest.IO
|
||||
want bool
|
||||
expectErr error
|
||||
}{
|
||||
{
|
||||
name: "measurementReady",
|
||||
ops: []i2ctest.IO{{Addr: I2CAddr, W: []byte{byte(regEASStatus0)}, R: []byte{0x80}}},
|
||||
expectErr: nil,
|
||||
want: true,
|
||||
},
|
||||
{
|
||||
name: "measurementNotReady",
|
||||
ops: []i2ctest.IO{{Addr: I2CAddr, W: []byte{byte(regEASStatus0)}, R: []byte{0x70}}},
|
||||
expectErr: nil,
|
||||
want: false,
|
||||
},
|
||||
} {
|
||||
t.Run(test.name, func(t *testing.T) {
|
||||
b := i2ctest.Playback{
|
||||
Ops: test.ops,
|
||||
DontPanic: true,
|
||||
}
|
||||
dev := Device{d: i2c.Dev{Bus: &b, Addr: I2CAddr}, variant: VariantNameBME680}
|
||||
dev.ops = dev.newBME680()
|
||||
status, err := dev.IsNewMeasurementReady()
|
||||
if !errors.Is(err, test.expectErr) {
|
||||
t.Fatalf("Expected error: %v, got: %v", test.expectErr, err)
|
||||
}
|
||||
if status != test.want {
|
||||
t.Fatalf("Expected status: %v, got: %v", test.want, status)
|
||||
}
|
||||
if err := b.Close(); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestDev_Sense tests the Sense() method of the BME680 driver.
|
||||
// It simulates I2C transactions and verifies that temperature, pressure,
|
||||
// humidity, and gas resistance readings are correctly returned and compensated.
|
||||
func TestDev_Sense(t *testing.T) {
|
||||
for _, test := range []struct {
|
||||
name string
|
||||
ops []i2ctest.IO
|
||||
testCfg SensorConfig
|
||||
testGasIndex int8
|
||||
want physic.Env
|
||||
gasRes GasResistance
|
||||
gasValid bool
|
||||
expectErr error
|
||||
}{
|
||||
{
|
||||
name: "success",
|
||||
ops: []i2ctest.IO{
|
||||
{Addr: I2CAddr, W: []byte{byte(regCtrlMeas), 0x55}, R: []byte{}},
|
||||
{Addr: I2CAddr, W: []byte{byte(regPressMSB)}, R: []byte{71, 58, 176, 118, 196, 16, 96, 8}},
|
||||
{Addr: I2CAddr, W: []byte{byte(regGasRMsb)}, R: []byte{98, 186}},
|
||||
},
|
||||
testCfg: SensorConfig{TempOversampling: OS2x, PressureOversampling: OS16x, HumidityOversampling: OS1x,
|
||||
IIRFilter: NoFilter, GasEnabled: true, OperatingMode: ForcedMode, GasProfiles: defaultGasProfiles(),
|
||||
},
|
||||
testGasIndex: 0,
|
||||
expectErr: nil,
|
||||
want: physic.Env{Temperature: 2260*10*physic.MilliCelsius + physic.ZeroCelsius, Pressure: 101860.0 * physic.Pascal, Humidity: 67 * physic.PercentRH},
|
||||
gasRes: 8514,
|
||||
gasValid: true,
|
||||
},
|
||||
{
|
||||
name: "gas sensor disabled",
|
||||
testCfg: SensorConfig{
|
||||
GasEnabled: false,
|
||||
OperatingMode: ForcedMode,
|
||||
GasProfiles: defaultGasProfiles(),
|
||||
},
|
||||
testGasIndex: 0,
|
||||
expectErr: ErrNoGasProfileSelected,
|
||||
want: physic.Env{},
|
||||
gasRes: 0,
|
||||
gasValid: false,
|
||||
},
|
||||
{
|
||||
name: "no active gas profile",
|
||||
testCfg: SensorConfig{GasEnabled: true, OperatingMode: ForcedMode},
|
||||
testGasIndex: -1,
|
||||
expectErr: ErrNoGasProfileSelected,
|
||||
},
|
||||
} {
|
||||
t.Run(test.name, func(t *testing.T) {
|
||||
b := i2ctest.Playback{
|
||||
Ops: test.ops,
|
||||
DontPanic: true,
|
||||
}
|
||||
dev := Device{d: i2c.Dev{Bus: &b, Addr: I2CAddr},
|
||||
c: mockCalibration(),
|
||||
cfg: test.testCfg,
|
||||
activeGasProfileIndex: test.testGasIndex,
|
||||
variant: VariantNameBME680,
|
||||
}
|
||||
// Assign sensorOps implementation
|
||||
dev.ops = dev.newBME680()
|
||||
eExp, gExp, gValid, err := dev.Sense()
|
||||
if !errors.Is(err, test.expectErr) {
|
||||
t.Fatalf("Expected error: %v, got: %v", test.expectErr, err)
|
||||
}
|
||||
// Compare Env safely with delta tolerance for Humidity
|
||||
assertEnvEqual(t, eExp, test.want, 0.1, 1.0, 0.01)
|
||||
// Compare gas sensor
|
||||
if gExp != test.gasRes {
|
||||
t.Fatalf("Gas resistance mismatch: got %v, want %v", gExp, test.gasRes)
|
||||
}
|
||||
if gValid != test.gasValid {
|
||||
t.Fatalf("Gas valid mismatch: got %v, want %v", gValid, test.gasValid)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestDev_InitCalibration tests the initialization of sensor calibration data.
|
||||
// It uses i2c test Playback to simulate I2C register reads and verifies
|
||||
// that the Dev.InitCalibration method correctly populates the calibration struct.
|
||||
func TestDev_InitCalibration(t *testing.T) {
|
||||
for _, test := range []struct {
|
||||
name string
|
||||
ops []i2ctest.IO
|
||||
want SensorCalibration
|
||||
expectErr error
|
||||
}{
|
||||
{
|
||||
name: "success",
|
||||
ops: []i2ctest.IO{
|
||||
{Addr: I2CAddr, W: []byte{byte(regParT1)}, R: []byte{254, 100}},
|
||||
{Addr: I2CAddr, W: []byte{byte(regParT2)}, R: []byte{181, 101, 3, 240, 209, 142, 117, 215, 88, 0, 159, 38, 8, 255, 38, 30, 0, 0, 106, 247, 36, 245, 30}},
|
||||
{Addr: I2CAddr, W: []byte{byte(regParH2)}, R: []byte{63, 91, 47, 0, 45, 20, 120, 156}},
|
||||
{Addr: I2CAddr, W: []byte{byte(regParG2)}, R: []byte{81, 211, 186, 18}},
|
||||
{Addr: I2CAddr, W: []byte{byte(regResHeatVal)}, R: []byte{54, 170, 22, 73, 19}},
|
||||
},
|
||||
expectErr: nil,
|
||||
want: mockCalibration(),
|
||||
},
|
||||
} {
|
||||
t.Run(test.name, func(t *testing.T) {
|
||||
b := i2ctest.Playback{
|
||||
Ops: test.ops,
|
||||
DontPanic: true,
|
||||
}
|
||||
dev := Device{d: i2c.Dev{Bus: &b, Addr: I2CAddr}, variant: VariantNameBME680}
|
||||
err := dev.InitCalibration()
|
||||
if !errors.Is(err, test.expectErr) {
|
||||
t.Fatalf("Expected error: %v, got: %v", test.expectErr, err)
|
||||
}
|
||||
if dev.c != test.want {
|
||||
t.Fatalf("Expected calibration: %v, got: %v", test.want, dev.c)
|
||||
}
|
||||
if err := b.Close(); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestCompensations verifies that the sensor compensation functions produce correct results
|
||||
// given known raw ADC readings and a mocked calibration. This ensures the Dev methods
|
||||
// for temperature, pressure, humidity, and gas sensor calculations are accurate.
|
||||
func TestCompensations(t *testing.T) {
|
||||
d := Device{c: mockCalibration(), variant: VariantNameBME680}
|
||||
// Raw Sensor ADC Readings
|
||||
var tRaw uint32 = 480355
|
||||
var pRaw uint32 = 291843
|
||||
var hRaw uint32 = 24615
|
||||
var gRaw uint32 = 386
|
||||
var gasResRange gasRangeR = 10
|
||||
// Expected compensated results (from datasheet formulas / reference implementation)
|
||||
var tExp int32 = 2070 // Temperature in hundredths of °C (20.70°C)
|
||||
var pExp int32 = 101513 // Pressure in Pa
|
||||
var hExp int32 = 67561 // Humidity in thousandths of %RH (67.561%)
|
||||
var gExp int32 = 8566 // Gas resistance in Ohms
|
||||
|
||||
tComp, pComp, hComp, gComp := expectedCompensated(&d, tRaw, pRaw, hRaw, gRaw, gasResRange)
|
||||
if tComp != tExp { // °C
|
||||
t.Fatalf("temp compensation does not match expected value : %v, got: %v", tExp, tComp)
|
||||
}
|
||||
if pComp != pExp { //Pa
|
||||
t.Fatalf("pressure compensation does not match expected = %v, got: %v", pExp, pComp)
|
||||
}
|
||||
if hComp != hExp {
|
||||
t.Fatalf("Humidity compensation does not match expected = %v, got: %v", hExp, hComp)
|
||||
}
|
||||
if gComp != gExp { //Ohm
|
||||
t.Fatalf("Gas compensation does not match expected = %v, got: %v", gExp, gComp)
|
||||
}
|
||||
}
|
||||
|
||||
// mockCalibration returns a SensorCalibration struct populated with fixed calibration constants.
|
||||
// These values simulate a real sensor's calibration data and are used in unit tests to
|
||||
// produce deterministic compensation outputs.
|
||||
func mockCalibration() SensorCalibration {
|
||||
return SensorCalibration{
|
||||
t1: 25854, t2: 26037, t3: 3,
|
||||
p1: 36561, p2: -10379, p3: 88, p4: 9887,
|
||||
p5: -248, p6: 30, p7: 38, p8: -2198, p9: -2780, p10: 30,
|
||||
h1: 763, h2: 1013, h3: 0, h4: 45, h5: 20, h6: 120, h7: -100,
|
||||
g1: -70, g2: -11439, g3: 18,
|
||||
resHeatVal: 54, resHeatRange: 2, switchingErr: 19,
|
||||
tFine: 0, tempComp: 0, pressureComp: 0, humidityComp: 0,
|
||||
}
|
||||
}
|
||||
|
||||
// expectedCompensated computes the fully compensated sensor readings for temperature, pressure,
|
||||
// humidity, and gas resistance based on raw ADC values. This helper is used in tests to
|
||||
// compare actual sensor compensation outputs against expected results.
|
||||
func expectedCompensated(dev *Device, tRaw, pRaw, hRaw, gRaw uint32, gasRange gasRangeR) (int32, int32, int32, int32) {
|
||||
return dev.compensatedTemperature(tRaw),
|
||||
dev.compensatedPressure(pRaw),
|
||||
dev.compensatedHumidity(hRaw),
|
||||
dev.compensatedGasSensor(gRaw, gasRange)
|
||||
}
|
||||
|
||||
// assertEnvEqual compares two physic.Env values (got vs want) with specified tolerances.
|
||||
// deltaTemp, deltaPress, and deltaRH are the allowed differences for temperature, pressure, and humidity respectively.
|
||||
// This is useful because floating-point conversions or sensor rounding can produce small variations.
|
||||
func assertEnvEqual(t *testing.T, got, want physic.Env, deltaTemp, deltaPress, deltaRH float64) {
|
||||
t.Helper()
|
||||
if diff := float64(got.Temperature - want.Temperature); diff < -deltaTemp || diff > deltaTemp {
|
||||
t.Fatalf("Temperature mismatch: got %v, want %v", got.Temperature, want.Temperature)
|
||||
}
|
||||
if diff := float64(got.Pressure - want.Pressure); diff < -deltaPress || diff > deltaPress {
|
||||
t.Fatalf("Pressure mismatch: got %v, want %v", got.Pressure, want.Pressure)
|
||||
}
|
||||
if diff := float64(got.Humidity - want.Humidity); diff < -deltaRH || diff > deltaRH {
|
||||
t.Fatalf("Humidity mismatch: got %v, want %v", got.Humidity, want.Humidity)
|
||||
}
|
||||
}
|
||||
|
||||
// defaultGasProfiles returns a complete default set of GasProfile entries.
|
||||
// This ensures that tests have a consistent, fully populated array and prevents
|
||||
// accidental gaps if additional profiles are added later.
|
||||
func defaultGasProfiles() [10]GasProfile {
|
||||
var profiles [10]GasProfile
|
||||
for i := range profiles {
|
||||
// Default values (can be zero or some safe value)
|
||||
profiles[i] = GasProfile{TargetTempC: 0, HeatingDurationMs: 0}
|
||||
}
|
||||
// Set specific profiles used in tests
|
||||
profiles[0] = GasProfile{TargetTempC: 300, HeatingDurationMs: 250}
|
||||
profiles[7] = GasProfile{TargetTempC: 150, HeatingDurationMs: 100}
|
||||
return profiles
|
||||
}
|
||||
@ -0,0 +1,329 @@
|
||||
// Copyright 2026 The Periph Authors. All rights reserved.
|
||||
// Use of this source code is governed under the Apache License, Version 2.0
|
||||
// that can be found in the LICENSE file.
|
||||
|
||||
package bme68x
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"periph.io/x/conn/v3/i2c"
|
||||
"periph.io/x/conn/v3/physic"
|
||||
)
|
||||
|
||||
// I2CAddr Default I²C address for BME680.
|
||||
const I2CAddr uint16 = 0x77
|
||||
|
||||
// Chip variants
|
||||
const (
|
||||
VariantBME680 uint8 = iota
|
||||
VariantBME688
|
||||
)
|
||||
|
||||
// SensorVariant Variant names
|
||||
type SensorVariant string
|
||||
|
||||
const (
|
||||
VariantNameBME680 SensorVariant = "BME680"
|
||||
VariantNameBME688 SensorVariant = "BME688"
|
||||
)
|
||||
|
||||
// OperatingMode represents the BME680 sensor's power and measurement mode.
|
||||
const (
|
||||
SleepMode uint8 = iota // SleepMode puts the sensor in low-power standby.
|
||||
ForcedMode // ForcedMode triggers a single measurement and then returns to sleep.
|
||||
)
|
||||
|
||||
// Oversampling bit positions.
|
||||
const (
|
||||
tempOSBit uint8 = 0x5
|
||||
pressOSBit uint8 = 0x2
|
||||
humOSBit uint8 = 0x0
|
||||
)
|
||||
|
||||
// Oversampling options for sensor measurements.
|
||||
const (
|
||||
OSSkipped uint8 = iota
|
||||
OS1x
|
||||
OS2x
|
||||
OS4x
|
||||
OS8x
|
||||
OS16x
|
||||
)
|
||||
|
||||
// iirFilterBit Bit position.
|
||||
const iirFilterBit = 0x2
|
||||
|
||||
// IIR filter coefficients for smoothing sensor data.
|
||||
const (
|
||||
NoFilter uint8 = iota
|
||||
C1Filter //nolint:unused
|
||||
C3Filter
|
||||
C7Filter
|
||||
C15Filter
|
||||
C31Filter
|
||||
C63Filter
|
||||
C127Filter
|
||||
)
|
||||
|
||||
// GasResistance is returned in Ohms.
|
||||
type GasResistance uint32
|
||||
|
||||
// GasProfile defines one BME680 gas sensor profile (0-9).
|
||||
type GasProfile struct {
|
||||
TargetTempC uint32 // Heater target temperature in °C
|
||||
HeatingDurationMs uint16 // Heating duration in milliseconds
|
||||
}
|
||||
|
||||
// SensorConfig holds all configurable parameters for the BME680 sensor,
|
||||
// including oversampling, filter, gas sensor profiles, and operating mode.
|
||||
type SensorConfig struct {
|
||||
TempOversampling uint8 // Temperature oversampling setting
|
||||
PressureOversampling uint8 // Pressure oversampling setting
|
||||
HumidityOversampling uint8 // Humidity oversampling setting
|
||||
IIRFilter uint8 // IIR filter coefficient
|
||||
GasEnabled bool // Enable gas measurements
|
||||
GasProfiles [10]GasProfile // Array of Gas sensor profiles
|
||||
AmbientTempC float32 // Ambient temperature for heater calculations
|
||||
OperatingMode uint8 // Sensor operating mode (Sleep/Forced), Default:Sleep
|
||||
}
|
||||
|
||||
var (
|
||||
ErrI2cAddress = errors.New("i2c: provided address is not supported by the device")
|
||||
ErrInvalidChipId = errors.New("bme68x: invalid chip ID")
|
||||
ErrInvalidVariantId = errors.New("bme68x: invalid variant ID")
|
||||
ErrNoGasProfileSelected = errors.New("bme68x: no gas profile selected, but gas measurements are enabled")
|
||||
ErrRunSetupSensor = errors.New("bme68x: gas measurement disabled; run SetupSensor()")
|
||||
ErrNilSensorConfig = errors.New("bme680: nil SensorConfig")
|
||||
)
|
||||
|
||||
// Device represents a handle to a BME680 sensor.
|
||||
type Device struct {
|
||||
d i2c.Dev // I²C device handle
|
||||
variant SensorVariant // Sensor variant identifier
|
||||
mutex sync.Mutex // Mutex for concurrent access
|
||||
cfg SensorConfig // User-provided configuration
|
||||
c SensorCalibration // Calibration data
|
||||
activeGasProfileIndex int8 // Currently active gas profile index; -1 if none selected
|
||||
ops sensorOps // Interface for low-level chip operations (read/write registers, measure)
|
||||
ambientTempC float32 // Ambient temperature used for gas sensor compensation
|
||||
}
|
||||
|
||||
// sensorOps defines low-level operations implemented by a specific BME68x chip variant.
|
||||
type sensorOps interface {
|
||||
prepareGasConfig() []byte // prepares the gas heater configuration buffer
|
||||
sense() (physic.Env, GasResistance, bool, error) // triggers a single measurement and returns TPH optionally gas resistance with validity flag
|
||||
status() (sensorStatus, error) // reads the current sensor status
|
||||
setGasProfile(profile uint8) error // activates a specific gas profile (0-9) without triggering measurement
|
||||
}
|
||||
|
||||
// NewI2C initializes a BME68x sensor over I²C.
|
||||
func NewI2C(b i2c.Bus, addr uint16) (*Device, error) {
|
||||
// Validate I2C Address
|
||||
if addr != I2CAddr {
|
||||
return nil, ErrI2cAddress
|
||||
}
|
||||
device := Device{d: i2c.Dev{Bus: b, Addr: addr}}
|
||||
// Validate Device and Variant ID
|
||||
if err := device.validateDeviceID(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
// Calibration Initialization - Common for both variant
|
||||
if err := device.InitCalibration(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return &device, nil
|
||||
}
|
||||
|
||||
// GetSensorVariant return the type of BME68X sensor connected
|
||||
func (dev *Device) GetSensorVariant() SensorVariant {
|
||||
return dev.variant
|
||||
}
|
||||
|
||||
// SetupSensor configures oversampling, filter, and gas heater profiles.
|
||||
// Does NOT trigger measurements; call Sense() for actual data. Copies user-provided SensorConfig and validates values.
|
||||
// Builds a write buffer for control registers and optionally gas heater registers.
|
||||
func (dev *Device) SetupSensor(config *SensorConfig) error {
|
||||
if config == nil {
|
||||
return ErrNilSensorConfig
|
||||
}
|
||||
dev.mutex.Lock()
|
||||
defer dev.mutex.Unlock()
|
||||
dev.cfg = *config
|
||||
dev.activeGasProfileIndex = -1 // default: no active profile
|
||||
dev.ambientTempC = dev.cfg.AmbientTempC
|
||||
if err := dev.validateOversampling(); err != nil {
|
||||
return err
|
||||
}
|
||||
writeBuf := []byte{
|
||||
byte(regCtrlHum), dev.cfg.HumidityOversampling << humOSBit,
|
||||
byte(regCtrlMeas), dev.cfg.PressureOversampling<<pressOSBit | dev.cfg.TempOversampling<<tempOSBit,
|
||||
byte(regConfig), dev.cfg.IIRFilter << iirFilterBit,
|
||||
}
|
||||
if dev.cfg.GasEnabled {
|
||||
gasBuf := dev.ops.prepareGasConfig()
|
||||
if len(gasBuf) > 0 {
|
||||
writeBuf = append(writeBuf, gasBuf...)
|
||||
}
|
||||
}
|
||||
return dev.regWrite(writeBuf)
|
||||
}
|
||||
|
||||
// SensorSoftReset performs a software reset of the BME680. (It restores the device to its default state without power cycling)
|
||||
// Writes the reset command to regReset and waits 20ms for the sensor to reboot.
|
||||
func (dev *Device) SensorSoftReset() error {
|
||||
dev.mutex.Lock()
|
||||
defer dev.mutex.Unlock()
|
||||
writeBuf := []byte{byte(regReset), byte(DeviceSoftReset)}
|
||||
if err := dev.regWrite(writeBuf); err != nil {
|
||||
return err
|
||||
}
|
||||
time.Sleep(20 * time.Millisecond)
|
||||
return nil
|
||||
}
|
||||
|
||||
// IsNewMeasurementReady returns true if a new TPHG measurement is available.
|
||||
// Returns false if reading the status fails.
|
||||
func (dev *Device) IsNewMeasurementReady() (bool, error) {
|
||||
dev.mutex.Lock()
|
||||
defer dev.mutex.Unlock()
|
||||
status, err := dev.ops.status()
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
return status.MeasurementReady, nil
|
||||
}
|
||||
|
||||
// ActiveGasProfile returns the currently active gas profile index (0-9).
|
||||
// Returns -1 if no gas profile is active or reading the status fails.
|
||||
func (dev *Device) ActiveGasProfile() (int8, error) {
|
||||
dev.mutex.Lock()
|
||||
defer dev.mutex.Unlock()
|
||||
status, err := dev.ops.status()
|
||||
if err != nil {
|
||||
return -1, err
|
||||
}
|
||||
return int8(status.GasProfileInProgress), nil
|
||||
}
|
||||
|
||||
// Sense triggers a single forced-mode measurement and returns the compensated data.
|
||||
// Returns temperature, pressure, humidity, and optionally gas resistance (with validity flag).
|
||||
// If gas measurements are enabled, a gas profile and GasEnabled must be selected beforehand.
|
||||
// Blocks until the measurement is ready.
|
||||
func (dev *Device) Sense() (physic.Env, GasResistance, bool, error) {
|
||||
dev.mutex.Lock()
|
||||
defer dev.mutex.Unlock()
|
||||
return dev.ops.sense()
|
||||
}
|
||||
|
||||
// SetGasProfile sets the active gas profile (0-9) on the BME680 sensor.
|
||||
// Does not trigger measurement; call Sense() afterwards
|
||||
// Updates the sensor hardware and the internal activeGasProfileIndex.
|
||||
func (dev *Device) SetGasProfile(profile uint8) error {
|
||||
// Validate profile index
|
||||
if profile > 9 {
|
||||
return fmt.Errorf("bme680: gas profile index must be 0-9, got %d", profile)
|
||||
}
|
||||
// Ensure gas measurements are enabled
|
||||
if !dev.cfg.GasEnabled {
|
||||
return ErrRunSetupSensor
|
||||
}
|
||||
dev.mutex.Lock()
|
||||
defer dev.mutex.Unlock()
|
||||
return dev.ops.setGasProfile(profile)
|
||||
}
|
||||
|
||||
// validateDeviceID verifies the BME68x chip ID and variant ID.
|
||||
// It reads the regID and regVariantID registers and sets the device variant.
|
||||
// Returns an error if the device is not a BME680 or BME688 (unsupported).
|
||||
func (dev *Device) validateDeviceID() error {
|
||||
var id, vid []byte
|
||||
var err error
|
||||
if id, err = dev.regRead(regID, 0x1); err != nil {
|
||||
return err
|
||||
}
|
||||
if id[0] != ChipDeviceID {
|
||||
return fmt.Errorf("bme68x: invalid chip ID (expected=0x%x, got=0x%x): %w", ChipDeviceID, id[0], ErrInvalidChipId)
|
||||
}
|
||||
if vid, err = dev.regRead(regVariantID, 0x1); err != nil {
|
||||
return err
|
||||
}
|
||||
switch vid[0] {
|
||||
case VariantBME680:
|
||||
dev.variant = VariantNameBME680
|
||||
dev.ops = dev.newBME680()
|
||||
case VariantBME688:
|
||||
dev.variant = VariantNameBME688
|
||||
return fmt.Errorf("bme68x: BME688 support not implemented yet")
|
||||
default:
|
||||
return fmt.Errorf("bme68x: invalid variant ID (expected=0 or 1, got=0x%x): %w", vid[0], ErrInvalidVariantId)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// triggerForcedMeasurement starts a forced-mode measurement on the BME680,
|
||||
// waits for it to complete based on sensor configuration (TPH oversampling, gas heater, etc.),
|
||||
// and ensures the data is ready to read.
|
||||
func (dev *Device) triggerForcedMeasurement() error {
|
||||
// Ensure device is in forced mode
|
||||
if dev.cfg.OperatingMode != ForcedMode {
|
||||
dev.cfg.OperatingMode = ForcedMode
|
||||
}
|
||||
// Set forced mode to start measurement
|
||||
if err := dev.regWrite([]byte{byte(regCtrlMeas),
|
||||
dev.cfg.PressureOversampling<<pressOSBit | dev.cfg.TempOversampling<<tempOSBit | ForcedMode}); err != nil {
|
||||
return err
|
||||
}
|
||||
// Wait for measurements to complete
|
||||
// time.Sleep(d.forcedModeWaitTime())
|
||||
return nil
|
||||
}
|
||||
|
||||
// forcedModeWaitTime computes the time required for a complete forced-mode measurement.
|
||||
// Takes into account:
|
||||
// - Oversampling for Temperature, Pressure, Humidity
|
||||
// - TPH switching overhead
|
||||
// - Gas measurement overhead
|
||||
// - Gas heater duration
|
||||
// - Wake-up time
|
||||
// - Gas heating duration (if enabled)
|
||||
//
|
||||
// Returns the total wait time as time.Duration
|
||||
func (dev *Device) forcedModeWaitTime() time.Duration {
|
||||
cycles := dev.osCycles(dev.cfg.TempOversampling) +
|
||||
dev.osCycles(dev.cfg.PressureOversampling) + dev.osCycles(dev.cfg.HumidityOversampling)
|
||||
// Reference : Bosch - BME68x_SensorAPI
|
||||
duration := time.Duration(cycles*1963)*time.Microsecond + // TPH switching overhead
|
||||
time.Duration(477*(4+5))*time.Microsecond // TPH switch + gas overhead
|
||||
// Add Gas Heating Duration if applicable
|
||||
if dev.cfg.GasEnabled && dev.activeGasProfileIndex >= 0 {
|
||||
duration += time.Duration(dev.cfg.GasProfiles[dev.activeGasProfileIndex].HeatingDurationMs) * time.Millisecond
|
||||
}
|
||||
return duration
|
||||
}
|
||||
|
||||
// validateOversampling validates the oversampling threshold
|
||||
func (dev *Device) validateOversampling() error {
|
||||
if dev.cfg.TempOversampling > OS16x {
|
||||
return fmt.Errorf("invalid temperature oversampling value: %d", dev.cfg.TempOversampling)
|
||||
}
|
||||
if dev.cfg.PressureOversampling > OS16x {
|
||||
return fmt.Errorf("invalid pressure oversampling value: %d", dev.cfg.PressureOversampling)
|
||||
}
|
||||
if dev.cfg.HumidityOversampling > OS16x {
|
||||
return fmt.Errorf("invalid humidity oversampling value: %d", dev.cfg.HumidityOversampling)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// osCycles helper to return the measurement cycles as per oversampling
|
||||
func (dev *Device) osCycles(os uint8) int {
|
||||
osToMeasureCycles := [...]int{0, 1, 2, 4, 8, 16}
|
||||
if int(os) >= len(osToMeasureCycles) {
|
||||
return 0 // safe fallback
|
||||
}
|
||||
return osToMeasureCycles[os]
|
||||
}
|
||||
@ -0,0 +1,14 @@
|
||||
// Copyright 2026 The Periph Authors. All rights reserved.
|
||||
// Use of this source code is governed under the Apache License, Version 2.0
|
||||
// that can be found in the LICENSE file.
|
||||
|
||||
// Package bme68x controls a Bosch BME680 device over I²C
|
||||
//
|
||||
// # More details
|
||||
//
|
||||
// See https://periph.io/device/bme68x/ for more details about the device.
|
||||
//
|
||||
// # Datasheet
|
||||
// BME680: https://www.bosch-sensortec.com/media/boschsensortec/downloads/datasheets/bst-bme680-ds001.pdf
|
||||
|
||||
package bme68x
|
||||
@ -0,0 +1,79 @@
|
||||
// Copyright 2026 The Periph Authors. All rights reserved.
|
||||
// Use of this source code is governed under the Apache License, Version 2.0
|
||||
// that can be found in the LICENSE file.
|
||||
|
||||
package bme68x_test
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"time"
|
||||
|
||||
"periph.io/x/conn/v3/i2c/i2creg"
|
||||
bme680 "periph.io/x/devices/v3/bme68x"
|
||||
"periph.io/x/host/v3"
|
||||
)
|
||||
|
||||
const (
|
||||
i2cBus = "/dev/i2c-1"
|
||||
i2cAddr = 0x77
|
||||
)
|
||||
|
||||
func main() {
|
||||
if _, err := host.Init(); err != nil {
|
||||
fmt.Println("Error: Failed to Host init()")
|
||||
return
|
||||
}
|
||||
|
||||
b, err := i2creg.Open(i2cBus)
|
||||
if err != nil {
|
||||
fmt.Printf("failed to open I2C bus: %v", err)
|
||||
return
|
||||
}
|
||||
defer b.Close()
|
||||
|
||||
// Get the Device handler
|
||||
d, err := bme680.NewI2C(b, i2cAddr)
|
||||
if err != nil {
|
||||
fmt.Printf("Error: failed to initialize BME680 sensor: %v\n", err)
|
||||
}
|
||||
|
||||
// user configuration
|
||||
userCfg := &bme680.SensorConfig{
|
||||
TempOversampling: bme680.OS2x, PressureOversampling: bme680.OS16x,
|
||||
HumidityOversampling: bme680.OS1x, IIRFilter: bme680.NoFilter,
|
||||
GasProfiles: [10]bme680.GasProfile{
|
||||
0: {TargetTempC: 300, HeatingDurationMs: 250},
|
||||
7: {TargetTempC: 150, HeatingDurationMs: 100},
|
||||
},
|
||||
GasEnabled: true,
|
||||
OperatingMode: bme680.ForcedMode,
|
||||
}
|
||||
|
||||
if err := d.SetupSensor(userCfg); err != nil {
|
||||
fmt.Printf("Error: Failed Setup Sensor %v\n", err)
|
||||
}
|
||||
if err := d.SetGasProfile(0); err != nil {
|
||||
fmt.Printf("Error: Failed to select gas profile %v\n", err)
|
||||
}
|
||||
|
||||
// Create a ticker to trigger measurements every 15 seconds
|
||||
ticker := time.NewTicker(15 * time.Second)
|
||||
defer ticker.Stop()
|
||||
|
||||
// Infinite loop to continuously read measurements at the specified interval
|
||||
for range ticker.C {
|
||||
env, gasResistance, valid, err := d.Sense()
|
||||
if err != nil {
|
||||
fmt.Printf("Failed to read sensor: %v", err)
|
||||
continue
|
||||
}
|
||||
fmt.Printf("[%s] Temp: %.3f C, Humidity: %5s, Pressure: %9s, Gas: %s\n",
|
||||
time.Now().Format("15:04:05"), env.Temperature.Celsius(), env.Humidity, env.Pressure,
|
||||
func() string {
|
||||
if valid {
|
||||
return fmt.Sprintf("%d Ohm", gasResistance)
|
||||
}
|
||||
return "INVALID"
|
||||
}())
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,141 @@
|
||||
// Copyright 2026 The Periph Authors. All rights reserved.
|
||||
// Use of this source code is governed under the Apache License, Version 2.0
|
||||
// that can be found in the LICENSE file.
|
||||
|
||||
package bme68x
|
||||
|
||||
const (
|
||||
DeviceSoftReset = 0x38
|
||||
ChipDeviceID = 0x61
|
||||
)
|
||||
|
||||
type reg uint8
|
||||
|
||||
// BME680 Register Addresses
|
||||
const (
|
||||
// Status, ID, reset & Ctl
|
||||
regStatus reg = 0x73 //unused
|
||||
regReset reg = 0xE0
|
||||
regID reg = 0xD0
|
||||
regConfig reg = 0x75
|
||||
regCtrlMeas reg = 0x74
|
||||
regCtrlHum reg = 0x72
|
||||
regCtrlGas1 reg = 0x71
|
||||
regCtrlGas0 reg = 0x70
|
||||
|
||||
// Gas wait time registers
|
||||
regGasWait0 reg = 0x64
|
||||
regGasWait1 reg = 0x65
|
||||
regGasWait2 reg = 0x66
|
||||
regGasWait3 reg = 0x67
|
||||
regGasWait4 reg = 0x68
|
||||
regGasWait5 reg = 0x69
|
||||
regGasWait6 reg = 0x6A
|
||||
regGasWait7 reg = 0x6B
|
||||
regGasWait8 reg = 0x6C
|
||||
regGasWait9 reg = 0x6D
|
||||
|
||||
// Heater registers
|
||||
regResHeat0 reg = 0x5A
|
||||
regResHeat1 reg = 0x5B
|
||||
regResHeat2 reg = 0x5C
|
||||
regResHeat3 reg = 0x5D
|
||||
regResHeat4 reg = 0x5E
|
||||
regResHeat5 reg = 0x5F
|
||||
regResHeat6 reg = 0x60
|
||||
regResHeat7 reg = 0x61
|
||||
regResHeat8 reg = 0x62
|
||||
regResHeat9 reg = 0x63
|
||||
|
||||
// IDAC heater registers : Retained for future use
|
||||
regIDACHeat0 reg = 0x50 //unused
|
||||
regIDACHeat1 reg = 0x51 //unused
|
||||
regIDACHeat2 reg = 0x52 //unused
|
||||
regIDACHeat3 reg = 0x53 //unused
|
||||
regIDACHeat4 reg = 0x54 //unused
|
||||
regIDACHeat5 reg = 0x55 //unused
|
||||
regIDACHeat6 reg = 0x56 //unused
|
||||
regIDACHeat7 reg = 0x57 //unused
|
||||
regIDACHeat8 reg = 0x58 //unused
|
||||
regIDACHeat9 reg = 0x59 //unused
|
||||
|
||||
// Sensor data registers
|
||||
regGasRMsb reg = 0x2A
|
||||
regGasRLsb reg = 0x2B //unused
|
||||
regHumMSB reg = 0x25 //unused
|
||||
regHumLSB reg = 0x26 //unused
|
||||
regTempXLSB reg = 0x24 //unused
|
||||
regTempLSB reg = 0x23 //unused
|
||||
regTempMSB reg = 0x22 //unused
|
||||
regPressXLSB reg = 0x21 //unused
|
||||
regPressLSB reg = 0x20 //unused
|
||||
regPressMSB reg = 0x1F
|
||||
|
||||
// Extended status and variant ID
|
||||
regEASStatus0 reg = 0x1D
|
||||
regVariantID reg = 0xF0
|
||||
|
||||
// Temperature calibration registers
|
||||
regParT1 reg = 0xE9 // uint16, LSB @ 0xE9, MSB @ 0xEA
|
||||
regParT2 reg = 0x8A // int16, LSB @ 0x8A, MSB @ 0x8B
|
||||
regParT3 reg = 0x8C // int8
|
||||
|
||||
// Pressure calibration registers
|
||||
regParP1 reg = 0x8E // uint16, LSB @ 0x8E / MSB @ 0x8F
|
||||
regParP2 reg = 0x90 // int16 LSB @ 0x90 / MSB @ 0x91
|
||||
regParP3 reg = 0x92 // int8
|
||||
regParP4 reg = 0x94 // int16 LSB @ 0x94 / MSB @ 0x95
|
||||
regParP5 reg = 0x96 // int16 LSB @ 0x96 / MSB @ 0x97
|
||||
regParP6 reg = 0x99 // int8
|
||||
regParP7 reg = 0x98 // int8
|
||||
regParP8 reg = 0x9C // int16 LSB @ 0x9C / MSB @ 0x9D
|
||||
regParP9 reg = 0x9E // int16 LSB @ 0x9E / MSB @ 0x9F
|
||||
regParP10 reg = 0xA0 // uint8
|
||||
|
||||
// Humidity calibration (packed) registers
|
||||
regParH2 reg = 0xE1 // H2[11:4] LSB @ 0xE2<7:4> / MSB @ 0xE1
|
||||
regParH1 reg = 0xE3 // H1[11:4] LSB @ 0xE2<3:0> / MSB @ 0xE3
|
||||
regParH3 reg = 0xE4 // int8
|
||||
regParH4 reg = 0xE5 // int8
|
||||
regParH5 reg = 0xE6 // int8
|
||||
regParH6 reg = 0xE7 // uint8
|
||||
regParH7 reg = 0xE8 // int8
|
||||
|
||||
// Gas calibration registers
|
||||
regParG2 reg = 0xEB // int16 LSB @ 0xEB / MSB @ 0xEC
|
||||
regParG1 reg = 0xED // int8
|
||||
regParG3 reg = 0xEE // int8
|
||||
|
||||
// Heater calibration (special registers)
|
||||
regResHeatVal reg = 0x00
|
||||
regResHeatRange reg = 0x02 // <5:4>
|
||||
regRangeSwitchingError reg = 0x04
|
||||
)
|
||||
|
||||
// Global slices for gas sensor registers
|
||||
var gasWaitRegs = []reg{
|
||||
regGasWait0, regGasWait1, regGasWait2, regGasWait3, regGasWait4,
|
||||
regGasWait5, regGasWait6, regGasWait7, regGasWait8, regGasWait9,
|
||||
}
|
||||
|
||||
var resHeatRegs = []reg{
|
||||
regResHeat0, regResHeat1, regResHeat2, regResHeat3, regResHeat4,
|
||||
regResHeat5, regResHeat6, regResHeat7, regResHeat8, regResHeat9,
|
||||
}
|
||||
|
||||
// regWrite writes a sequence of bytes to the device
|
||||
func (dev *Device) regWrite(b []byte) error {
|
||||
if err := dev.d.Tx(b, nil); err != nil {
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// regRead reads a sequence of bytes from a given register
|
||||
func (dev *Device) regRead(addr reg, length uint8) ([]byte, error) {
|
||||
readBuf := make([]byte, length)
|
||||
if err := dev.d.Tx([]byte{byte(addr)}, readBuf); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return readBuf, nil
|
||||
}
|
||||
Loading…
Reference in New Issue