| /* bme680.c - Driver for Bosch Sensortec's BME680 temperature, pressure, |
| * humidity and gas sensor |
| * |
| * https://www.bosch-sensortec.com/bst/products/all_products/bme680 |
| */ |
| |
| /* |
| * Copyright (c) 2018 Bosch Sensortec GmbH |
| * |
| * SPDX-License-Identifier: Apache-2.0 |
| */ |
| |
| #include "bme680.h" |
| #include <drivers/gpio.h> |
| #include <drivers/i2c.h> |
| #include <init.h> |
| #include <kernel.h> |
| #include <sys/byteorder.h> |
| #include <sys/__assert.h> |
| #include <drivers/sensor.h> |
| |
| #include <logging/log.h> |
| LOG_MODULE_REGISTER(bme680, CONFIG_SENSOR_LOG_LEVEL); |
| |
| static int bme680_reg_read(struct bme680_data *data, u8_t start, u8_t *buf, |
| int size) |
| { |
| return i2c_burst_read(data->i2c_master, data->i2c_slave_addr, start, |
| buf, size); |
| return 0; |
| } |
| |
| static int bme680_reg_write(struct bme680_data *data, u8_t reg, u8_t val) |
| { |
| return i2c_reg_write_byte(data->i2c_master, data->i2c_slave_addr, |
| reg, val); |
| return 0; |
| } |
| |
| static void bme680_calc_temp(struct bme680_data *data, u32_t adc_temp) |
| { |
| s64_t var1, var2, var3; |
| |
| var1 = ((s32_t)adc_temp >> 3) - ((s32_t)data->par_t1 << 1); |
| var2 = (var1 * (s32_t)data->par_t2) >> 11; |
| var3 = ((var1 >> 1) * (var1 >> 1)) >> 12; |
| var3 = ((var3) * ((s32_t)data->par_t3 << 4)) >> 14; |
| data->t_fine = var2 + var3; |
| data->calc_temp = ((data->t_fine * 5) + 128) >> 8; |
| } |
| |
| static void bme680_calc_press(struct bme680_data *data, u32_t adc_press) |
| { |
| s32_t var1, var2, var3, calc_press; |
| |
| var1 = (((s32_t)data->t_fine) >> 1) - 64000; |
| var2 = ((((var1 >> 2) * (var1 >> 2)) >> 11) * |
| (s32_t)data->par_p6) >> 2; |
| var2 = var2 + ((var1 * (s32_t)data->par_p5) << 1); |
| var2 = (var2 >> 2) + ((s32_t)data->par_p4 << 16); |
| var1 = (((((var1 >> 2) * (var1 >> 2)) >> 13) * |
| ((s32_t)data->par_p3 << 5)) >> 3) |
| + (((s32_t)data->par_p2 * var1) >> 1); |
| var1 = var1 >> 18; |
| var1 = ((32768 + var1) * (s32_t)data->par_p1) >> 15; |
| calc_press = 1048576 - adc_press; |
| calc_press = (calc_press - (var2 >> 12)) * ((u32_t)3125); |
| /* This max value is used to provide precedence to multiplication or |
| * division in the pressure calculation equation to achieve least |
| * loss of precision and avoiding overflows. |
| * i.e Comparing value, signed int 32bit (1 << 30) |
| */ |
| if (calc_press >= (s32_t)0x40000000) { |
| calc_press = ((calc_press / var1) << 1); |
| } else { |
| calc_press = ((calc_press << 1) / var1); |
| } |
| var1 = ((s32_t)data->par_p9 * |
| (s32_t)(((calc_press >> 3) |
| * (calc_press >> 3)) >> 13)) >> 12; |
| var2 = ((s32_t)(calc_press >> 2) * (s32_t)data->par_p8) >> 13; |
| var3 = ((s32_t)(calc_press >> 8) * (s32_t)(calc_press >> 8) |
| * (s32_t)(calc_press >> 8) |
| * (s32_t)data->par_p10) >> 17; |
| |
| data->calc_press = calc_press |
| + ((var1 + var2 + var3 |
| + ((s32_t)data->par_p7 << 7)) >> 4); |
| } |
| |
| static void bme680_calc_humidity(struct bme680_data *data, u16_t adc_humidity) |
| { |
| s32_t var1, var2_1, var2_2, var2, var3, var4, var5, var6; |
| s32_t temp_scaled, calc_hum; |
| |
| temp_scaled = (((s32_t)data->t_fine * 5) + 128) >> 8; |
| var1 = (s32_t)(adc_humidity - ((s32_t)((s32_t)data->par_h1 * 16))) - |
| (((temp_scaled * (s32_t)data->par_h3) |
| / ((s32_t)100)) >> 1); |
| var2_1 = (s32_t)data->par_h2; |
| var2_2 = ((temp_scaled * (s32_t)data->par_h4) / (s32_t)100) |
| + (((temp_scaled * ((temp_scaled * (s32_t)data->par_h5) |
| / ((s32_t)100))) >> 6) / ((s32_t)100)) |
| + (s32_t)(1 << 14); |
| var2 = (var2_1 * var2_2) >> 10; |
| var3 = var1 * var2; |
| var4 = (s32_t)data->par_h6 << 7; |
| var4 = ((var4) + ((temp_scaled * (s32_t)data->par_h7) / |
| ((s32_t)100))) >> 4; |
| var5 = ((var3 >> 14) * (var3 >> 14)) >> 10; |
| var6 = (var4 * var5) >> 1; |
| calc_hum = (((var3 + var6) >> 10) * ((s32_t)1000)) >> 12; |
| |
| if (calc_hum > 100000) { /* Cap at 100%rH */ |
| calc_hum = 100000; |
| } else if (calc_hum < 0) { |
| calc_hum = 0; |
| } |
| |
| data->calc_humidity = calc_hum; |
| } |
| |
| static void bme680_calc_gas_resistance(struct bme680_data *data, u8_t gas_range, |
| u16_t adc_gas_res) |
| { |
| s64_t var1, var3; |
| u64_t var2; |
| |
| static const u32_t look_up1[16] = { 2147483647, 2147483647, 2147483647, |
| 2147483647, 2147483647, 2126008810, 2147483647, |
| 2130303777, 2147483647, 2147483647, 2143188679, |
| 2136746228, 2147483647, 2126008810, 2147483647, |
| 2147483647 }; |
| |
| static const u32_t look_up2[16] = { 4096000000, 2048000000, 1024000000, |
| 512000000, 255744255, 127110228, 64000000, |
| 32258064, 16016016, 8000000, 4000000, 2000000, |
| 1000000, 500000, 250000, 125000 }; |
| |
| var1 = (s64_t)((1340 + (5 * (s64_t)data->range_sw_err)) * |
| ((s64_t)look_up1[gas_range])) >> 16; |
| var2 = (((s64_t)((s64_t)adc_gas_res << 15) - (s64_t)(16777216)) + var1); |
| var3 = (((s64_t)look_up2[gas_range] * (s64_t)var1) >> 9); |
| data->calc_gas_resistance = (u32_t)((var3 + ((s64_t)var2 >> 1)) |
| / (s64_t)var2); |
| } |
| |
| static u8_t bme680_calc_res_heat(struct bme680_data *data, u16_t heatr_temp) |
| { |
| u8_t heatr_res; |
| s32_t var1, var2, var3, var4, var5; |
| s32_t heatr_res_x100; |
| s32_t amb_temp = 25; /* Assume ambient temperature to be 25 deg C */ |
| |
| if (heatr_temp > 400) { /* Cap temperature */ |
| heatr_temp = 400; |
| } |
| |
| var1 = ((amb_temp * data->par_gh3) / 1000) * 256; |
| var2 = (data->par_gh1 + 784) * (((((data->par_gh2 + 154009) |
| * heatr_temp * 5) / 100) |
| + 3276800) / 10); |
| var3 = var1 + (var2 / 2); |
| var4 = (var3 / (data->res_heat_range + 4)); |
| var5 = (131 * data->res_heat_val) + 65536; |
| heatr_res_x100 = ((var4 / var5) - 250) * 34; |
| heatr_res = (heatr_res_x100 + 50) / 100; |
| |
| return heatr_res; |
| } |
| |
| static u8_t bme680_calc_gas_wait(u16_t dur) |
| { |
| u8_t factor = 0, durval; |
| |
| if (dur >= 0xfc0) { |
| durval = 0xff; /* Max duration*/ |
| } else { |
| while (dur > 0x3F) { |
| dur = dur / 4; |
| factor += 1; |
| } |
| durval = dur + (factor * 64); |
| } |
| |
| return durval; |
| } |
| |
| static int bme680_sample_fetch(struct device *dev, enum sensor_channel chan) |
| { |
| struct bme680_data *data = dev->driver_data; |
| u8_t buff[BME680_LEN_FIELD] = { 0 }; |
| u8_t gas_range; |
| u32_t adc_temp, adc_press; |
| u16_t adc_hum, adc_gas_res; |
| int size = BME680_LEN_FIELD; |
| int ret; |
| |
| __ASSERT_NO_MSG(chan == SENSOR_CHAN_ALL); |
| |
| ret = bme680_reg_read(data, BME680_REG_FIELD0, buff, size); |
| if (ret < 0) { |
| return ret; |
| } |
| |
| data->new_data = buff[0] & BME680_MSK_NEW_DATA; |
| data->heatr_stab = buff[14] & BME680_MSK_HEATR_STAB; |
| |
| adc_press = (u32_t)(((u32_t)buff[2] << 12) | ((u32_t)buff[3] << 4) |
| | ((u32_t)buff[4] >> 4)); |
| adc_temp = (u32_t)(((u32_t)buff[5] << 12) | ((u32_t)buff[6] << 4) |
| | ((u32_t)buff[7] >> 4)); |
| adc_hum = (u16_t)(((u32_t)buff[8] << 8) | (u32_t)buff[9]); |
| adc_gas_res = (u16_t)((u32_t)buff[13] << 2 | (((u32_t)buff[14]) >> 6)); |
| gas_range = buff[14] & BME680_MSK_GAS_RANGE; |
| |
| if (data->new_data) { |
| bme680_calc_temp(data, adc_temp); |
| bme680_calc_press(data, adc_press); |
| bme680_calc_humidity(data, adc_hum); |
| bme680_calc_gas_resistance(data, gas_range, adc_gas_res); |
| } |
| |
| /* Trigger the next measurement */ |
| ret = bme680_reg_write(data, BME680_REG_CTRL_MEAS, |
| BME680_CTRL_MEAS_VAL); |
| if (ret < 0) { |
| return ret; |
| } |
| |
| return 0; |
| } |
| |
| static int bme680_channel_get(struct device *dev, enum sensor_channel chan, |
| struct sensor_value *val) |
| { |
| struct bme680_data *data = dev->driver_data; |
| |
| switch (chan) { |
| case SENSOR_CHAN_AMBIENT_TEMP: |
| /* |
| * data->calc_temp has a resolution of 0.01 degC. |
| * So 5123 equals 51.23 degC. |
| */ |
| val->val1 = data->calc_temp / 100; |
| val->val2 = data->calc_temp % 100 * 10000; |
| break; |
| case SENSOR_CHAN_PRESS: |
| /* |
| * data->calc_press has a resolution of 1 Pa. |
| * So 96321 equals 96.321 kPa. |
| */ |
| val->val1 = data->calc_press / 1000; |
| val->val2 = (data->calc_press % 1000) * 1000; |
| break; |
| case SENSOR_CHAN_HUMIDITY: |
| /* |
| * data->calc_humidity has a resolution of 0.001 %RH. |
| * So 46333 equals 46.333 %RH. |
| */ |
| val->val1 = data->calc_humidity / 1000; |
| val->val2 = (data->calc_humidity % 1000) * 1000; |
| break; |
| case SENSOR_CHAN_GAS_RES: |
| /* |
| * data->calc_gas_resistance has a resolution of 1 ohm. |
| * So 100000 equals 100000 ohms. |
| */ |
| val->val1 = data->calc_gas_resistance; |
| val->val2 = 0; |
| break; |
| default: |
| return -EINVAL; |
| } |
| |
| return 0; |
| } |
| |
| static int bme680_read_compensation(struct bme680_data *data) |
| { |
| u8_t buff[BME680_LEN_COEFF_ALL]; |
| int err = 0; |
| |
| err = bme680_reg_read(data, BME680_REG_COEFF1, buff, BME680_LEN_COEFF1); |
| if (err < 0) { |
| return err; |
| } |
| |
| err = bme680_reg_read(data, BME680_REG_COEFF2, &buff[BME680_LEN_COEFF1], |
| 16); |
| if (err < 0) { |
| return err; |
| } |
| |
| err = bme680_reg_read(data, BME680_REG_COEFF3, |
| &buff[BME680_LEN_COEFF1 + BME680_LEN_COEFF2], |
| BME680_LEN_COEFF3); |
| if (err < 0) { |
| return err; |
| } |
| |
| /* Temperature related coefficients */ |
| data->par_t1 = (u16_t)(BME680_CONCAT_BYTES(buff[32], buff[31])); |
| data->par_t2 = (s16_t)(BME680_CONCAT_BYTES(buff[1], buff[0])); |
| data->par_t3 = (u8_t)(buff[2]); |
| |
| /* Pressure related coefficients */ |
| data->par_p1 = (u16_t)(BME680_CONCAT_BYTES(buff[5], buff[4])); |
| data->par_p2 = (s16_t)(BME680_CONCAT_BYTES(buff[7], buff[6])); |
| data->par_p3 = (s8_t)buff[8]; |
| data->par_p4 = (s16_t)(BME680_CONCAT_BYTES(buff[11], buff[10])); |
| data->par_p5 = (s16_t)(BME680_CONCAT_BYTES(buff[13], buff[12])); |
| data->par_p6 = (s8_t)(buff[15]); |
| data->par_p7 = (s8_t)(buff[14]); |
| data->par_p8 = (s16_t)(BME680_CONCAT_BYTES(buff[19], buff[18])); |
| data->par_p9 = (s16_t)(BME680_CONCAT_BYTES(buff[21], buff[20])); |
| data->par_p10 = (u8_t)(buff[22]); |
| |
| /* Humidity related coefficients */ |
| data->par_h1 = (u16_t)(((u16_t)buff[25] << 4) | (buff[24] & 0x0f)); |
| data->par_h2 = (u16_t)(((u16_t)buff[23] << 4) | ((buff[24]) >> 4)); |
| data->par_h3 = (s8_t)buff[26]; |
| data->par_h4 = (s8_t)buff[27]; |
| data->par_h5 = (s8_t)buff[28]; |
| data->par_h6 = (u8_t)buff[29]; |
| data->par_h7 = (s8_t)buff[30]; |
| |
| /* Gas heater related coefficients */ |
| data->par_gh1 = (s8_t)buff[35]; |
| data->par_gh2 = (s16_t)(BME680_CONCAT_BYTES(buff[34], buff[33])); |
| data->par_gh3 = (s8_t)buff[36]; |
| |
| data->res_heat_val = (s8_t)buff[37]; |
| data->res_heat_range = ((buff[39] & BME680_MSK_RH_RANGE) >> 4); |
| data->range_sw_err = ((s8_t)(buff[41] & BME680_MSK_RANGE_SW_ERR)) / 16; |
| |
| return 0; |
| } |
| |
| static int bme680_chip_init(struct device *dev) |
| { |
| struct bme680_data *data = (struct bme680_data *)dev->driver_data; |
| int err; |
| |
| err = bme680_reg_read(data, BME680_REG_CHIP_ID, &data->chip_id, 1); |
| if (err < 0) { |
| return err; |
| } |
| |
| if (data->chip_id == BME680_CHIP_ID) { |
| LOG_ERR("BME680 chip detected"); |
| } else { |
| LOG_ERR("Bad BME680 chip id 0x%x", data->chip_id); |
| return -ENOTSUP; |
| } |
| |
| err = bme680_read_compensation(data); |
| if (err < 0) { |
| return err; |
| } |
| |
| err = bme680_reg_write(data, BME680_REG_CTRL_HUM, BME680_HUMIDITY_OVER); |
| if (err < 0) { |
| return err; |
| } |
| |
| err = bme680_reg_write(data, BME680_REG_CONFIG, BME680_CONFIG_VAL); |
| if (err < 0) { |
| return err; |
| } |
| |
| err = bme680_reg_write(data, BME680_REG_CTRL_GAS_1, |
| BME680_CTRL_GAS_1_VAL); |
| if (err < 0) { |
| return err; |
| } |
| |
| err = bme680_reg_write(data, BME680_REG_RES_HEAT0, |
| bme680_calc_res_heat(data, BME680_HEATR_TEMP)); |
| if (err < 0) { |
| return err; |
| } |
| |
| err = bme680_reg_write(data, BME680_REG_GAS_WAIT0, |
| bme680_calc_gas_wait(BME680_HEATR_DUR_MS)); |
| if (err < 0) { |
| return err; |
| } |
| |
| err = bme680_reg_write(data, BME680_REG_CTRL_MEAS, |
| BME680_CTRL_MEAS_VAL); |
| if (err < 0) { |
| return err; |
| } |
| |
| return 0; |
| } |
| |
| static int bme680_init(struct device *dev) |
| { |
| struct bme680_data *data = dev->driver_data; |
| |
| data->i2c_master = device_get_binding( |
| DT_INST_0_BOSCH_BME680_BUS_NAME); |
| if (!data->i2c_master) { |
| LOG_ERR("I2C master not found: %s", |
| DT_INST_0_BOSCH_BME680_BUS_NAME); |
| return -EINVAL; |
| } |
| |
| data->i2c_slave_addr = DT_INST_0_BOSCH_BME680_BASE_ADDRESS; |
| |
| if (bme680_chip_init(dev) < 0) { |
| return -EINVAL; |
| } |
| |
| return 0; |
| } |
| |
| static const struct sensor_driver_api bme680_api_funcs = { |
| .sample_fetch = bme680_sample_fetch, |
| .channel_get = bme680_channel_get, |
| }; |
| |
| static struct bme680_data bme680_data; |
| |
| DEVICE_AND_API_INIT(bme680, DT_INST_0_BOSCH_BME680_LABEL, bme680_init, &bme680_data, |
| NULL, POST_KERNEL, CONFIG_SENSOR_INIT_PRIORITY, |
| &bme680_api_funcs); |