bmi270.cpp

Go to the documentation of this file.

#include "bmi270.h"
#include "bmi270_config.h"
#include "esphome/core/log.h"
#include "esphome/core/hal.h"
#include "esphome/core/progmem.h"
 
namespace esphome::bmi270 {
 
#ifdef USE_BMI270_BMM150
using namespace bmm150;  // NOLINT - sole consumer of the BMM150 aux-device definitions
#endif
 
ESPHOME_LOG_TAG(TAG, "bmi270");
 
PROGMEM_STRING_TABLE(AccelRangeStrings, "±2g", "±4g", "±8g", "±16g");
PROGMEM_STRING_TABLE(GyroRangeStrings, "±2000°/s", "±1000°/s", "±500°/s", "±250°/s", "±125°/s");
 
#if defined(USE_ARDUINO) && !defined(USE_ESP32)
static constexpr size_t MAX_I2C_BUFFER_SIZE = 32;
#else
static constexpr size_t MAX_I2C_BUFFER_SIZE = 256;
#endif
 
//  Configuration blob upload
// The BMI270 requires a firmware config blob to be written to its internal
// memory after every power-on before sensors can be used.
 
bool BMI270Component::load_config_file_() {
  // 1. Disable advanced power-save so the config port is accessible
  if (!this->write_byte(BMI270_REG_PWR_CONF, BMI270_PWR_CONF_ADV_POWER_SAVE_OFF))
    return false;
  delay(1);
 
  // 2. Prepare config load: write 0x00 to INIT_CTRL to start
  if (!this->write_byte(BMI270_REG_INIT_CTRL, BMI270_INIT_CTRL_LOAD_START))
    return false;
 
  // 3. Burst-write the config in pages
  const uint8_t *cfg = BMI270_CONFIG_FILE;
  constexpr size_t cfg_len = sizeof(BMI270_CONFIG_FILE);
  size_t index = 0;
 
  while (index != cfg_len) {
    // Set the page address in INIT_ADDR registers
    uint8_t addr_lsb = (uint8_t) ((index / 2) & 0x0F);
    uint8_t addr_msb = (uint8_t) ((index / 2) >> 4);
    if (!this->write_byte(BMI270_REG_INIT_ADDR_0, addr_lsb))
      return false;
    if (!this->write_byte(BMI270_REG_INIT_ADDR_0 + 1, addr_msb))
      return false;
 
    // Write a burst of up to the maximum allowed size
    size_t burst = clamp_at_most(cfg_len - index, MAX_I2C_BUFFER_SIZE);
    if (this->write_register(BMI270_REG_INIT_DATA, cfg + index, burst) != i2c::ERROR_OK)
      return false;
 
    index += burst;
  }
 
  // 4. Signal end of config load
  if (!this->write_byte(BMI270_REG_INIT_CTRL, BMI270_INIT_CTRL_LOAD_DONE))
    return false;
  delay(20);  // spec: wait ≥20 ms for init to complete
 
  // 5. Check INTERNAL_STATUS: bit[0:3] should be 0x01 ("initialisation OK")
  uint8_t status = 0;
  if (!this->read_byte(BMI270_REG_INTERNAL_STATUS, &status))
    return false;
  if ((status & BMI270_INTERNAL_STATUS_MASK) != BMI270_INTERNAL_STATUS_INIT_OK) {
    ESP_LOGE(TAG, "Config load failed: INTERNAL_STATUS=0x%02X (expected 0x01)", status);
    return false;
  }
  return true;
}
 
//  setup() ─
 
void BMI270Component::setup() {
  MotionComponent::setup();
  // 1. Verify chip ID
  uint8_t chip_id = 0;
  if (!this->read_byte(BMI270_REG_CHIP_ID, &chip_id)) {
    this->mark_failed(LOG_STR(ESP_LOG_MSG_COMM_FAIL));
    return;
  }
  if (chip_id != BMI270_CHIP_ID_VALUE) {
    ESP_LOGE(TAG, "Wrong chip ID: 0x%02X (expected 0x%02X)", chip_id, BMI270_CHIP_ID_VALUE);
    this->mark_failed(LOG_STR("Wrong chip ID"));
    return;
  }
  ESP_LOGD(TAG, "Chip ID: 0x%02X", chip_id);
 
  // 2. Soft-reset via CMD register (0x7E = 0xB6)
  if (!this->write_byte(BMI270_REG_CMD, BMI270_CMD_SOFT_RESET)) {
    this->mark_failed(LOG_STR(ESP_LOG_MSG_COMM_FAIL));
    return;
  }
  delay(20);
 
  // 4. Upload the configuration blob
  if (!load_config_file_()) {
    this->mark_failed(LOG_STR("Config file upload failed"));
    return;
  }
  ESP_LOGD(TAG, "Config blob uploaded ✓");
 
  // 5. Configure accelerometer
  // ACC_CONF: ODR | BWP(0x2 = normal avg4) | perf_mode(1)
  uint8_t acc_conf =
      (uint8_t) (accel_odr_) | (BMI270_CONF_BWP_NORMAL << BMI270_CONF_BWP_SHIFT) | BMI270_ACC_CONF_PERF_MODE;
  if (!this->write_byte(BMI270_REG_ACC_CONF, acc_conf)) {
    this->mark_failed(LOG_STR(ESP_LOG_MSG_COMM_FAIL));
    return;
  }
  if (!this->write_byte(BMI270_REG_ACC_RANGE, (uint8_t) accel_range_)) {
    this->mark_failed(LOG_STR(ESP_LOG_MSG_COMM_FAIL));
    return;
  }
 
  // 6. Configure gyroscope
  // GYR_CONF: ODR | BWP(0x2 = normal) | noise_perf(1) | filter_perf(1)
  uint8_t gyr_conf = (uint8_t) (gyro_odr_) | (BMI270_CONF_BWP_NORMAL << BMI270_CONF_BWP_SHIFT) |
                     BMI270_GYR_CONF_NOISE_PERF | BMI270_GYR_CONF_FILTER_PERF;
  if (!this->write_byte(BMI270_REG_GYR_CONF, gyr_conf)) {
    this->mark_failed(LOG_STR(ESP_LOG_MSG_COMM_FAIL));
    return;
  }
  if (!this->write_byte(BMI270_REG_GYR_RANGE, (uint8_t) gyro_range_)) {
    this->mark_failed(LOG_STR(ESP_LOG_MSG_COMM_FAIL));
    return;
  }
 
  // 7. Enable accelerometer, gyroscope, and temperature sensor
  //    PWR_CTRL bits: temp_en[3] | gyr_en[2] | acc_en[1]
  if (!this->write_byte(BMI270_REG_PWR_CTRL, BMI270_PWR_CTRL_IMU)) {
    this->mark_failed(LOG_STR(ESP_LOG_MSG_COMM_FAIL));
    return;
  }
  delay(5);
 
  // 8. Re-enable advanced power save (optional; keeps current low between reads)
  // Disabled here for simplicity – leave in performance mode
  if (!this->write_byte(BMI270_REG_PWR_CONF, BMI270_PWR_CONF_FIFO_SELF_WAKEUP)) {  // bit1 = fifo_self_wakeup
    this->mark_failed(LOG_STR(ESP_LOG_MSG_COMM_FAIL));
    return;
  }
 
  // 9. Optionally bring up whatever is wired to the aux interface.
  // This is entirely additive: it is off by default, and failure only disables
  // magnetometer reporting rather than the whole component.
#ifdef USE_BMI270_BMM150
  if (this->aux_device_ == BMI270_AUX_DEVICE_BMM150) {
    this->magnetometer_ready_ = this->setup_magnetometer_();
    if (!this->magnetometer_ready_) {
      ESP_LOGW(TAG, "BMM150 magnetometer setup failed; continuing without it");
    }
  }
#endif
 
  ESP_LOGCONFIG(TAG, "BMI270 initialised successfully");
}
 
#ifdef USE_BMI270_BMM150
bool BMI270Component::wait_for_aux_idle_(uint32_t timeout_ms) {
  // The STATUS aux-busy bit is set while an aux transaction is in flight. Aux transaction
  // duration depends on the attached device's own timing, so poll with a bounded
  // timeout instead of guessing a fixed delay.
  uint32_t start = millis();
  while (true) {
    uint8_t status = 0;
    if (!this->read_byte(BMI270_REG_STATUS, &status))
      return false;
    if ((status & BMI270_STATUS_AUX_BUSY) == 0)
      return true;
    if (millis() - start >= timeout_ms)
      return false;
    delay(1);
  }
}
 
bool BMI270Component::write_aux_register_(uint8_t reg, uint8_t value) {
  if (!this->write_byte(BMI270_REG_AUX_WR_DATA, value))
    return false;
  if (!this->write_byte(BMI270_REG_AUX_WR_ADDR, reg))
    return false;
  return this->wait_for_aux_idle_(20);
}
 
bool BMI270Component::read_aux_block_(uint8_t reg, uint8_t *buf) {
  if (!this->write_byte(BMI270_REG_AUX_RD_ADDR, reg))
    return false;
  if (!this->wait_for_aux_idle_(20))
    return false;
  return this->read_bytes(BMI270_REG_AUX_X_LSB, buf, BMI270_AUX_DATA_LEN);
}
 
bool BMI270Component::read_magnetometer_trim_() {
  uint8_t regs[BMM150_TRIM_BLOCKS * BMM150_TRIM_BLOCK_LEN];
  for (uint8_t i = 0; i < BMM150_TRIM_BLOCKS; i++) {
    if (!this->read_aux_block_(BMM150_REG_TRIM_START + i * BMM150_TRIM_BLOCK_LEN, regs + i * BMM150_TRIM_BLOCK_LEN))
      return false;
  }
  this->mag_trim_ = bmm150_parse_trim(regs);
  return true;
}
 
bool BMI270Component::setup_magnetometer_() {
  // Sequence adapted from the Bosch BMI270 aux-interface protocol: enable the secondary
  // I2C master in manual mode, point it at the BMM150's address, power the BMM150 up
  // and soft-reset it, verify its chip ID, read its factory trim values, put it in
  // normal/30Hz mode, then switch the aux interface to auto-burst mode so BMI270 keeps
  // AUX_X/Y/Z/R refreshed from the BMM150's data registers.
  ESP_LOGD(TAG, "Setting up BMM150 magnetometer via BMI270 aux interface...");
 
  if (!this->write_byte(BMI270_REG_IF_CONF, BMI270_IF_CONF_AUX_IF_EN))
    return false;
  if (!this->write_byte(BMI270_REG_AUX_IF_CONF, BMI270_AUX_IF_CONF_MANUAL_EN | BMI270_AUX_IF_CONF_MAN_RD_BURST_8))
    return false;
  if (!this->write_byte(BMI270_REG_AUX_DEV_ID, (uint8_t) (this->aux_device_address_ << 1)))
    return false;
 
  // Suspend -> sleep, then a soft reset so the BMM150 starts from a known state even if it
  // stayed powered across a restart. The chip ID is only readable once the power bit is set.
  if (!this->write_aux_register_(BMM150_REG_POWER_CONTROL, BMM150_CMD_POWER_ON)) {
    ESP_LOGW(TAG, "BMM150 power-on write timed out");
    return false;
  }
  delay(BMM150_START_UP_TIME_MS);
  if (!this->write_aux_register_(BMM150_REG_POWER_CONTROL, BMM150_CMD_SOFT_RESET)) {
    ESP_LOGW(TAG, "BMM150 soft-reset write timed out");
    return false;
  }
  delay(BMM150_SOFT_RESET_TIME_MS);
 
  uint8_t chip_id[BMI270_AUX_DATA_LEN];
  if (!this->read_aux_block_(BMM150_REG_CHIP_ID, chip_id)) {
    ESP_LOGW(TAG, "BMM150 chip-ID read failed");
    return false;
  }
  if (chip_id[0] != BMM150_CHIP_ID_VALUE) {
    ESP_LOGW(TAG, "BMM150 not detected (chip ID 0x%02X, expected 0x%02X)", chip_id[0], BMM150_CHIP_ID_VALUE);
    return false;
  }
 
  if (!this->read_magnetometer_trim_()) {
    ESP_LOGW(TAG, "BMM150 trim data read failed");
    return false;
  }
 
  if (!this->write_aux_register_(BMM150_REG_OP_MODE, BMM150_CMD_NORMAL_MODE_ODR_30HZ)) {
    ESP_LOGW(TAG, "BMM150 mode write timed out");
    return false;
  }
 
  // Switch to auto-burst mode: BMI270 will keep polling 8 bytes from the BMM150's
  // data registers (0x42) into its own AUX_X/Y/Z/R registers automatically.
  if (!this->write_byte(BMI270_REG_AUX_IF_CONF, BMI270_AUX_IF_CONF_FCU_WRITE_EN | BMI270_AUX_IF_CONF_MAN_RD_BURST_8 |
                                                    BMI270_AUX_IF_CONF_RD_BURST_8))
    return false;
  if (!this->write_byte(BMI270_REG_AUX_RD_ADDR, BMM150_REG_DATA_X_LSB))
    return false;
  if (!this->write_byte(BMI270_REG_PWR_CTRL, BMI270_PWR_CTRL_IMU | BMI270_PWR_CTRL_AUX_EN))
    return false;
 
  ESP_LOGD(TAG, "BMM150 magnetometer ready");
  return true;
}
#endif  // USE_BMI270_BMM150
 
void BMI270Component::dump_config() {
  ESP_LOGCONFIG(TAG, "BMI270 IMU:");
  LOG_I2C_DEVICE(this);
  if (this->is_failed())
    return;
 
  ESP_LOGCONFIG(TAG, "  Accel range : %s",
                LOG_STR_ARG(AccelRangeStrings::get_log_str(this->accel_range_, AccelRangeStrings::LAST_INDEX)));
  ESP_LOGCONFIG(TAG, "  Gyro  range : %s",
                LOG_STR_ARG(GyroRangeStrings::get_log_str(this->gyro_range_, GyroRangeStrings::LAST_INDEX)));
#ifdef USE_BMI270_BMM150
  if (this->aux_device_ == BMI270_AUX_DEVICE_BMM150) {
    ESP_LOGCONFIG(TAG, "  Aux device  : BMM150 magnetometer (%s)",
                  this->magnetometer_ready_ ? LOG_STR_LITERAL("ready") : LOG_STR_LITERAL("NOT DETECTED"));
  }
#endif
  MotionComponent::dump_config();
}
 
//  update() ─
// Reads all 6 axes + temperature in one block
 
bool BMI270Component::update_data(motion::MotionData &data) {
  if (this->is_failed())
    return false;
 
    //  Accelerometer: registers 0x0C–0x11 (6 bytes: x_lsb, x_msb, y_lsb, y_msb, z_lsb, z_msb)
    // When the magnetometer is active, the 8 aux data bytes (0x04–0x0B) sit directly before
    // the accel data, so one burst read from AUX_X_LSB fetches both.
#ifdef USE_BMI270_BMM150
  const bool read_mag = this->magnetometer_ready_ && !this->magnetometer_callback_.empty();
  uint8_t buf[BMI270_AUX_DATA_LEN + REG_READ_LEN];
  const uint8_t *mag_raw = buf;
  const uint8_t *raw_data = read_mag ? buf + BMI270_AUX_DATA_LEN : buf;
  const bool read_ok = read_mag ? this->read_bytes(BMI270_REG_AUX_X_LSB, buf, sizeof(buf))
                                : this->read_bytes(BMI270_REG_DATA_8, buf, REG_READ_LEN);
#else
  uint8_t buf[REG_READ_LEN];
  const uint8_t *raw_data = buf;
  const bool read_ok = this->read_bytes(BMI270_REG_DATA_8, buf, REG_READ_LEN);
#endif
  if (!read_ok) {
    ESP_LOGW(TAG, "Failed to read IMU data");
    return false;
  }
  // Scale factor: LSB/g depends on range
  // raw is a signed 16-bit value; full-scale = range_g * 2^15 lsb
  // In PROGMEM; each read is a 32-bit load, which is safe from flash on ESP8266
  alignas(4) static constexpr float ACCEL_SCALE[] PROGMEM = {
      2.0f / 32768.0f,
      4.0f / 32768.0f,
      8.0f / 32768.0f,
      16.0f / 32768.0f,
  };
  float scale = ACCEL_SCALE[this->accel_range_];
 
  data.acceleration[motion::X_AXIS] = (int16_t) ((raw_data[1] << 8) | raw_data[0]) * scale;
  data.acceleration[motion::Y_AXIS] = (int16_t) ((raw_data[3] << 8) | raw_data[2]) * scale;
  data.acceleration[motion::Z_AXIS] = (int16_t) ((raw_data[5] << 8) | raw_data[4]) * scale;
 
  // Gyroscope: registers 0x12–0x17 (6 bytes)
  // Scale: full-scale range / 2^15
  alignas(4) static constexpr float GYRO_SCALE[] PROGMEM = {
      2000.0f / 32768.0f, 1000.0f / 32768.0f, 500.0f / 32768.0f, 250.0f / 32768.0f, 125.0f / 32768.0f,
  };
  static constexpr uint8_t GYR_OFFS = BMI270_REG_DATA_14 - BMI270_REG_DATA_8;
  scale = GYRO_SCALE[this->gyro_range_];
 
  data.angular_rate[motion::X_AXIS] = (int16_t) ((raw_data[GYR_OFFS + 1] << 8) | raw_data[GYR_OFFS + 0]) * scale;
  data.angular_rate[motion::Y_AXIS] = (int16_t) ((raw_data[GYR_OFFS + 3] << 8) | raw_data[GYR_OFFS + 2]) * scale;
  data.angular_rate[motion::Z_AXIS] = (int16_t) ((raw_data[GYR_OFFS + 5] << 8) | raw_data[GYR_OFFS + 4]) * scale;
 
  if (!this->temperature_callback_.empty()) {
    //  Temperature: registers 0x22–0x23
    // Formula from datasheet: T[°C] = raw / 512 + 23
    static constexpr uint8_t TEMP_OFFS = BMI270_REG_TEMP_0 - BMI270_REG_DATA_8;
    int16_t raw_t = (int16_t) ((raw_data[TEMP_OFFS + 1] << 8) | raw_data[TEMP_OFFS + 0]);
    float temperature = (raw_t / 512.0f) + 23.0f;
    this->temperature_callback_.call(temperature);
  }
 
#ifdef USE_BMI270_BMM150
  if (read_mag) {
    const BMM150Data mag_data = bmm150_convert(this->mag_trim_, mag_raw);
    this->magnetometer_callback_.call(mag_data);
  }
#endif
  return true;
}
 
}  // namespace esphome::bmi270