lis3dh.cpp

Go to the documentation of this file.

#include "lis3dh.h"
#include "esphome/core/hal.h"
#include "esphome/core/log.h"
 
namespace esphome::lis3dh {
 
ESPHOME_LOG_TAG(TAG, "lis3dh");
 
// g per LSB of the left-justified 16-bit sample, indexed by range. The same in every
// operating mode, since the chip leaves the unused low bits at zero.
static const float SCALE_G[] PROGMEM = {0.0625e-3f, 0.125e-3f, 0.25e-3f, 0.75e-3f};
 
static const LogString *mode_to_str(LIS3DHOperatingMode mode) {
  switch (mode) {
    case LIS3DH_MODE_LOW_POWER:
      return LOG_STR("low power (8-bit)");
    case LIS3DH_MODE_NORMAL:
      return LOG_STR("normal (10-bit)");
    default:
      return LOG_STR("high resolution (12-bit)");
  }
}
 
// Output data rate in Hz, indexed by the ODR field minus one.
static const uint16_t RATE_HZ[] PROGMEM = {1, 10, 25, 50, 100, 200, 400, 1620, 1344};
 
void LIS3DHComponent::setup() {
  MotionComponent::setup();
 
  uint8_t who_am_i = 0;
  if (!this->read_byte(LIS3DH_REG_WHO_AM_I, &who_am_i)) {
    this->mark_failed(LOG_STR("Failed to read chip ID - check wiring / address"));
    return;
  }
  if (who_am_i != LIS3DH_WHO_AM_I_VALUE) {
    ESP_LOGE(TAG, "Wrong chip ID: 0x%02X (expected 0x%02X)", who_am_i, LIS3DH_WHO_AM_I_VALUE);
    this->mark_failed(LOG_STR("Wrong chip ID"));
    return;
  }
 
  if (!this->setup_accelerometer_() || !this->setup_temperature_() || !this->setup_interrupt_()) {
    this->mark_failed(LOG_STR("Failed to configure sensor"));
    return;
  }
}
 
bool LIS3DHComponent::setup_accelerometer_() {
  // CTRL_REG1: output data rate, low-power flag and axis enable.
  uint8_t ctrl_reg1 = ((uint8_t) this->data_rate_ << 4) | LIS3DH_CTRL_REG1_AXES_EN;
  if (this->operating_mode_ == LIS3DH_MODE_LOW_POWER)
    ctrl_reg1 |= LIS3DH_CTRL_REG1_LPEN;
  if (!this->write_byte(LIS3DH_REG_CTRL_REG1, ctrl_reg1))
    return false;
 
  // CTRL_REG4: block data update, full-scale range and high-resolution flag.
  uint8_t ctrl_reg4 = LIS3DH_CTRL_REG4_BDU | ((uint8_t) this->range_ << 4);
  if (this->operating_mode_ == LIS3DH_MODE_HIGH_RESOLUTION)
    ctrl_reg4 |= LIS3DH_CTRL_REG4_HR;
  return this->write_byte(LIS3DH_REG_CTRL_REG4, ctrl_reg4);
}
 
bool LIS3DHComponent::setup_temperature_() {
  // Only power the ADC / temperature sensor when a temperature sensor is used.
  uint8_t temp_cfg =
      this->temperature_callback_.empty() ? 0x00 : (uint8_t) (LIS3DH_TEMP_CFG_ADC_EN | LIS3DH_TEMP_CFG_TEMP_EN);
  return this->write_byte(LIS3DH_REG_TEMP_CFG, temp_cfg);
}
 
bool LIS3DHComponent::setup_interrupt_() {
  // Runs even with no interrupt configured: the chip usually stays powered across resets,
  // so this drops whatever the previous firmware left in the interrupt registers.
  // High-pass filter the interrupt (IA1) input so the ~1 g of gravity is removed
  // from the threshold comparison. The output data registers stay unfiltered
  // (FDS = 0), so acceleration / pitch / roll still report the full gravity vector.
  uint8_t ctrl_reg2 = this->interrupt_high_pass_ ? LIS3DH_CTRL_REG2_HP_IA1 : 0x00;
  if (!this->write_byte(LIS3DH_REG_CTRL_REG2, ctrl_reg2))
    return false;
 
  if (!this->write_byte(LIS3DH_REG_INT1_CFG, this->interrupt_axes_cfg_) ||
      !this->write_byte(LIS3DH_REG_INT1_THS, this->interrupt_threshold_) ||
      !this->write_byte(LIS3DH_REG_INT1_DURATION, this->interrupt_duration_))
    return false;
 
  // Latch the request so a brief movement keeps the pad asserted until INT1_SRC is read.
  uint8_t ctrl_reg5 = this->interrupt_latched_ ? LIS3DH_CTRL_REG5_LIR_INT1 : 0;
  if (!this->write_byte(LIS3DH_REG_CTRL_REG5, ctrl_reg5))
    return false;
 
  // Route the IA1 engine to the chosen physical pad and set the pad polarity.
  uint8_t ctrl_reg3 = 0;
  uint8_t ctrl_reg6 = this->interrupt_active_high_ ? 0 : LIS3DH_CTRL_REG6_INT_POLARITY;
  if (this->interrupt_axes_cfg_ != 0) {
    if (this->interrupt_pin_ == LIS3DH_INT_PIN_INT1) {
      ctrl_reg3 |= LIS3DH_CTRL_REG3_I1_IA1;
    } else {
      ctrl_reg6 |= LIS3DH_CTRL_REG6_I2_IA1;
    }
  }
  if (!this->write_byte(LIS3DH_REG_CTRL_REG3, ctrl_reg3) || !this->write_byte(LIS3DH_REG_CTRL_REG6, ctrl_reg6))
    return false;
  if (this->interrupt_axes_cfg_ == 0)
    return true;
 
  // With the high-pass filter enabled, reading REFERENCE captures the current
  // acceleration as the filter's zero point (removing the standing gravity bias).
  if (this->interrupt_high_pass_) {
    uint8_t reference = 0;
    this->read_byte(LIS3DH_REG_REFERENCE, &reference);
  }
 
  // Clear any latched request left over from the motion that woke the device.
  uint8_t src = 0;
  this->read_byte(LIS3DH_REG_INT1_SRC, &src);
  return true;
}
 
void LIS3DHComponent::dump_config() {
  ESP_LOGCONFIG(TAG, "LIS3DH:");
  LOG_I2C_DEVICE(this);
  if (this->is_failed())
    return;
 
  ESP_LOGCONFIG(TAG,
                "  Range: ±%ug\n"
                "  Operating mode: %s\n"
                "  Data rate: %uHz",
                2u << this->range_, LOG_STR_ARG(mode_to_str(this->operating_mode_)),
                (unsigned) progmem_read_uint16(&RATE_HZ[this->data_rate_ - 1]));
  if (this->interrupt_axes_cfg_ != 0) {
    ESP_LOGCONFIG(TAG,
                  "  Motion interrupt: %s (%s%s%s)\n"
                  "    Threshold: %u steps\n"
                  "    Duration: %u samples",
                  this->interrupt_pin_ == LIS3DH_INT_PIN_INT1 ? LOG_STR_LITERAL("INT1") : LOG_STR_LITERAL("INT2"),
                  this->interrupt_active_high_ ? LOG_STR_LITERAL("active high") : LOG_STR_LITERAL("active low"),
                  this->interrupt_high_pass_ ? LOG_STR_LITERAL(", high-pass") : LOG_STR_LITERAL(""),
                  this->interrupt_latched_ ? LOG_STR_LITERAL(", latched") : LOG_STR_LITERAL(""),
                  this->interrupt_threshold_, this->interrupt_duration_);
  }
  MotionComponent::dump_config();
}
 
void LIS3DHComponent::on_shutdown() {
  // Clear a latched request from motion seen while awake, so it does not wake the device straight away.
  if (this->interrupt_latched_ && this->interrupt_axes_cfg_ != 0 && !this->is_failed()) {
    uint8_t src = 0;
    this->read_byte(LIS3DH_REG_INT1_SRC, &src);
  }
}
 
bool LIS3DHComponent::update_data(motion::MotionData &data) {
  if (this->is_failed())
    return false;
 
  uint8_t raw[6];
  if (!this->read_bytes(LIS3DH_REG_OUT_X_L | LIS3DH_AUTO_INCREMENT, raw, 6)) {
    this->status_set_warning(LOG_STR("Failed to read acceleration data"));
    return false;
  }
 
  float scale;
  progmem_memcpy(&scale, &SCALE_G[this->range_], sizeof(scale));
 
  // Data is little-endian and left-justified in a signed 16-bit register.
  int16_t raw_x = (int16_t) encode_uint16(raw[1], raw[0]);
  int16_t raw_y = (int16_t) encode_uint16(raw[3], raw[2]);
  int16_t raw_z = (int16_t) encode_uint16(raw[5], raw[4]);
  ESP_LOGV(TAG, "Read raw accel data: %d, %d, %d", raw_x, raw_y, raw_z);
  data.acceleration[motion::X_AXIS] = raw_x * scale;
  data.acceleration[motion::Y_AXIS] = raw_y * scale;
  data.acceleration[motion::Z_AXIS] = raw_z * scale;
 
  if (this->temperature_callback_.empty() || this->publish_temperature_())
    this->status_clear_warning();
  return true;
}
 
bool LIS3DHComponent::publish_temperature_() {
  uint8_t raw[2];
  if (!this->read_bytes(LIS3DH_REG_OUT_ADC3_L | LIS3DH_AUTO_INCREMENT, raw, 2)) {
    this->status_set_warning(LOG_STR("Failed to read temperature data"));
    return false;
  }
  // Signed, left-justified, relative value with 1 °C per count of the high byte; the
  // low byte carries the fractional bits in the modes that have them.
  float temperature = (int16_t) encode_uint16(raw[1], raw[0]) / 256.0f + LIS3DH_TEMP_REFERENCE_C;
  this->temperature_callback_.call(temperature);
  return true;
}
 
}  // namespace esphome::lis3dh