* drivers/sensors/bme680_uorb.c
*
* SPDX-License-Identifier: Apache-2.0
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership. The
* ASF licenses this file to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance with the
* License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*
****************************************************************************/
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <nuttx/nuttx.h>
#include <stdio.h>
#include <stdlib.h>
#include <fixedmath.h>
#include <errno.h>
#include <debug.h>
#include <string.h>
#include <nuttx/arch.h>
#include <nuttx/kmalloc.h>
#include <nuttx/kthread.h>
#include <nuttx/mutex.h>
#include <nuttx/semaphore.h>
#include <nuttx/signal.h>
#include <nuttx/fs/fs.h>
#include <nuttx/i2c/i2c_master.h>
#include <nuttx/sensors/bme680.h>
#include <nuttx/sensors/sensor.h>
#if defined(CONFIG_I2C) && defined(CONFIG_SENSORS_BME680)
* Pre-processor Definitions
****************************************************************************/
#define BME680_ADDR 0x76
#define BME680_FREQ CONFIG_BME680_I2C_FREQUENCY
#define BME680_DEVID 0x61
#ifdef CONFIG_BME680_DISABLE_PRESS_MEAS
# define BME680_TEMP_IDX (0)
#else
# define BME680_TEMP_IDX (-1)
#endif
#define BME680_TEMP_IDX_OFF BME680_TEMP_IDX
#ifndef CONFIG_BME680_DISABLE_PRESS_MEAS
# define BME680_PRESS_IDX (BME680_TEMP_IDX_OFF + (1))
# define BME680_PRESS_IDX_OFF BME680_PRESS_IDX
#else
# define BME680_PRESS_IDX (-1)
# define BME680_PRESS_IDX_OFF BME680_TEMP_IDX_OFF
#endif
#ifndef CONFIG_BME680_DISABLE_HUM_MEAS
# define BME680_HUM_IDX (BME680_PRESS_IDX_OFF + (1))
# define BME680_HUM_IDX_OFF BME680_HUM_IDX
#else
# define BME680_HUM_IDX (-1)
# define BME680_HUM_IDX_OFF BME680_PRESS_IDX_OFF
#endif
#ifndef CONFIG_BME680_DISABLE_GAS_MEAS
# define BME680_GAS_IDX (BME680_HUM_IDX_OFF + (1))
# define BME680_GAS_IDX_OFF BME680_GAS_IDX
#else
# define BME680_GAS_IDX (-1)
# define BME680_GAS_IDX_OFF BME680_HUM_IDX_OFF
#endif
#define BME680_SENSORS_COUNT (BME680_GAS_IDX_OFF + (1))
#define BME680_STATUS_REG_ADDR 0X73
#define BME680_RESET_REG_ADDR 0xE0
#define BME680_ID_REG_ADDR 0xD0
#define BME680_CTRL_HUM_ADDR 0x72
#define BME680_CTRL_MEAS_ADDR 0x74
#define BME680_CONFIG_REG_ADDR 0x75
#define BME680_CTRL_GAS0 0x70
#define BME680_CTRL_GAS1 0x71
#define BME680_PRESS_MSB 0x1F
#define BME680_PRESS_LSB 0x20
#define BME680_PRESS_XLSB 0x21
#define BME680_TEMP_MSB 0x22
#define BME680_TEMP_LSB 0x23
#define BME680_TEMP_XLSB 0x24
#define BME680_HUM_MSB 0x25
#define BME680_HUM_LSB 0x26
#define BME680_GAS_R_MSB 0x2A
#define BME680_GAS_R_LSB 0x2B
#define BME680_IDAC_HEAT_ADDR 0x50
#define BME680_RES_HEAT_ADDR 0x5A
#define BME680_GAS_WAIT_ADDR 0x64
#define BME680_MEAS_STAT0 0x1D
#define BME680_NBCONV_MIN (0)
#define BME680_NBCONV_MAX (9)
#define BME680_SLEEP_MODE (0x00)
#define BME680_FORCED_MODE (0x01)
#define BME680_SOFT_RESET (0xB6)
#define BME680_COEFF_ADDR1 (0x89)
#define BME680_COEFF_ADDR2 (0xE1)
#define BME680_COEFF_SIZE (41)
#define BME680_COEFF_ADDR1_LEN (25)
#define BME680_COEFF_ADDR2_LEN (16)
#define BME680_DATA_ADDR (0x1D)
#define BME680_DATA_LEN (15)
#define BME680_RES_HEAT_RANGE_ADDR (0x02)
#define BME680_RES_HEAT_VAL_ADDR (0x00)
#define BME680_RANGE_SW_ERR_ADDR (0x04)
#define BME680_T2_LSB_REG (1)
#define BME680_T2_MSB_REG (2)
#define BME680_T3_REG (3)
#define BME680_P1_LSB_REG (5)
#define BME680_P1_MSB_REG (6)
#define BME680_P2_LSB_REG (7)
#define BME680_P2_MSB_REG (8)
#define BME680_P3_REG (9)
#define BME680_P4_LSB_REG (11)
#define BME680_P4_MSB_REG (12)
#define BME680_P5_LSB_REG (13)
#define BME680_P5_MSB_REG (14)
#define BME680_P7_REG (15)
#define BME680_P6_REG (16)
#define BME680_P8_LSB_REG (19)
#define BME680_P8_MSB_REG (20)
#define BME680_P9_LSB_REG (21)
#define BME680_P9_MSB_REG (22)
#define BME680_P10_REG (23)
#define BME680_H2_MSB_REG (25)
#define BME680_H2_LSB_REG (26)
#define BME680_H1_LSB_REG (26)
#define BME680_H1_MSB_REG (27)
#define BME680_H3_REG (28)
#define BME680_H4_REG (29)
#define BME680_H5_REG (30)
#define BME680_H6_REG (31)
#define BME680_H7_REG (32)
#define BME680_T1_LSB_REG (33)
#define BME680_T1_MSB_REG (34)
#define BME680_GH2_LSB_REG (35)
#define BME680_GH2_MSB_REG (36)
#define BME680_GH1_REG (37)
#define BME680_GH3_REG (38)
#define BME680_GAS_MEAS_MSK (0x30)
#define BME680_NBCONV_MSK (0X0F)
#define BME680_FILTER_MSK (0X1C)
#define BME680_OST_MSK (0XE0)
#define BME680_OSP_MSK (0X1C)
#define BME680_OSH_MSK (0X07)
#define BME680_HCTRL_MSK (0x08)
#define BME680_RUN_GAS_MSK (0x10)
#define BME680_MODE_MSK (0x03)
#define BME680_RHRANGE_MSK (0x30)
#define BME680_RSERROR_MSK (0xF0)
#define BME680_NEW_DATA_MSK (0x80)
#define BME680_GAS_INDEX_MSK (0x0F)
#define BME680_GAS_RANGE_MSK (0x0F)
#define BME680_GASM_VALID_MSK (0x20)
#define BME680_HEAT_STAB_MSK (0x10)
#define BME680_MEM_PAGE_MSK (0x10)
#define BME680_BIT_H1_DATA_MSK (0x0F)
#define MIN_HOT_PLATE_TEMP (200)
#define MAX_HOT_PLATE_TEMP (400)
#define BME680_MAX_OVERFLOW_VAL (0x40000000ULL)
const uint32_t const_array1_int[16] =
{
2147483647, 2147483647, 2147483647, 2147483647,
2147483647, 2126008810, 2147483647, 2130303777,
2147483647, 2147483647, 2143188679, 2136746228,
2147483647, 2126008810, 2147483647, 2147483647
};
const uint32_t const_array2_int[16] =
{
4096000000, 2048000000, 1024000000, 512000000,
255744255, 127110228, 64000000, 32258064, 16016016,
8000000, 4000000, 2000000, 1000000, 500000,
250000, 125000
};
const float const_array1[16] =
{
1.0, 1.0, 1.0, 1.0, 1.0, 0.99, 1.0, 0.992, 1.0, 1.0,
0.998, 0.995, 1.0, 0.99, 1.0, 1.0
};
const float const_array2[16] =
{
8000000.0, 4000000.0, 2000000.0, 1000000.0, 499500.4995,
248262.1648, 125000.0, 63004.03226, 31281.28128, 15625.0,
7812.5, 3906.25, 1953.125, 976.5625, 488.28125, 244.140625
};
#define CHECK_OS_BOUNDS(type) \
((type) >= BME680_OS_SKIPPED && (type) <= BME680_OS_16X)
* Private Type Definitions
****************************************************************************/
struct bme680_data_s
{
uint64_t timestamp;
float temperature;
float pressure;
float humidity;
float gas_resistance;
};
struct bme680_calib_s
{
uint16_t t1;
int16_t t2;
int8_t t3;
#ifndef CONFIG_BME680_DISABLE_PRESS_MEAS
uint16_t p1;
int16_t p2;
int8_t p3;
int16_t p4;
int16_t p5;
int8_t p6;
int8_t p7;
int16_t p8;
int16_t p9;
uint8_t p10;
#endif
#ifndef CONFIG_BME680_DISABLE_HUM_MEAS
uint16_t h1;
uint16_t h2;
int8_t h3;
int8_t h4;
int8_t h5;
uint8_t h6;
int8_t h7;
#endif
#ifndef CONFIG_BME680_DISABLE_GAS_MEAS
int8_t gh1;
int16_t gh2;
int8_t gh3;
uint8_t res_heat_range;
int8_t res_heat_val;
int8_t range_sw_err;
#endif
int32_t t_fine;
};
struct bme680_sensor_s
{
struct sensor_lowerhalf_s lower[BME680_SENSORS_COUNT];
struct bme680_calib_s calib;
struct bme680_config_s config;
bool calibrated;
};
struct bme680_dev_s
{
struct bme680_sensor_s dev;
FAR struct i2c_master_s *i2c;
mutex_t dev_lock;
sem_t run;
bool enabled;
};
typedef int (*push_data_func)(FAR struct bme680_dev_s *priv,
FAR struct bme680_data_s *data);
* Private Function Prototypes
****************************************************************************/
static uint8_t bme680_getreg8(FAR struct bme680_dev_s *priv,
uint8_t regaddr);
static int bme680_putreg8(FAR struct bme680_dev_s *priv, uint8_t regaddr,
uint8_t regval);
static int bme680_getregs(FAR struct bme680_dev_s *priv, uint8_t regaddr,
uint8_t *rxbuffer, uint8_t length);
#ifndef CONFIG_BME680_DISABLE_PRESS_MEAS
static int bme680_push_press_data(FAR struct bme680_dev_s *priv,
FAR struct bme680_data_s *data);
#else
static int bme680_push_temp_data(FAR struct bme680_dev_s *priv,
FAR struct bme680_data_s *data);
#endif
#ifndef CONFIG_BME680_DISABLE_HUM_MEAS
static int bme680_push_hum_data(FAR struct bme680_dev_s *priv,
FAR struct bme680_data_s *data);
#endif
#ifndef CONFIG_BME680_DISABLE_GAS_MEAS
static int bme680_push_gas_data(FAR struct bme680_dev_s *priv,
FAR struct bme680_data_s *data);
#endif
static int bme680_activate(FAR struct sensor_lowerhalf_s *lower,
FAR struct file *filep,
bool enable);
static int bme680_calibrate(FAR struct sensor_lowerhalf_s *lower,
FAR struct file *filep,
unsigned long arg);
static int bme680_control(FAR struct sensor_lowerhalf_s *lower,
FAR struct file *filep,
int cmd, unsigned long arg);
* Private Data
****************************************************************************/
static const push_data_func deliver_data[BME680_SENSORS_COUNT] =
{
#ifndef CONFIG_BME680_DISABLE_PRESS_MEAS
bme680_push_press_data
#else
bme680_push_temp_data
#endif
#ifndef CONFIG_BME680_DISABLE_HUM_MEAS
, bme680_push_hum_data
#endif
#ifndef CONFIG_BME680_DISABLE_GAS_MEAS
, bme680_push_gas_data
#endif
};
static const struct sensor_ops_s g_sensor_ops =
{
NULL,
NULL,
bme680_activate,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
bme680_calibrate,
NULL,
NULL,
bme680_control
};
* Private Functions
****************************************************************************/
* Name: bme680_getreg8
*
* Description:
* Read from an 8-bit BME680 register
*
****************************************************************************/
static uint8_t bme680_getreg8(FAR struct bme680_dev_s *priv, uint8_t regaddr)
{
struct i2c_msg_s msg[2];
uint8_t regval = 0;
int ret;
msg[0].frequency = BME680_FREQ;
msg[0].addr = BME680_ADDR;
msg[0].flags = 0;
msg[0].buffer = ®addr;
msg[0].length = 1;
msg[1].frequency = BME680_FREQ;
msg[1].addr = BME680_ADDR;
msg[1].flags = I2C_M_READ;
msg[1].buffer = ®val;
msg[1].length = 1;
ret = I2C_TRANSFER(priv->i2c, msg, 2);
if (ret < 0)
{
snerr("I2C_TRANSFER failed: %d\n", ret);
return 0;
}
return regval;
}
* Name: bme680_getregs
*
* Description:
* Read <length> bytes starting from a BME680 register addr
*
****************************************************************************/
static int bme680_getregs(FAR struct bme680_dev_s *priv, uint8_t regaddr,
uint8_t *rxbuffer, uint8_t length)
{
struct i2c_msg_s msg[2];
int ret;
msg[0].frequency = BME680_FREQ;
msg[0].addr = BME680_ADDR;
msg[0].flags = 0;
msg[0].buffer = ®addr;
msg[0].length = 1;
msg[1].frequency = BME680_FREQ;
msg[1].addr = BME680_ADDR;
msg[1].flags = I2C_M_READ;
msg[1].buffer = rxbuffer;
msg[1].length = length;
ret = I2C_TRANSFER(priv->i2c, msg, 2);
if (ret < 0)
{
snerr("I2C_TRANSFER failed: %d\n", ret);
return -1;
}
return OK;
}
* Name: bme680_putreg8
*
* Description:
* Write to an 8-bit BME680 register
*
****************************************************************************/
static int bme680_putreg8(FAR struct bme680_dev_s *priv, uint8_t regaddr,
uint8_t regval)
{
struct i2c_msg_s msg[2];
uint8_t txbuffer[2];
int ret;
txbuffer[0] = regaddr;
txbuffer[1] = regval;
msg[0].frequency = BME680_FREQ;
msg[0].addr = BME680_ADDR;
msg[0].flags = 0;
msg[0].buffer = txbuffer;
msg[0].length = 2;
ret = I2C_TRANSFER(priv->i2c, msg, 1);
if (ret < 0)
{
snerr("I2C_TRANSFER failed: %d\n", ret);
}
return ret;
}
* Name: bme680_checkid
*
* Description:
* Read and verify the BME680 chip ID
*
****************************************************************************/
static int bme680_checkid(FAR struct bme680_dev_s *priv)
{
uint8_t devid = 0;
devid = bme680_getreg8(priv, BME680_ID_REG_ADDR);
up_mdelay(1);
sninfo("devid: 0x%02x\n", devid);
if (devid != (uint8_t)BME680_DEVID)
{
snerr("Wrong Device ID! %02x\n", devid);
return -ENODEV;
}
return OK;
}
* Name: bme680_get_calib_data
*
* Description:
* Read sensor-specific parameters and store them for later
* use in computing the compensated values.
*
****************************************************************************/
static int bme680_get_calib_data(FAR struct bme680_dev_s *priv)
{
uint8_t coeff[BME680_COEFF_SIZE];
uint8_t temp_val;
int ret;
ret = bme680_getregs(priv, BME680_COEFF_ADDR1, coeff,
BME680_COEFF_ADDR1_LEN);
if (ret < 0)
{
return ret;
}
ret = bme680_getregs(priv, BME680_COEFF_ADDR2,
&coeff[BME680_COEFF_ADDR1_LEN],
BME680_COEFF_ADDR2_LEN);
if (ret < 0)
{
return ret;
}
priv->dev.calib.t1 = coeff[BME680_T1_MSB_REG] << 8
| coeff[BME680_T1_LSB_REG];
priv->dev.calib.t2 = coeff[BME680_T2_MSB_REG] << 8
| coeff[BME680_T2_LSB_REG];
priv->dev.calib.t3 = coeff[BME680_T3_REG];
#ifndef CONFIG_BME680_DISABLE_PRESS_MEAS
priv->dev.calib.p1 = coeff[BME680_P1_MSB_REG] << 8
| coeff[BME680_P1_LSB_REG];
priv->dev.calib.p2 = coeff[BME680_P2_MSB_REG] << 8
| coeff[BME680_P2_LSB_REG];
priv->dev.calib.p3 = coeff[BME680_P3_REG];
priv->dev.calib.p4 = coeff[BME680_P4_MSB_REG] << 8
| coeff[BME680_P4_LSB_REG];
priv->dev.calib.p5 = coeff[BME680_P5_MSB_REG] << 8
| coeff[BME680_P5_LSB_REG];
priv->dev.calib.p6 = coeff[BME680_P6_REG];
priv->dev.calib.p7 = coeff[BME680_P7_REG];
priv->dev.calib.p8 = coeff[BME680_P8_MSB_REG] << 8
| coeff[BME680_P8_LSB_REG];
priv->dev.calib.p9 = coeff[BME680_P9_MSB_REG] << 8
| coeff[BME680_P9_LSB_REG];
priv->dev.calib.p10 = coeff[BME680_P10_REG];
#endif
#ifndef CONFIG_BME680_DISABLE_HUM_MEAS
priv->dev.calib.h1 = (uint16_t)(((uint16_t)coeff[BME680_H1_MSB_REG] << 4)
| (coeff[BME680_H1_LSB_REG] & BME680_BIT_H1_DATA_MSK));
priv->dev.calib.h2 = (uint16_t)(((uint16_t)coeff[BME680_H2_MSB_REG] << 4)
| ((coeff[BME680_H2_LSB_REG]) >> 4));
priv->dev.calib.h3 = coeff[BME680_H3_REG];
priv->dev.calib.h4 = coeff[BME680_H4_REG];
priv->dev.calib.h5 = coeff[BME680_H5_REG];
priv->dev.calib.h6 = coeff[BME680_H6_REG];
priv->dev.calib.h7 = coeff[BME680_H7_REG];
#endif
#ifndef CONFIG_BME680_DISABLE_GAS_MEAS
priv->dev.calib.gh1 = coeff[BME680_GH1_REG];
priv->dev.calib.gh2 = coeff[BME680_GH2_MSB_REG] << 8
| coeff[BME680_GH2_LSB_REG];
priv->dev.calib.gh3 = coeff[BME680_GH3_REG];
ret = bme680_getregs(priv, BME680_RES_HEAT_RANGE_ADDR, &temp_val, 1);
if (ret < 0)
{
return ret;
}
priv->dev.calib.res_heat_range = ((temp_val & BME680_RHRANGE_MSK)) / 16;
ret = bme680_getregs(priv, BME680_RES_HEAT_VAL_ADDR, &temp_val, 1);
if (ret < 0)
{
return ret;
}
priv->dev.calib.res_heat_val = (int8_t)temp_val;
ret = bme680_getregs(priv, BME680_RANGE_SW_ERR_ADDR, &temp_val, 1);
if (ret < 0)
{
return ret;
}
priv->dev.calib.range_sw_err = ((int8_t)temp_val
& (int8_t)BME680_RSERROR_MSK) / 16;
#endif
return ret;
}
* Name: bme680_set_mode
*
* Description:
* Set sensor mode and wait for it to change accordingly.
*
****************************************************************************/
static int bme680_set_mode(FAR struct bme680_dev_s *priv, uint8_t mode)
{
int ret;
uint8_t power_mode;
uint8_t regval;
ret = bme680_getregs(priv, BME680_CTRL_MEAS_ADDR, ®val, 1);
if (ret < 0)
{
return ret;
}
power_mode = regval & BME680_MODE_MSK;
if (power_mode != mode)
{
regval &= (uint8_t)(~BME680_MODE_MSK);
regval |= (mode & BME680_MODE_MSK);
ret = bme680_putreg8(priv, BME680_CTRL_MEAS_ADDR, regval);
if (ret < 0)
{
return ret;
}
ret = bme680_getregs(priv, BME680_CTRL_MEAS_ADDR, ®val, 1);
while ((regval & BME680_MODE_MSK) != mode)
{
up_mdelay(100);
ret = bme680_getregs(priv, BME680_CTRL_MEAS_ADDR, ®val, 1);
}
}
return OK;
}
* Name: bme680_set_oversamp
*
* Description:
* Set temperature, pressure and humidity oversampling.
*
****************************************************************************/
static int bme680_set_oversamp(FAR struct bme680_dev_s *priv)
{
struct bme680_config_s config = priv->dev.config;
int ret;
uint8_t regval;
#ifndef CONFIG_BME680_DISABLE_HUM_MEAS
regval = config.hum_os & BME680_OSH_MSK;
ret = bme680_putreg8(priv, BME680_CTRL_HUM_ADDR, regval);
#endif
regval = 0;
ret = bme680_getregs(priv, BME680_CTRL_MEAS_ADDR, ®val, 1);
if (ret < 0)
{
return ret;
}
regval &= BME680_MODE_MSK;
regval |= ((config.temp_os << 5) & BME680_OST_MSK);
#ifndef CONFIG_BME680_DISABLE_PRESS_MEAS
regval |= ((config.press_os << 2) & BME680_OSP_MSK);
#endif
ret = bme680_putreg8(priv, BME680_CTRL_MEAS_ADDR, regval);
if (ret < 0)
{
return ret;
}
return OK;
}
#ifndef CONFIG_BME680_DISABLE_PRESS_MEAS
static int bme680_push_press_data(FAR struct bme680_dev_s *priv,
FAR struct bme680_data_s *data)
{
struct sensor_baro press_data;
int ret;
struct sensor_lowerhalf_s lower = priv->dev.lower[BME680_PRESS_IDX];
press_data.timestamp = data->timestamp;
press_data.temperature = data->temperature;
press_data.pressure = data->pressure / 100.f;
ret = lower.push_event(lower.priv, &press_data,
sizeof(struct sensor_baro));
if (ret < 0)
{
snerr("Pushing baro data failed\n");
return ret;
}
return OK;
}
#else
static int bme680_push_temp_data(FAR struct bme680_dev_s *priv,
FAR struct bme680_data_s *data)
{
struct sensor_temp temp_data;
int ret;
struct sensor_lowerhalf_s lower = priv->dev.lower[BME680_TEMP_IDX];
temp_data.timestamp = data->timestamp;
temp_data.temperature = data->temperature;
ret = lower.push_event(lower.priv, &temp_data, sizeof(struct sensor_temp));
if (ret < 0)
{
snerr("Pushing temperature data failed\n");
return ret;
}
return OK;
}
#endif
#ifndef CONFIG_BME680_DISABLE_HUM_MEAS
static int bme680_push_hum_data(FAR struct bme680_dev_s *priv,
FAR struct bme680_data_s *data)
{
struct sensor_humi hum_data;
int ret;
struct sensor_lowerhalf_s lower = priv->dev.lower[BME680_HUM_IDX];
hum_data.timestamp = data->timestamp;
hum_data.humidity = data->humidity;
ret = lower.push_event(lower.priv, &hum_data, sizeof(struct sensor_humi));
if (ret < 0)
{
snerr("Pushing humidity data failed\n");
return ret;
}
return OK;
}
#endif
#ifndef CONFIG_BME680_DISABLE_GAS_MEAS
static int bme680_push_gas_data(FAR struct bme680_dev_s *priv,
FAR struct bme680_data_s *data)
{
struct sensor_gas gas_data;
int ret;
struct sensor_lowerhalf_s lower = priv->dev.lower[BME680_GAS_IDX];
gas_data.timestamp = data->timestamp;
gas_data.gas_resistance = data->gas_resistance / 1000.f;
ret = lower.push_event(lower.priv, &gas_data, sizeof(struct sensor_gas));
if (ret < 0)
{
snerr("Pushing gas data failed\n");
return ret;
}
return OK;
}
* Name: calc_heater_res
*
* Description:
* Compute the heater resistance using the target temperature.
*
****************************************************************************/
static uint8_t calc_heater_res(FAR const struct bme680_dev_s *priv)
{
uint8_t res_heat;
int32_t var1;
int32_t var2;
int32_t var3;
int32_t var4;
int32_t var5;
int32_t res_heat_x100;
int16_t temp;
int16_t amb_temp;
struct bme680_sensor_s dev = priv->dev;
temp = dev.config.target_temp;
if (temp > 400)
{
temp = 400;
}
amb_temp = dev.config.amb_temp;
var1 = (((int32_t)amb_temp * dev.calib.gh3) / 10) * 256;
var2 = (dev.calib.gh1 + 784) * (((((dev.calib.gh2 + 154009)
* temp * 5) / 100) + 3276800) / 10);
var3 = var1 + (var2 / 2);
var4 = (var3 / (dev.calib.res_heat_range + 4));
var5 = (131 * dev.calib.res_heat_val) + 65536;
res_heat_x100 = (int32_t)(((var4 / var5) - 250) * 34);
res_heat = (uint8_t)((res_heat_x100 + 50) / 100);
return res_heat;
}
* Name: calc_heater_dur
*
* Description:
* Compute the heater duration to be written to heat_dur register.
*
****************************************************************************/
static uint8_t calc_heater_dur(FAR const struct bme680_dev_s *priv)
{
uint16_t heat_dur = priv->dev.config.heater_duration;
uint8_t gas_wait_val;
uint8_t factor;
if (heat_dur > 0xfc0)
{
heat_dur = 0xfc0;
}
factor = 0;
while (heat_dur > 0x3f)
{
heat_dur = heat_dur / 4;
factor++;
}
gas_wait_val = (factor << 6) | heat_dur;
return gas_wait_val;
}
static int bme680_set_gas_config(FAR struct bme680_dev_s *priv)
{
int ret;
uint8_t heat_res;
uint8_t heat_dur;
uint8_t run_gas;
uint8_t regval;
uint8_t nb_conv = priv->dev.config.nb_conv;
heat_res = calc_heater_res(priv);
ret = bme680_putreg8(priv, (BME680_RES_HEAT_ADDR + nb_conv), heat_res);
if (ret < 0)
{
return ret;
}
heat_dur = calc_heater_dur(priv);
ret = bme680_putreg8(priv, (BME680_GAS_WAIT_ADDR + nb_conv), heat_dur);
if (ret < 0)
{
return ret;
}
run_gas = priv->dev.config.target_temp ? 1 : 0;
regval = (run_gas << 4) | nb_conv;
ret = bme680_putreg8(priv, BME680_CTRL_GAS1, regval);
if (ret < 0)
{
return ret;
}
return OK;
}
#endif
* Name: bme680_write_config
*
* Description:
* Write the configuration of the sensor into its registers
* (oversampling, heater temp, heater duration, etc).
*
****************************************************************************/
static int bme680_write_config(FAR struct bme680_dev_s *priv)
{
int ret;
#ifdef CONFIG_BME680_ENABLE_IIR_FILTER
uint8_t regval;
#endif
nxmutex_lock(&priv->dev_lock);
ret = bme680_set_mode(priv, BME680_SLEEP_MODE);
if (ret < 0)
{
goto err_out;
}
ret = bme680_set_oversamp(priv);
if (ret < 0)
{
goto err_out;
}
#ifdef CONFIG_BME680_ENABLE_IIR_FILTER
regval = priv->dev.config.filter_coef << 2;
ret = bme680_putreg8(priv, BME680_CONFIG_REG_ADDR, regval);
if (ret < 0)
{
goto err_out;
}
#endif
#ifndef CONFIG_BME680_DISABLE_GAS_MEAS
ret = bme680_set_gas_config(priv);
if (ret < 0)
{
goto err_out;
}
#endif
nxmutex_unlock(&priv->dev_lock);
return OK;
err_out:
snerr("Failed to calibrate sensor.\n");
nxmutex_unlock(&priv->dev_lock);
return ret;
}
static float bme680_comp_temp(FAR struct bme680_dev_s *priv,
uint32_t adc_temp)
{
float var1 = 0.0f;
float var2 = 0.0f;
float calc_temp = 0.0f;
struct bme680_sensor_s dev = priv->dev;
var1 = ((((float)adc_temp / 16384.0f) - ((float)dev.calib.t1 / 1024.0f))
* ((float)dev.calib.t2));
var2 = (((((float)adc_temp / 131072.0f) - ((float)dev.calib.t1 / 8192.0f))
* (((float)adc_temp / 131072.0f) - ((float)dev.calib.t1 / 8192.0f)))
* ((float)dev.calib.t3 * 16.0f));
priv->dev.calib.t_fine = (var1 + var2);
calc_temp = (priv->dev.calib.t_fine) / 5120.0f;
return calc_temp;
}
#ifndef CONFIG_BME680_DISABLE_PRESS_MEAS
static float bme680_comp_press(FAR struct bme680_dev_s *priv,
uint32_t adc_press)
{
float var1 = 0.0f;
float var2 = 0.0f;
float var3 = 0.0f;
float calc_pres = 0.0f;
struct bme680_sensor_s dev = priv->dev;
var1 = (((float)dev.calib.t_fine / 2.0f) - 64000.0f);
var2 = var1 * var1 * (((float)dev.calib.p6) / (131072.0f));
var2 = var2 + (var1 * ((float)dev.calib.p5) * 2.0f);
var2 = (var2 / 4.0f) + (((float)dev.calib.p4) * 65536.0f);
var1 = (((((float)dev.calib.p3 * var1 * var1) / 16384.0f)
+ ((float)dev.calib.p2 * var1)) / 524288.0f);
var1 = ((1.0f + (var1 / 32768.0f)) * ((float)dev.calib.p1));
calc_pres = (1048576.0f - ((float)adc_press));
if ((int)var1 != 0)
{
calc_pres = (((calc_pres - (var2 / 4096.0f)) * 6250.0f) / var1);
var1 = (((float)dev.calib.p9) * calc_pres * calc_pres) / 2147483648.0f;
var2 = calc_pres * (((float)dev.calib.p8) / 32768.0f);
var3 = ((calc_pres / 256.0f) * (calc_pres / 256.0f)
* (calc_pres / 256.0f) * (dev.calib.p10 / 131072.0f));
calc_pres = (calc_pres + (var1 + var2 + var3
+ ((float)dev.calib.p7 * 128.0f)) / 16.0f);
}
return calc_pres;
}
#endif
#ifndef CONFIG_BME680_DISABLE_HUM_MEAS
static float bme680_comp_hum(FAR struct bme680_dev_s *priv,
uint16_t adc_hum)
{
float calc_hum = 0.0f;
float var1 = 0.0f;
float var2 = 0.0f;
float var3 = 0.0f;
float var4 = 0.0f;
float temp_comp;
struct bme680_sensor_s dev = priv->dev;
temp_comp = ((dev.calib.t_fine) / 5120.0f);
var1 = (float)((float)adc_hum) - (((float)dev.calib.h1 * 16.0f)
+ (((float)dev.calib.h3 / 2.0f) * temp_comp));
var2 = var1 * ((float)(((float)dev.calib.h2 / 262144.0f)
* (1.0f + (((float)dev.calib.h4 / 16384.0f) * temp_comp)
+ (((float)dev.calib.h5 / 1048576.0f) * temp_comp * temp_comp))));
var3 = (float)dev.calib.h6 / 16384.0f;
var4 = (float)dev.calib.h7 / 2097152.0f;
calc_hum = var2 + ((var3 + (var4 * temp_comp)) * var2 * var2);
if (calc_hum > 100.0f)
{
calc_hum = 100.0f;
}
else if (calc_hum < 0.0f)
{
calc_hum = 0.0f;
}
return calc_hum;
}
#endif
#ifndef CONFIG_BME680_DISABLE_GAS_MEAS
static float bme680_calc_gas_res(FAR struct bme680_dev_s *priv,
uint16_t adc_gas_res, uint8_t gas_range)
{
float calc_gas_res;
float var1 = 0.0f;
struct bme680_sensor_s dev = priv->dev;
var1 = (1340.0f + (5.0f * dev.calib.range_sw_err))
* const_array1[gas_range];
calc_gas_res = var1 * const_array2[gas_range]
/ (adc_gas_res - 512.0f + var1);
return calc_gas_res;
}
#endif
* Name: bme680_read_measurements
*
* Description:
* Reads the raw data from the sensor and computes the compensated
* values, storing them in the data struct.
*
****************************************************************************/
static int bme680_read_measurements(FAR struct bme680_dev_s *priv,
FAR struct bme680_data_s *data)
{
uint8_t status;
uint32_t adc_temp;
#ifndef CONFIG_BME680_DISABLE_PRESS_MEAS
uint32_t adc_press;
#endif
#ifndef CONFIG_BME680_DISABLE_HUM_MEAS
uint16_t adc_hum;
#endif
#ifndef CONFIG_BME680_DISABLE_GAS_MEAS
uint16_t adc_gas_res;
uint8_t gas_range;
uint8_t gas_valid;
uint8_t heat_stab;
#endif
int ret;
uint8_t data_regs[BME680_DATA_LEN];
ret = bme680_getregs(priv, BME680_DATA_ADDR, data_regs, BME680_DATA_LEN);
if (ret < 0)
{
snerr("Failed to read data registers.\n");
return ret;
}
status = data_regs[0] & BME680_NEW_DATA_MSK;
if (!status)
{
sninfo("No new data\n");
return -ENODATA;
}
adc_temp = (uint32_t)(((uint32_t)data_regs[5] << 12)
| ((uint32_t)data_regs[6] << 4)
| ((uint32_t)data_regs[7] >> 4));
data->temperature = bme680_comp_temp(priv, adc_temp);
#ifndef CONFIG_BME680_DISABLE_PRESS_MEAS
adc_press = (uint32_t)(((uint32_t)data_regs[2] << 12)
| ((uint32_t)data_regs[3] << 4)
| ((uint32_t)data_regs[4] >> 4));
data->pressure = bme680_comp_press(priv, adc_press);
#endif
#ifndef CONFIG_BME680_DISABLE_HUM_MEAS
adc_hum = (uint16_t)(((uint32_t)data_regs[8] << 8)
| (uint32_t)data_regs[9]);
data->humidity = bme680_comp_hum(priv, adc_hum);
#endif
#ifndef CONFIG_BME680_DISABLE_GAS_MEAS
adc_gas_res = (uint16_t)((uint32_t)data_regs[13] << 2
| (((uint32_t)data_regs[14]) >> 6));
gas_range = data_regs[14] & BME680_GAS_RANGE_MSK;
gas_valid = data_regs[14] & BME680_GASM_VALID_MSK;
if (!gas_valid)
{
sninfo("Invalid gas measurement.\n");
return -1;
}
heat_stab = data_regs[14] & BME680_HEAT_STAB_MSK;
if (!heat_stab)
{
sninfo("The heater did not stabilize.\n");
return -1;
}
priv->dev.config.amb_temp = data->temperature;
data->gas_resistance = bme680_calc_gas_res(priv, adc_gas_res, gas_range);
#endif
return OK;
}
* Name: bme680_get_tphg_dur
*
* Description:
* Compute the duration of a tphg cycle in us, taking into consideration
* the settings of the sensor.
*
****************************************************************************/
static uint16_t bme680_get_tphg_dur(FAR struct bme680_dev_s *priv)
{
uint32_t tph_dur;
uint32_t meas_cycles;
uint16_t duration;
uint8_t os_to_meas_cycles[6] =
{
0, 1, 2, 4, 8, 16
};
meas_cycles = os_to_meas_cycles[priv->dev.config.temp_os];
#ifndef CONFIG_BME680_DISABLE_PRESS_MEAS
meas_cycles += os_to_meas_cycles[priv->dev.config.press_os];
#endif
#ifndef CONFIG_BME680_DISABLE_HUM_MEAS
meas_cycles += os_to_meas_cycles[priv->dev.config.hum_os];
#endif
tph_dur = meas_cycles * 1963;
tph_dur += 477 * 4;
#ifndef CONFIG_BME680_DISABLE_GAS_MEAS
tph_dur += 477 * 5;
#endif
tph_dur += 500;
tph_dur /= 1000;
tph_dur += 1;
duration = (uint16_t)tph_dur;
#ifndef CONFIG_BME680_DISABLE_GAS_MEAS
duration += priv->dev.config.heater_duration;
#endif
return duration;
}
static int bme680_activate(FAR struct sensor_lowerhalf_s *lower,
FAR struct file *filep, bool enable)
{
int offset;
FAR struct bme680_sensor_s *dev;
FAR struct bme680_dev_s *priv;
switch (lower->type)
{
case SENSOR_TYPE_AMBIENT_TEMPERATURE:
offset = BME680_TEMP_IDX;
break;
case SENSOR_TYPE_BAROMETER:
offset = BME680_PRESS_IDX;
break;
case SENSOR_TYPE_RELATIVE_HUMIDITY:
offset = BME680_HUM_IDX;
break;
case SENSOR_TYPE_GAS:
offset = BME680_GAS_IDX;
break;
default:
offset = 0;
break;
}
dev = (FAR struct bme680_sensor_s *)
((uintptr_t)lower - offset * sizeof(*lower));
priv = container_of(dev, FAR struct bme680_dev_s, dev);
* multiple times for the bme680 sub-sensors)
*/
if (!priv->enabled && enable)
{
dev->calibrated = false;
priv->enabled = enable;
nxsem_post(&priv->run);
return OK;
}
priv->enabled = enable;
return OK;
}
static int bme680_calibrate(FAR struct sensor_lowerhalf_s *lower,
FAR struct file *filep, unsigned long arg)
{
int offset;
FAR struct bme680_sensor_s *dev;
FAR struct bme680_dev_s *priv;
FAR struct bme680_config_s *calibval = (FAR struct bme680_config_s *)arg;
int ret;
switch (lower->type)
{
case SENSOR_TYPE_AMBIENT_TEMPERATURE:
offset = BME680_TEMP_IDX;
break;
case SENSOR_TYPE_BAROMETER:
offset = BME680_PRESS_IDX;
break;
case SENSOR_TYPE_RELATIVE_HUMIDITY:
offset = BME680_HUM_IDX;
break;
case SENSOR_TYPE_GAS:
offset = BME680_GAS_IDX;
break;
default:
offset = 0;
break;
}
dev = (FAR struct bme680_sensor_s *)
((uintptr_t)lower - offset * sizeof(*lower));
priv = container_of(dev, FAR struct bme680_dev_s, dev);
if (!CHECK_OS_BOUNDS(calibval->temp_os))
{
return -EINVAL;
}
#ifndef CONFIG_BME680_DISABLE_PRESS_MEAS
if (!CHECK_OS_BOUNDS(calibval->press_os))
{
return -EINVAL;
}
#endif
#ifndef CONFIG_BME680_DISABLE_HUM_MEAS
if (!CHECK_OS_BOUNDS(calibval->hum_os))
{
return -EINVAL;
}
#endif
#ifdef CONFIG_BME680_ENABLE_IIR_FILTER
if (calibval->filter_coef < BME680_FILTER_COEF0 ||
calibval->filter_coef > BME680_FILTER_COEF127)
{
return -EINVAL;
}
#endif
#ifndef CONFIG_BME680_DISABLE_GAS_MEAS
if (calibval->target_temp < MIN_HOT_PLATE_TEMP ||
calibval->target_temp > MAX_HOT_PLATE_TEMP)
{
return -EINVAL;
}
if (calibval->nb_conv > 9)
{
return -EINVAL;
}
#endif
memcpy(&priv->dev.config, calibval, sizeof(struct bme680_config_s));
ret = bme680_write_config(priv);
if (ret < 0)
{
snerr("Failed to calibrate sensor.\n");
return ret;
}
priv->dev.calibrated = true;
return ret;
}
static int bme680_control(FAR struct sensor_lowerhalf_s *lower,
FAR struct file *filep,
int cmd, unsigned long arg)
{
FAR struct bme680_sensor_s *dev = container_of(lower,
FAR struct bme680_sensor_s,
lower);
FAR struct bme680_dev_s *priv = container_of(dev,
FAR struct bme680_dev_s,
dev);
int ret;
switch (cmd)
{
case SNIOC_RESET:
{
uint8_t regval = 0xb6;
ret = bme680_putreg8(priv, BME680_RESET_REG_ADDR, regval);
if (ret < 0)
{
return ret;
}
up_mdelay(100);
}
break;
default:
break;
}
return OK;
}
static int bme680_thread(int argc, char **argv)
{
FAR struct bme680_dev_s *priv =
(FAR struct bme680_dev_s *)((uintptr_t)strtoul(argv[1], NULL, 16));
struct bme680_data_s data;
int ret;
while (true)
{
int sensor;
if (!priv->enabled)
{
nxsem_wait(&priv->run);
}
if (!priv->dev.calibrated)
{
sninfo("The sensor is not calibrated!\n");
goto thread_sleep;
}
ret = bme680_set_mode(priv, BME680_FORCED_MODE);
uint16_t cycle_duration = bme680_get_tphg_dur(priv);
up_mdelay(cycle_duration);
ret = bme680_read_measurements(priv, &data);
if (ret < 0)
{
goto thread_sleep;
}
data.timestamp = sensor_get_timestamp();
for (sensor = 0; sensor < BME680_SENSORS_COUNT; sensor++)
{
deliver_data[sensor](priv, &data);
}
thread_sleep:
nxsig_usleep(CONFIG_SENSORS_BME680_POLL_INTERVAL);
}
return OK;
}
* Public Functions
****************************************************************************/
* Name: bme680_register
*
* Description:
* Register the BME680 character device
* @devno - The user-specified device number, starting from 0
* @i2c - An instance of the I2C interface to use to communicate with
* BME680
*
* Return value:
* Zero (OK) on success; a negated errno value on failure
****************************************************************************/
int bme680_register(int devno, FAR struct i2c_master_s *i2c)
{
FAR struct sensor_lowerhalf_s *lower;
FAR struct bme680_dev_s *priv;
FAR char *argv[2];
char arg1[32];
int ret = OK;
int i;
DEBUGASSERT(i2c != NULL);
priv = kmm_zalloc(sizeof(struct bme680_dev_s));
if (priv == NULL)
{
snerr("ERROR: Failed to allocate instance (err = %d)\n", ret);
return -ENOMEM;
}
priv->i2c = i2c;
priv->enabled = false;
nxmutex_init(&priv->dev_lock);
nxsem_init(&priv->run, 0, 0);
ret = bme680_checkid(priv);
if (ret < 0)
{
snerr("ERROR: Wrong device ID!\n");
goto err_init;
}
ret = bme680_get_calib_data(priv);
if (ret < 0)
{
snerr("Failed to read calib data from bme680:%d\n", ret);
goto err_init;
}
#ifndef CONFIG_BME680_DISABLE_PRESS_MEAS
lower = &priv->dev.lower[BME680_PRESS_IDX];
lower->ops = &g_sensor_ops;
lower->type = SENSOR_TYPE_BAROMETER;
ret = sensor_register(lower, devno);
if (ret < 0)
{
snerr("ERROR: Failed to register barometer driver (err = %d)\n",
ret);
goto err_init;
}
#else
lower = &priv->dev.lower[BME680_TEMP_IDX];
lower->ops = &g_sensor_ops;
lower->type = SENSOR_TYPE_AMBIENT_TEMPERATURE;
ret = sensor_register(lower, devno);
if (ret < 0)
{
snerr("ERROR: Failed to register temperature driver (err = %d)\n",
ret);
goto err_init;
}
#endif
#ifndef CONFIG_BME680_DISABLE_HUM_MEAS
lower = &priv->dev.lower[BME680_HUM_IDX];
lower->ops = &g_sensor_ops;
lower->type = SENSOR_TYPE_RELATIVE_HUMIDITY;
ret = sensor_register(lower, devno);
if (ret < 0)
{
snerr("ERROR: Failed to register humidity driver (err = %d)\n",
ret);
goto err_init;
}
#endif
#ifndef CONFIG_BME680_DISABLE_GAS_MEAS
lower = &priv->dev.lower[BME680_GAS_IDX];
lower->ops = &g_sensor_ops;
lower->type = SENSOR_TYPE_GAS;
ret = sensor_register(lower, devno);
if (ret < 0)
{
snerr("ERROR: Failed to register gas driver (err = %d)\n",
ret);
goto err_init;
}
#endif
snprintf(arg1, 16, "%p", priv);
argv[0] = arg1;
argv[1] = NULL;
ret = kthread_create("bme680_thread", SCHED_PRIORITY_DEFAULT,
CONFIG_SENSORS_BME680_THREAD_STACKSIZE,
bme680_thread, argv);
if (ret < 0)
{
snerr("ERROR: Failed to create poll thread (err = %d)\n", ret);
goto err_register;
}
sninfo("BME680 driver loaded successfully!\n");
return OK;
err_register:
for (i = 0; i < BME680_SENSORS_COUNT; i++)
{
sensor_unregister(&priv->dev.lower[i], devno);
}
err_init:
nxsem_destroy(&priv->run);
nxmutex_destroy(&priv->dev_lock);
kmm_free(priv);
return ret;
}
#endif