mirror of https://github.com/esphome/esphome.git
149 lines
4.5 KiB
C++
149 lines
4.5 KiB
C++
#include "ina226.h"
|
|
#include "esphome/core/log.h"
|
|
#include "esphome/core/hal.h"
|
|
|
|
namespace esphome {
|
|
namespace ina226 {
|
|
|
|
static const char *const TAG = "ina226";
|
|
|
|
// | A0 | A1 | Address |
|
|
// | GND | GND | 0x40 |
|
|
// | GND | V_S+ | 0x41 |
|
|
// | GND | SDA | 0x42 |
|
|
// | GND | SCL | 0x43 |
|
|
// | V_S+ | GND | 0x44 |
|
|
// | V_S+ | V_S+ | 0x45 |
|
|
// | V_S+ | SDA | 0x46 |
|
|
// | V_S+ | SCL | 0x47 |
|
|
// | SDA | GND | 0x48 |
|
|
// | SDA | V_S+ | 0x49 |
|
|
// | SDA | SDA | 0x4A |
|
|
// | SDA | SCL | 0x4B |
|
|
// | SCL | GND | 0x4C |
|
|
// | SCL | V_S+ | 0x4D |
|
|
// | SCL | SDA | 0x4E |
|
|
// | SCL | SCL | 0x4F |
|
|
|
|
static const uint8_t INA226_REGISTER_CONFIG = 0x00;
|
|
static const uint8_t INA226_REGISTER_SHUNT_VOLTAGE = 0x01;
|
|
static const uint8_t INA226_REGISTER_BUS_VOLTAGE = 0x02;
|
|
static const uint8_t INA226_REGISTER_POWER = 0x03;
|
|
static const uint8_t INA226_REGISTER_CURRENT = 0x04;
|
|
static const uint8_t INA226_REGISTER_CALIBRATION = 0x05;
|
|
|
|
void INA226Component::setup() {
|
|
ESP_LOGCONFIG(TAG, "Setting up INA226...");
|
|
// Config Register
|
|
// 0bx000000000000000 << 15 RESET Bit (1 -> trigger reset)
|
|
if (!this->write_byte_16(INA226_REGISTER_CONFIG, 0x8000)) {
|
|
this->mark_failed();
|
|
return;
|
|
}
|
|
delay(1);
|
|
|
|
uint16_t config = 0x0000;
|
|
|
|
// Averaging Mode AVG Bit Settings[11:9] (000 -> 1 sample, 001 -> 4 sample, 111 -> 1024 samples)
|
|
config |= 0b0000001000000000;
|
|
|
|
// Bus Voltage Conversion Time VBUSCT Bit Settings [8:6] (100 -> 1.1ms, 111 -> 8.244 ms)
|
|
config |= 0b0000000100000000;
|
|
|
|
// Shunt Voltage Conversion Time VSHCT Bit Settings [5:3] (100 -> 1.1ms, 111 -> 8.244 ms)
|
|
config |= 0b0000000000100000;
|
|
|
|
// Mode Settings [2:0] Combinations (111 -> Shunt and Bus, Continuous)
|
|
config |= 0b0000000000000111;
|
|
|
|
if (!this->write_byte_16(INA226_REGISTER_CONFIG, config)) {
|
|
this->mark_failed();
|
|
return;
|
|
}
|
|
|
|
// lsb is multiplied by 1000000 to store it as an integer value
|
|
uint32_t lsb = static_cast<uint32_t>(ceilf(this->max_current_a_ * 1000000.0f / 32768));
|
|
|
|
this->calibration_lsb_ = lsb;
|
|
|
|
auto calibration = uint32_t(0.00512 / (lsb * this->shunt_resistance_ohm_ / 1000000.0f));
|
|
|
|
ESP_LOGV(TAG, " Using LSB=%u calibration=%u", lsb, calibration);
|
|
|
|
if (!this->write_byte_16(INA226_REGISTER_CALIBRATION, calibration)) {
|
|
this->mark_failed();
|
|
return;
|
|
}
|
|
}
|
|
|
|
void INA226Component::dump_config() {
|
|
ESP_LOGCONFIG(TAG, "INA226:");
|
|
LOG_I2C_DEVICE(this);
|
|
|
|
if (this->is_failed()) {
|
|
ESP_LOGE(TAG, "Communication with INA226 failed!");
|
|
return;
|
|
}
|
|
LOG_UPDATE_INTERVAL(this);
|
|
|
|
LOG_SENSOR(" ", "Bus Voltage", this->bus_voltage_sensor_);
|
|
LOG_SENSOR(" ", "Shunt Voltage", this->shunt_voltage_sensor_);
|
|
LOG_SENSOR(" ", "Current", this->current_sensor_);
|
|
LOG_SENSOR(" ", "Power", this->power_sensor_);
|
|
}
|
|
|
|
float INA226Component::get_setup_priority() const { return setup_priority::DATA; }
|
|
|
|
bool INA226Component::read_ina226_reg_(uint8_t reg, uint16_t *result) {
|
|
if (write(®, 1) != i2c::ERROR_OK) {
|
|
status_set_warning();
|
|
return false;
|
|
}
|
|
delay(1); // conversion time
|
|
if (read(reinterpret_cast<uint8_t *>(result), 2) != i2c::ERROR_OK) {
|
|
status_set_warning();
|
|
return false;
|
|
}
|
|
*result = i2c::i2ctohs(*result);
|
|
return true;
|
|
}
|
|
|
|
void INA226Component::update() {
|
|
if (this->bus_voltage_sensor_ != nullptr) {
|
|
uint16_t raw_bus_voltage;
|
|
if (read_ina226_reg_(INA226_REGISTER_BUS_VOLTAGE, &raw_bus_voltage)) {
|
|
float bus_voltage_v = int16_t(raw_bus_voltage) * 0.00125f;
|
|
this->bus_voltage_sensor_->publish_state(bus_voltage_v);
|
|
}
|
|
}
|
|
|
|
if (this->shunt_voltage_sensor_ != nullptr) {
|
|
uint16_t raw_shunt_voltage;
|
|
if (read_ina226_reg_(INA226_REGISTER_SHUNT_VOLTAGE, &raw_shunt_voltage)) {
|
|
float shunt_voltage_v = int16_t(raw_shunt_voltage) * 0.0000025f;
|
|
this->shunt_voltage_sensor_->publish_state(shunt_voltage_v);
|
|
}
|
|
}
|
|
|
|
if (this->current_sensor_ != nullptr) {
|
|
uint16_t raw_current;
|
|
if (read_ina226_reg_(INA226_REGISTER_CURRENT, &raw_current)) {
|
|
float current_ma = int16_t(raw_current) * (this->calibration_lsb_ / 1000.0f);
|
|
this->current_sensor_->publish_state(current_ma / 1000.0f);
|
|
}
|
|
}
|
|
|
|
if (this->power_sensor_ != nullptr) {
|
|
uint16_t raw_power;
|
|
if (read_ina226_reg_(INA226_REGISTER_POWER, &raw_power)) {
|
|
float power_mw = int16_t(raw_power) * (this->calibration_lsb_ * 25.0f / 1000.0f);
|
|
this->power_sensor_->publish_state(power_mw / 1000.0f);
|
|
}
|
|
}
|
|
|
|
this->status_clear_warning();
|
|
}
|
|
|
|
} // namespace ina226
|
|
} // namespace esphome
|