mt6701_i2c.cpp

Go to the documentation of this file.

#include "mt6701_i2c.h"
#include "esphome/core/hal.h"
#include "esphome/core/log.h"
 
namespace esphome::mt6701_i2c {
 
ESPHOME_LOG_TAG(TAG, "mt6701_i2c");
 
// Registers apply_config_() may write, each read-modify-written once
static const uint8_t CONFIG_REGS[] PROGMEM = {
    REG_ABZ_MUX_DIR, REG_RES_H, REG_ABZ_RES_L, REG_CONFIG_H,  REG_ZERO_L,
    REG_HYST_L,      REG_OUT,   REG_A_HIGH,    REG_A_START_L, REG_A_STOP_L,
};
static constexpr uint8_t CONFIG_REG_COUNT = sizeof(CONFIG_REGS);
 
void MT6701I2CComponent::setup() {
  uint16_t count;
  if (!this->read_count(count)) {
    this->mark_failed(LOG_STR("not responding on I2C"));
    return;
  }
  this->apply_config_();
}
 
void MT6701I2CComponent::dump_config() {
  ESP_LOGCONFIG(TAG, "MT6701 (I2C):");
  LOG_I2C_DEVICE(this);
  if (this->is_failed()) {
    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
    return;
  }
  if (this->direction_ != UNSET_U8) {
    ESP_LOGCONFIG(TAG, "  Direction bit: %u", this->direction_);
  }
  if (this->zero_offset_ != UNSET_U16) {
    ESP_LOGCONFIG(TAG, "  Zero offset: %u", this->zero_offset_);
  }
  if (this->hysteresis_ != UNSET_U8) {
    ESP_LOGCONFIG(TAG, "  Hysteresis code: %u", this->hysteresis_);
  }
  if (this->output_mode_ != UNSET_U8) {
    ESP_LOGCONFIG(TAG, "  Output mode: %s", this->output_mode_ != 0 ? LOG_STR_LITERAL("UVW") : LOG_STR_LITERAL("ABZ"));
  }
  if (this->abz_pulses_per_revolution_ != UNSET_U16) {
    ESP_LOGCONFIG(TAG, "  ABZ pulses/rev: %u", this->abz_pulses_per_revolution_);
  }
  if (this->z_pulse_width_ != UNSET_U8) {
    ESP_LOGCONFIG(TAG, "  Z pulse width code: %u", this->z_pulse_width_);
  }
  if (this->uvw_pole_pairs_ != UNSET_U8) {
    ESP_LOGCONFIG(TAG, "  UVW pole pairs: %u", this->uvw_pole_pairs_);
  }
  if (this->out_pin_mode_ != UNSET_U8) {
    ESP_LOGCONFIG(TAG, "  Output pin mode: %s",
                  this->out_pin_mode_ != 0 ? LOG_STR_LITERAL("PWM") : LOG_STR_LITERAL("analog"));
  }
  if (this->pwm_frequency_ != UNSET_U8) {
    ESP_LOGCONFIG(TAG, "  PWM frequency code: %u", this->pwm_frequency_);
  }
  if (this->pwm_polarity_ != UNSET_U8) {
    ESP_LOGCONFIG(TAG, "  PWM polarity code: %u", this->pwm_polarity_);
  }
  if (this->analog_start_ != UNSET_U16) {
    ESP_LOGCONFIG(TAG, "  Analog start: %u", this->analog_start_);
  }
  if (this->analog_stop_ != UNSET_U16) {
    ESP_LOGCONFIG(TAG, "  Analog stop: %u", this->analog_stop_);
  }
}
 
bool MT6701I2CComponent::read_count(uint16_t &count) {
  // Single-byte reads, 0x03 first; datasheet 1.9 documents no burst read
  uint8_t high;
  uint8_t low;
  if (this->read_register(REG_ANGLE_H, &high, 1) != i2c::ERROR_OK ||
      this->read_register(REG_ANGLE_L, &low, 1) != i2c::ERROR_OK)
    return false;
  count = encode_uint16(high, low) >> 2;
  return true;
}
 
bool MT6701I2CComponent::update_register_(uint8_t reg, uint8_t mask, uint8_t value) {
  uint8_t current;
  if (this->read_register(reg, &current, 1) != i2c::ERROR_OK)
    return false;
  uint8_t updated = (current & ~mask) | (value & mask);
  if (updated == current)
    return true;
  return this->write_register(reg, &updated, 1) == i2c::ERROR_OK;
}
 
void MT6701I2CComponent::apply_config_() {
  // Collect the bits per register first; several options share one register
  uint8_t masks[CONFIG_REG_COUNT] = {};
  uint8_t values[CONFIG_REG_COUNT] = {};
  auto add = [&masks, &values](uint8_t reg, uint8_t mask, uint8_t value) {
    for (uint8_t i = 0; i < CONFIG_REG_COUNT; i++) {
      if (progmem_read_byte(&CONFIG_REGS[i]) == reg) {
        masks[i] |= mask;
        values[i] |= value & mask;
        return;
      }
    }
  };
 
  if (this->direction_ != UNSET_U8)
    add(REG_ABZ_MUX_DIR, 0x02, this->direction_ << 1);
  if (this->output_mode_ != UNSET_U8)
    add(REG_ABZ_MUX_DIR, 0x40, (this->output_mode_ & 0x01) << 6);
  if (this->zero_offset_ != UNSET_U16) {
    add(REG_CONFIG_H, 0x0F, this->zero_offset_ >> 8);
    add(REG_ZERO_L, 0xFF, this->zero_offset_ & 0xFF);
  }
  if (this->hysteresis_ != UNSET_U8) {
    add(REG_CONFIG_H, 0x80, (this->hysteresis_ & 0x04) << 5);  // HYST[2] -> bit7
    add(REG_HYST_L, 0xC0, (this->hysteresis_ & 0x03) << 6);    // HYST[1:0] -> bits7:6
  }
  if (this->abz_pulses_per_revolution_ != UNSET_U16) {
    // ABZ_RES holds pulses per revolution minus 1
    uint16_t res = this->abz_pulses_per_revolution_ - 1;
    add(REG_RES_H, 0x03, res >> 8);
    add(REG_ABZ_RES_L, 0xFF, res & 0xFF);
  }
  if (this->z_pulse_width_ != UNSET_U8)
    add(REG_CONFIG_H, 0x70, (this->z_pulse_width_ & 0x07) << 4);
  if (this->uvw_pole_pairs_ != UNSET_U8) {
    // UVW_RES holds pole pairs minus 1
    add(REG_RES_H, 0xF0, (this->uvw_pole_pairs_ - 1) << 4);
  }
  if (this->out_pin_mode_ != UNSET_U8)
    add(REG_OUT, 0x20, (this->out_pin_mode_ & 0x01) << 5);
  if (this->pwm_frequency_ != UNSET_U8)
    add(REG_OUT, 0x80, (this->pwm_frequency_ & 0x01) << 7);
  if (this->pwm_polarity_ != UNSET_U8)
    add(REG_OUT, 0x40, (this->pwm_polarity_ & 0x01) << 6);
  if (this->analog_start_ != UNSET_U16) {
    add(REG_A_HIGH, 0x0F, this->analog_start_ >> 8);
    add(REG_A_START_L, 0xFF, this->analog_start_ & 0xFF);
  }
  if (this->analog_stop_ != UNSET_U16) {
    add(REG_A_HIGH, 0xF0, (this->analog_stop_ >> 8) << 4);
    add(REG_A_STOP_L, 0xFF, this->analog_stop_ & 0xFF);
  }
 
  bool ok = true;
  for (uint8_t i = 0; i < CONFIG_REG_COUNT; i++) {
    if (masks[i] != 0)
      ok &= this->update_register_(progmem_read_byte(&CONFIG_REGS[i]), masks[i], values[i]);
  }
  if (!ok) {
    // A half-configured chip must not be sampled or have its EEPROM saved
    this->mark_failed(LOG_STR("configuration register write failed"));
  }
}
 
void MT6701I2CComponent::save_eeprom() {
  if (this->is_failed()) {
    // A failed component gets no timeouts, so the bus would stay suspended
    ESP_LOGW(TAG, "Not programming EEPROM: component is marked failed");
    return;
  }
  if (this->suspend_sampling_) {
    ESP_LOGW(TAG, "EEPROM programming already in progress");
    return;
  }
  ESP_LOGW(TAG, "Programming MT6701 EEPROM. The EEPROM has a limited number of write "
                "cycles, so avoid doing this repeatedly. Supply must be 4.5-5.5 V.");
  this->suspend_sampling_ = true;
 
  bool ok = this->write_byte(REG_EEPROM_KEY, EEPROM_KEY_VALUE) && this->write_byte(REG_EEPROM_CMD, EEPROM_CMD_VALUE);
  if (!ok) {
    ESP_LOGE(TAG, "Failed to start EEPROM programming");
    this->suspend_sampling_ = false;
    return;
  }
 
  // suspend_sampling_ keeps a second save out, so the timer needs no name
  this->set_timeout(EEPROM_PROGRAM_DELAY_MS, [this]() {
    this->suspend_sampling_ = false;
    ESP_LOGI(TAG, "EEPROM programming finished. Power-cycle the MT6701 to verify the stored configuration");
  });
}
 
}  // namespace esphome::mt6701_i2c