esphome 2024.9.1__py3-none-any.whl → 2024.10.0__py3-none-any.whl

esphome/components/mics_4514/sensor.py

@@ -1,10 +1,14 @@
 import esphome.codegen as cg
+from esphome.components import i2c, sensor
 import esphome.config_validation as cv
-
-from esphome.components import sensor, i2c
-
 from esphome.const import (
+    CONF_AMMONIA,
+    CONF_CARBON_MONOXIDE,
+    CONF_ETHANOL,
+    CONF_HYDROGEN,
     CONF_ID,
+    CONF_METHANE,
+    CONF_NITROGEN_DIOXIDE,
     STATE_CLASS_MEASUREMENT,
     UNIT_PARTS_PER_MILLION,
 )
@@ -12,13 +16,6 @@ from esphome.const import (
 CODEOWNERS = ["@jesserockz"]
 DEPENDENCIES = ["i2c"]
 
-CONF_CARBON_MONOXIDE = "carbon_monoxide"
-CONF_NITROGEN_DIOXIDE = "nitrogen_dioxide"
-CONF_METHANE = "methane"
-CONF_ETHANOL = "ethanol"
-CONF_HYDROGEN = "hydrogen"
-CONF_AMMONIA = "ammonia"
-
 
 mics_4514_ns = cg.esphome_ns.namespace("mics_4514")
 MICS4514Component = mics_4514_ns.class_(
@@ -31,6 +28,7 @@ SENSORS = [
     CONF_ETHANOL,
     CONF_HYDROGEN,
     CONF_AMMONIA,
+    CONF_NITROGEN_DIOXIDE,
 ]
 
 common_sensor_schema = sensor.sensor_schema(
@@ -40,16 +38,7 @@ common_sensor_schema = sensor.sensor_schema(
 )
 
 CONFIG_SCHEMA = (
-    cv.Schema(
-        {
-            cv.GenerateID(): cv.declare_id(MICS4514Component),
-            cv.Optional(CONF_NITROGEN_DIOXIDE): sensor.sensor_schema(
-                unit_of_measurement=UNIT_PARTS_PER_MILLION,
-                state_class=STATE_CLASS_MEASUREMENT,
-                accuracy_decimals=2,
-            ),
-        }
-    )
+    cv.Schema({cv.GenerateID(): cv.declare_id(MICS4514Component)})
     .extend({cv.Optional(sensor_type): common_sensor_schema for sensor_type in SENSORS})
     .extend(i2c.i2c_device_schema(0x75))
     .extend(cv.polling_component_schema("60s"))
@@ -62,10 +51,6 @@ async def to_code(config):
     await i2c.register_i2c_device(var, config)
 
     for sensor_type in SENSORS:
-        if sensor_type in config:
-            sens = await sensor.new_sensor(config[sensor_type])
+        if sensor_config := config.get(sensor_type):
+            sens = await sensor.new_sensor(sensor_config)
             cg.add(getattr(var, f"set_{sensor_type}_sensor")(sens))
-
-    if CONF_NITROGEN_DIOXIDE in config:
-        sens = await sensor.new_sensor(config[CONF_NITROGEN_DIOXIDE])
-        cg.add(var.set_nitrogen_dioxide_sensor(sens))

esphome/components/modbus_controller/__init__.py

@@ -1,27 +1,29 @@
 import binascii
-import esphome.codegen as cg
-import esphome.config_validation as cv
+
 from esphome import automation
+import esphome.codegen as cg
 from esphome.components import modbus
+import esphome.config_validation as cv
 from esphome.const import (
     CONF_ADDRESS,
     CONF_ID,
-    CONF_NAME,
     CONF_LAMBDA,
+    CONF_NAME,
     CONF_OFFSET,
     CONF_TRIGGER_ID,
 )
 from esphome.cpp_helpers import logging
+
 from .const import (
     CONF_ALLOW_DUPLICATE_COMMANDS,
     CONF_BITMASK,
     CONF_BYTE_OFFSET,
     CONF_COMMAND_THROTTLE,
-    CONF_OFFLINE_SKIP_UPDATES,
     CONF_CUSTOM_COMMAND,
     CONF_FORCE_NEW_RANGE,
-    CONF_MODBUS_CONTROLLER_ID,
     CONF_MAX_CMD_RETRIES,
+    CONF_MODBUS_CONTROLLER_ID,
+    CONF_OFFLINE_SKIP_UPDATES,
     CONF_ON_COMMAND_SENT,
     CONF_REGISTER_COUNT,
     CONF_REGISTER_TYPE,

esphome/components/modbus_controller/binary_sensor/__init__.py

@@ -1,16 +1,16 @@
+import esphome.codegen as cg
 from esphome.components import binary_sensor
 import esphome.config_validation as cv
-import esphome.codegen as cg
-
 from esphome.const import CONF_ADDRESS, CONF_ID
+
 from .. import (
+    MODBUS_REGISTER_TYPE,
+    ModbusItemBaseSchema,
+    SensorItem,
     add_modbus_base_properties,
-    modbus_controller_ns,
     modbus_calc_properties,
+    modbus_controller_ns,
     validate_modbus_register,
-    ModbusItemBaseSchema,
-    SensorItem,
-    MODBUS_REGISTER_TYPE,
 )
 from ..const import (
     CONF_BITMASK,

esphome/components/modbus_controller/number/__init__.py

@@ -1,6 +1,6 @@
 import esphome.codegen as cg
-import esphome.config_validation as cv
 from esphome.components import number
+import esphome.config_validation as cv
 from esphome.const import (
     CONF_ADDRESS,
     CONF_ID,
@@ -12,14 +12,13 @@ from esphome.const import (
 
 from .. import (
     MODBUS_WRITE_REGISTER_TYPE,
-    add_modbus_base_properties,
-    modbus_controller_ns,
-    modbus_calc_properties,
+    SENSOR_VALUE_TYPE,
     ModbusItemBaseSchema,
     SensorItem,
-    SENSOR_VALUE_TYPE,
+    add_modbus_base_properties,
+    modbus_calc_properties,
+    modbus_controller_ns,
 )
-
 from ..const import (
     CONF_BITMASK,
     CONF_CUSTOM_COMMAND,

esphome/components/modbus_controller/output/__init__.py

@@ -1,20 +1,15 @@
 import esphome.codegen as cg
-import esphome.config_validation as cv
 from esphome.components import output
-from esphome.const import (
-    CONF_ADDRESS,
-    CONF_ID,
-    CONF_MULTIPLY,
-)
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_ID, CONF_MULTIPLY
 
 from .. import (
-    modbus_controller_ns,
-    modbus_calc_properties,
+    SENSOR_VALUE_TYPE,
     ModbusItemBaseSchema,
     SensorItem,
-    SENSOR_VALUE_TYPE,
+    modbus_calc_properties,
+    modbus_controller_ns,
 )
-
 from ..const import (
     CONF_MODBUS_CONTROLLER_ID,
     CONF_REGISTER_TYPE,
@@ -65,6 +60,7 @@ CONFIG_SCHEMA = cv.typed_schema(
 async def to_code(config):
     byte_offset, reg_count = modbus_calc_properties(config)
     # Binary Output
+    write_template = None
     if config[CONF_REGISTER_TYPE] == "coil":
         var = cg.new_Pvariable(
             config[CONF_ID],
@@ -72,7 +68,7 @@ async def to_code(config):
             byte_offset,
         )
         if CONF_WRITE_LAMBDA in config:
-            template_ = await cg.process_lambda(
+            write_template = await cg.process_lambda(
                 config[CONF_WRITE_LAMBDA],
                 [
                     (ModbusBinaryOutput.operator("ptr"), "item"),
@@ -92,7 +88,7 @@ async def to_code(config):
         )
         cg.add(var.set_write_multiply(config[CONF_MULTIPLY]))
         if CONF_WRITE_LAMBDA in config:
-            template_ = await cg.process_lambda(
+            write_template = await cg.process_lambda(
                 config[CONF_WRITE_LAMBDA],
                 [
                     (ModbusFloatOutput.operator("ptr"), "item"),
@@ -105,5 +101,5 @@ async def to_code(config):
     parent = await cg.get_variable(config[CONF_MODBUS_CONTROLLER_ID])
     cg.add(var.set_use_write_mutiple(config[CONF_USE_WRITE_MULTIPLE]))
     cg.add(var.set_parent(parent))
-    if CONF_WRITE_LAMBDA in config:
-        cg.add(var.set_write_template(template_))
+    if write_template:
+        cg.add(var.set_write_template(write_template))

esphome/components/modbus_controller/select/__init__.py

@@ -1,6 +1,6 @@
 import esphome.codegen as cg
-import esphome.config_validation as cv
 from esphome.components import select
+import esphome.config_validation as cv
 from esphome.const import CONF_ADDRESS, CONF_ID, CONF_LAMBDA, CONF_OPTIMISTIC
 
 from .. import (

esphome/components/modbus_controller/sensor/__init__.py

@@ -1,17 +1,17 @@
+import esphome.codegen as cg
 from esphome.components import sensor
 import esphome.config_validation as cv
-import esphome.codegen as cg
+from esphome.const import CONF_ADDRESS, CONF_ID
 
-from esphome.const import CONF_ID, CONF_ADDRESS
 from .. import (
+    MODBUS_REGISTER_TYPE,
+    SENSOR_VALUE_TYPE,
+    ModbusItemBaseSchema,
+    SensorItem,
     add_modbus_base_properties,
-    modbus_controller_ns,
     modbus_calc_properties,
+    modbus_controller_ns,
     validate_modbus_register,
-    ModbusItemBaseSchema,
-    SensorItem,
-    MODBUS_REGISTER_TYPE,
-    SENSOR_VALUE_TYPE,
 )
 from ..const import (
     CONF_BITMASK,

esphome/components/modbus_controller/switch/__init__.py

@@ -1,17 +1,16 @@
+import esphome.codegen as cg
 from esphome.components import switch
 import esphome.config_validation as cv
-import esphome.codegen as cg
-
+from esphome.const import CONF_ADDRESS, CONF_ID
 
-from esphome.const import CONF_ID, CONF_ADDRESS
 from .. import (
+    MODBUS_REGISTER_TYPE,
+    ModbusItemBaseSchema,
+    SensorItem,
     add_modbus_base_properties,
-    modbus_controller_ns,
     modbus_calc_properties,
+    modbus_controller_ns,
     validate_modbus_register,
-    ModbusItemBaseSchema,
-    SensorItem,
-    MODBUS_REGISTER_TYPE,
 )
 from ..const import (
     CONF_BITMASK,

esphome/components/modbus_controller/text_sensor/__init__.py

@@ -1,26 +1,25 @@
+import esphome.codegen as cg
 from esphome.components import text_sensor
 import esphome.config_validation as cv
-import esphome.codegen as cg
-
-
 from esphome.const import CONF_ADDRESS, CONF_ID
+
 from .. import (
+    MODBUS_REGISTER_TYPE,
+    ModbusItemBaseSchema,
+    SensorItem,
     add_modbus_base_properties,
-    modbus_controller_ns,
     modbus_calc_properties,
+    modbus_controller_ns,
     validate_modbus_register,
-    ModbusItemBaseSchema,
-    SensorItem,
-    MODBUS_REGISTER_TYPE,
 )
 from ..const import (
     CONF_FORCE_NEW_RANGE,
     CONF_MODBUS_CONTROLLER_ID,
+    CONF_RAW_ENCODE,
     CONF_REGISTER_COUNT,
+    CONF_REGISTER_TYPE,
     CONF_RESPONSE_SIZE,
     CONF_SKIP_UPDATES,
-    CONF_RAW_ENCODE,
-    CONF_REGISTER_TYPE,
 )
 
 DEPENDENCIES = ["modbus_controller"]

esphome/components/mqtt/__init__.py

@@ -11,6 +11,7 @@ from esphome.const import (
     CONF_BIRTH_MESSAGE,
     CONF_BROKER,
     CONF_CERTIFICATE_AUTHORITY,
+    CONF_CLEAN_SESSION,
     CONF_CLIENT_CERTIFICATE,
     CONF_CLIENT_CERTIFICATE_KEY,
     CONF_CLIENT_ID,
@@ -209,6 +210,7 @@ CONFIG_SCHEMA = cv.All(
             cv.Optional(CONF_PORT, default=1883): cv.port,
             cv.Optional(CONF_USERNAME, default=""): cv.string,
             cv.Optional(CONF_PASSWORD, default=""): cv.string,
+            cv.Optional(CONF_CLEAN_SESSION, default=False): cv.boolean,
             cv.Optional(CONF_CLIENT_ID): cv.string,
             cv.SplitDefault(CONF_IDF_SEND_ASYNC, esp32_idf=False): cv.All(
                 cv.boolean, cv.only_with_esp_idf
@@ -325,6 +327,7 @@ async def to_code(config):
     cg.add(var.set_broker_port(config[CONF_PORT]))
     cg.add(var.set_username(config[CONF_USERNAME]))
     cg.add(var.set_password(config[CONF_PASSWORD]))
+    cg.add(var.set_clean_session(config[CONF_CLEAN_SESSION]))
     if CONF_CLIENT_ID in config:
         cg.add(var.set_client_id(config[CONF_CLIENT_ID]))
 

esphome/components/mqtt/mqtt_client.cpp

@@ -147,6 +147,7 @@ void MQTTClientComponent::dump_config() {
                 this->ip_.str().c_str());
   ESP_LOGCONFIG(TAG, "  Username: " LOG_SECRET("'%s'"), this->credentials_.username.c_str());
   ESP_LOGCONFIG(TAG, "  Client ID: " LOG_SECRET("'%s'"), this->credentials_.client_id.c_str());
+  ESP_LOGCONFIG(TAG, "  Clean Session: %s", YESNO(this->credentials_.clean_session));
   if (this->is_discovery_ip_enabled()) {
     ESP_LOGCONFIG(TAG, "  Discovery IP enabled");
   }
@@ -246,6 +247,7 @@ void MQTTClientComponent::start_connect_() {
   this->mqtt_backend_.disconnect();
 
   this->mqtt_backend_.set_client_id(this->credentials_.client_id.c_str());
+  this->mqtt_backend_.set_clean_session(this->credentials_.clean_session);
   const char *username = nullptr;
   if (!this->credentials_.username.empty())
     username = this->credentials_.username.c_str();

esphome/components/mqtt/mqtt_client.h

@@ -51,6 +51,7 @@ struct MQTTCredentials {
   std::string username;
   std::string password;
   std::string client_id;  ///< The client ID. Will automatically be truncated to 23 characters.
+  bool clean_session;     ///< Whether the session will be cleaned or remembered between connects.
 };
 
 /// Simple data struct for Home Assistant component availability.
@@ -254,6 +255,7 @@ class MQTTClientComponent : public Component {
   void set_username(const std::string &username) { this->credentials_.username = username; }
   void set_password(const std::string &password) { this->credentials_.password = password; }
   void set_client_id(const std::string &client_id) { this->credentials_.client_id = client_id; }
+  void set_clean_session(const bool &clean_session) { this->credentials_.clean_session = clean_session; }
   void set_on_connect(mqtt_on_connect_callback_t &&callback);
   void set_on_disconnect(mqtt_on_disconnect_callback_t &&callback);
 

esphome/components/nau7802/nau7802.cpp

@@ -0,0 +1,323 @@
+#include "nau7802.h"
+#include "esphome/core/log.h"
+#include "esphome/core/hal.h"
+
+namespace esphome {
+namespace nau7802 {
+
+static const char *const TAG = "nau7802";
+
+// Only define what we need
+
+static const uint8_t READ_BIT = 0x01;
+
+static const uint8_t PU_CTRL_REG = 0x00;
+static const uint8_t PU_CTRL_REGISTER_RESET = 0x01;
+static const uint8_t PU_CTRL_POWERUP_DIGITAL = 0x02;
+static const uint8_t PU_CTRL_POWERUP_ANALOG = 0x04;
+static const uint8_t PU_CTRL_POWERUP_READY = 0x08;
+static const uint8_t PU_CTRL_CYCLE_START = 0x10;
+static const uint8_t PU_CTRL_CYCLE_READY = 0x20;
+static const uint8_t PU_CTRL_AVDD_EXTERNAL = 0x80;
+
+static const uint8_t CTRL1_REG = 0x01;
+static const uint8_t CTRL1_LDO_SHIFT = 3;
+static const uint8_t CTRL1_LDO_MASK = (0x7 << CTRL1_LDO_SHIFT);
+static const uint8_t CTRL1_GAIN_MASK = 0x7;
+
+static const uint8_t CTRL2_REG = 0x02;
+static const uint8_t CTRL2_CRS_SHIFT = 4;
+static const uint8_t CTRL2_CRS_MASK = (0x7 << CTRL2_CRS_SHIFT);
+static const uint8_t CTRL2_CALS = 0x04;
+static const uint8_t CTRL2_CAL_ERR = 0x08;
+static const uint8_t CTRL2_GAIN_CALIBRATION = 0x03;
+static const uint8_t CTRL2_CONFIG_MASK = 0xF0;
+
+static const uint8_t OCAL1_B2_REG = 0x03;
+static const uint8_t GCAL1_B3_REG = 0x06;
+static const uint8_t GCAL1_FRACTIONAL = 23;
+
+// only need the first data register for sequential read method
+static const uint8_t ADCO_B2_REG = 0x12;
+
+static const uint8_t ADC_REG = 0x15;
+static const uint8_t ADC_CHPS_DISABLE = 0x30;
+
+static const uint8_t PGA_REG = 0x1B;
+static const uint8_t PGA_LDOMODE_ESR = 0x40;
+
+static const uint8_t POWER_REG = 0x1C;
+static const uint8_t POWER_PGA_CAP_EN = 0x80;
+
+static const uint8_t DEVICE_REV = 0x1F;
+
+void NAU7802Sensor::setup() {
+  i2c::I2CRegister pu_ctrl = this->reg(PU_CTRL_REG);
+  ESP_LOGCONFIG(TAG, "Setting up NAU7802 '%s'...", this->name_.c_str());
+  uint8_t rev;
+
+  if (this->read_register(DEVICE_REV | READ_BIT, &rev, 1)) {
+    ESP_LOGE(TAG, "Failed I2C read during setup()");
+    this->mark_failed();
+    return;
+  }
+  ESP_LOGI(TAG, "Setting up NAU7802 Rev %d", rev);
+
+  // reset
+  pu_ctrl |= PU_CTRL_REGISTER_RESET;
+  delay(10);
+  pu_ctrl &= ~PU_CTRL_REGISTER_RESET;
+
+  // power up digital hw
+  pu_ctrl |= PU_CTRL_POWERUP_DIGITAL;
+
+  delay(1);
+  if (!(pu_ctrl.get() & PU_CTRL_POWERUP_READY)) {
+    ESP_LOGE(TAG, "Failed to reset sensor during setup()");
+    this->mark_failed();
+    return;
+  }
+
+  uint32_t gcal = (uint32_t) (round(this->gain_calibration_ * (1 << GCAL1_FRACTIONAL)));
+  this->write_value_(OCAL1_B2_REG, 3, this->offset_calibration_);
+  this->write_value_(GCAL1_B3_REG, 4, gcal);
+
+  // turn on AFE
+  pu_ctrl |= PU_CTRL_POWERUP_ANALOG;
+  auto f = std::bind(&NAU7802Sensor::complete_setup_, this);
+  this->set_timeout(600, f);
+}
+
+void NAU7802Sensor::complete_setup_() {
+  i2c::I2CRegister pu_ctrl = this->reg(PU_CTRL_REG);
+  i2c::I2CRegister ctrl1 = this->reg(CTRL1_REG);
+  i2c::I2CRegister ctrl2 = this->reg(CTRL2_REG);
+  pu_ctrl |= PU_CTRL_CYCLE_START;
+
+  // set gain
+  ctrl1 &= ~CTRL1_GAIN_MASK;
+  ctrl1 |= this->gain_;
+
+  // enable internal LDO
+  if (this->ldo_ != NAU7802_LDO_EXTERNAL) {
+    pu_ctrl |= PU_CTRL_AVDD_EXTERNAL;
+    ctrl1 &= ~CTRL1_LDO_MASK;
+    ctrl1 |= this->ldo_ << CTRL1_LDO_SHIFT;
+  }
+
+  // set sps
+  ctrl2 &= ~CTRL2_CRS_MASK;
+  ctrl2 |= this->sps_ << CTRL2_CRS_SHIFT;
+
+  // disable ADC chopper clock
+  i2c::I2CRegister adc_reg = this->reg(ADC_REG);
+  adc_reg |= ADC_CHPS_DISABLE;
+
+  // use low ESR caps
+  i2c::I2CRegister pga_reg = this->reg(PGA_REG);
+  pga_reg &= ~PGA_LDOMODE_ESR;
+
+  // PGA stabilizer cap on output
+  i2c::I2CRegister pwr_reg = this->reg(POWER_REG);
+  pwr_reg |= POWER_PGA_CAP_EN;
+
+  this->setup_complete_ = true;
+}
+
+void NAU7802Sensor::dump_config() {
+  LOG_SENSOR("", "NAU7802", this);
+  LOG_I2C_DEVICE(this);
+
+  if (this->is_failed()) {
+    ESP_LOGE(TAG, "Communication with NAU7802 failed earlier, during setup");
+    return;
+  }
+  // Note these may differ from the values on the device if calbration has been run
+  ESP_LOGCONFIG(TAG, "  Offset Calibration: %s", to_string(this->offset_calibration_).c_str());
+  ESP_LOGCONFIG(TAG, "  Gain Calibration: %f", this->gain_calibration_);
+
+  std::string voltage = "unknown";
+  switch (this->ldo_) {
+    case NAU7802_LDO_2V4:
+      voltage = "2.4V";
+      break;
+    case NAU7802_LDO_2V7:
+      voltage = "2.7V";
+      break;
+    case NAU7802_LDO_3V0:
+      voltage = "3.0V";
+      break;
+    case NAU7802_LDO_3V3:
+      voltage = "3.3V";
+      break;
+    case NAU7802_LDO_3V6:
+      voltage = "3.6V";
+      break;
+    case NAU7802_LDO_3V9:
+      voltage = "3.9V";
+      break;
+    case NAU7802_LDO_4V2:
+      voltage = "4.2V";
+      break;
+    case NAU7802_LDO_4V5:
+      voltage = "4.5V";
+      break;
+    case NAU7802_LDO_EXTERNAL:
+      voltage = "External";
+      break;
+  }
+  ESP_LOGCONFIG(TAG, "  LDO Voltage: %s", voltage.c_str());
+  int gain = 0;
+  switch (this->gain_) {
+    case NAU7802_GAIN_128:
+      gain = 128;
+      break;
+    case NAU7802_GAIN_64:
+      gain = 64;
+      break;
+    case NAU7802_GAIN_32:
+      gain = 32;
+      break;
+    case NAU7802_GAIN_16:
+      gain = 16;
+      break;
+    case NAU7802_GAIN_8:
+      gain = 8;
+      break;
+    case NAU7802_GAIN_4:
+      gain = 4;
+      break;
+    case NAU7802_GAIN_2:
+      gain = 2;
+      break;
+    case NAU7802_GAIN_1:
+      gain = 1;
+      break;
+  }
+  ESP_LOGCONFIG(TAG, "  Gain: %dx", gain);
+  int sps = 0;
+  switch (this->sps_) {
+    case NAU7802_SPS_320:
+      sps = 320;
+      break;
+    case NAU7802_SPS_80:
+      sps = 80;
+      break;
+    case NAU7802_SPS_40:
+      sps = 40;
+      break;
+    case NAU7802_SPS_20:
+      sps = 20;
+      break;
+    case NAU7802_SPS_10:
+      sps = 10;
+      break;
+  }
+  ESP_LOGCONFIG(TAG, "  Samples Per Second: %d", sps);
+  LOG_UPDATE_INTERVAL(this);
+}
+
+void NAU7802Sensor::write_value_(uint8_t start_reg, size_t size, int32_t value) {
+  uint8_t data[4];
+  for (int i = 0; i < size; i++) {
+    data[i] = 0xFF & (value >> (size - 1 - i) * 8);
+  }
+  this->write_register(start_reg, data, size);
+}
+
+int32_t NAU7802Sensor::read_value_(uint8_t start_reg, size_t size) {
+  uint8_t data[4];
+  this->read_register(start_reg, data, size);
+  int32_t result = 0;
+  for (int i = 0; i < size; i++) {
+    result |= data[i] << (size - 1 - i) * 8;
+  }
+  // extend sign bit
+  if (result & 0x800000 && size == 3) {
+    result |= 0xFF000000;
+  }
+  return result;
+}
+
+bool NAU7802Sensor::calibrate_(enum NAU7802CalibrationModes mode) {
+  // check if already calbrating
+  if (this->state_ != CalibrationState::INACTIVE) {
+    ESP_LOGW(TAG, "Calibration already in progress");
+    return false;
+  }
+
+  this->state_ = mode == NAU7802_CALIBRATE_GAIN ? CalibrationState::GAIN : CalibrationState::OFFSET;
+
+  i2c::I2CRegister ctrl2 = this->reg(CTRL2_REG);
+  // clear calibraye registers
+  ctrl2 &= CTRL2_CONFIG_MASK;
+  // Calibrate
+  ctrl2 |= mode;
+  ctrl2 |= CTRL2_CALS;
+  return true;
+}
+
+void NAU7802Sensor::set_calibration_failure_(bool failed) {
+  switch (this->state_) {
+    case CalibrationState::GAIN:
+      this->gain_calibration_failed_ = failed;
+      break;
+    case CalibrationState::OFFSET:
+      this->offset_calibration_failed_ = failed;
+      break;
+    case CalibrationState::INACTIVE:
+      // shouldn't happen
+      break;
+  }
+}
+
+void NAU7802Sensor::loop() {
+  i2c::I2CRegister ctrl2 = this->reg(CTRL2_REG);
+
+  if (this->state_ != CalibrationState::INACTIVE && !(ctrl2.get() & CTRL2_CALS)) {
+    if (ctrl2.get() & CTRL2_CAL_ERR) {
+      this->set_calibration_failure_(true);
+      this->state_ = CalibrationState::INACTIVE;
+      ESP_LOGE(TAG, "Failed to calibrate sensor");
+      this->status_set_error("Calibration Failed");
+      return;
+    }
+
+    this->set_calibration_failure_(false);
+    this->state_ = CalibrationState::INACTIVE;
+
+    if (!this->offset_calibration_failed_ && !this->gain_calibration_failed_)
+      this->status_clear_error();
+
+    int32_t ocal = this->read_value_(OCAL1_B2_REG, 3);
+    ESP_LOGI(TAG, "New Offset: %s", to_string(ocal).c_str());
+    uint32_t gcal = this->read_value_(GCAL1_B3_REG, 4);
+    float gcal_f = ((float) gcal / (float) (1 << GCAL1_FRACTIONAL));
+    ESP_LOGI(TAG, "New Gain: %f", gcal_f);
+  }
+}
+
+float NAU7802Sensor::get_setup_priority() const { return setup_priority::DATA; }
+
+void NAU7802Sensor::update() {
+  if (!this->is_data_ready_()) {
+    ESP_LOGW(TAG, "No measurements ready!");
+    this->status_set_warning();
+    return;
+  }
+
+  this->status_clear_warning();
+
+  // Get the most recent sample to publish
+  int32_t result = this->read_value_(ADCO_B2_REG, 3);
+
+  ESP_LOGD(TAG, "'%s': Got value %" PRId32, this->name_.c_str(), result);
+  this->publish_state(result);
+}
+
+bool NAU7802Sensor::is_data_ready_() { return this->reg(PU_CTRL_REG).get() & PU_CTRL_CYCLE_READY; }
+
+bool NAU7802Sensor::can_proceed() { return this->setup_complete_; }
+
+}  // namespace nau7802
+}  // namespace esphome