esphome 2025.8.3__py3-none-any.whl → 2025.9.0b1__py3-none-any.whl

esphome/components/bl0940/bl0940.h

@@ -1,66 +1,48 @@
 #pragma once
 
 #include "esphome/core/component.h"
-#include "esphome/components/uart/uart.h"
+#include "esphome/core/datatypes.h"
+#include "esphome/core/defines.h"
+#ifdef USE_BUTTON
+#include "esphome/components/button/button.h"
+#endif
+#ifdef USE_NUMBER
+#include "esphome/components/number/number.h"
+#endif
 #include "esphome/components/sensor/sensor.h"
+#include "esphome/components/uart/uart.h"
 
 namespace esphome {
 namespace bl0940 {
 
-static const float BL0940_PREF = 1430;
-static const float BL0940_UREF = 33000;
-static const float BL0940_IREF = 275000;  // 2750 from tasmota. Seems to generate values 100 times too high
-
-// Measured to 297J  per click according to power consumption of 5 minutes
-// Converted to kWh (3.6MJ per kwH). Used to be 256 * 1638.4
-static const float BL0940_EREF = 3.6e6 / 297;
-
-struct ube24_t {  // NOLINT(readability-identifier-naming,altera-struct-pack-align)
-  uint8_t l;
-  uint8_t m;
-  uint8_t h;
-} __attribute__((packed));
-
-struct ube16_t {  // NOLINT(readability-identifier-naming,altera-struct-pack-align)
-  uint8_t l;
-  uint8_t h;
-} __attribute__((packed));
-
-struct sbe24_t {  // NOLINT(readability-identifier-naming,altera-struct-pack-align)
-  uint8_t l;
-  uint8_t m;
-  int8_t h;
-} __attribute__((packed));
-
 // Caveat: All these values are big endian (low - middle - high)
-
-union DataPacket {  // NOLINT(altera-struct-pack-align)
-  uint8_t raw[35];
-  struct {
-    uint8_t frame_header;  // value of 0x58 according to docs. 0x55 according to Tasmota real world tests. Reality wins.
-    ube24_t i_fast_rms;    // 0x00
-    ube24_t i_rms;         // 0x04
-    ube24_t RESERVED0;     // reserved
-    ube24_t v_rms;         // 0x06
-    ube24_t RESERVED1;     // reserved
-    sbe24_t watt;          // 0x08
-    ube24_t RESERVED2;     // reserved
-    ube24_t cf_cnt;        // 0x0A
-    ube24_t RESERVED3;     // reserved
-    ube16_t tps1;          // 0x0c
-    uint8_t RESERVED4;     // value of 0x00
-    ube16_t tps2;          // 0x0c
-    uint8_t RESERVED5;     // value of 0x00
-    uint8_t checksum;      // checksum
-  };
+struct DataPacket {
+  uint8_t frame_header;    // Packet header (0x58 in EN docs, 0x55 in CN docs and Tasmota tests)
+  uint24_le_t i_fast_rms;  // Fast RMS current
+  uint24_le_t i_rms;       // RMS current
+  uint24_t RESERVED0;      // Reserved
+  uint24_le_t v_rms;       // RMS voltage
+  uint24_t RESERVED1;      // Reserved
+  int24_le_t watt;         // Active power (can be negative for bidirectional measurement)
+  uint24_t RESERVED2;      // Reserved
+  uint24_le_t cf_cnt;      // Energy pulse count
+  uint24_t RESERVED3;      // Reserved
+  uint16_le_t tps1;        // Internal temperature sensor 1
+  uint8_t RESERVED4;       // Reserved (should be 0x00)
+  uint16_le_t tps2;        // Internal temperature sensor 2
+  uint8_t RESERVED5;       // Reserved (should be 0x00)
+  uint8_t checksum;        // Packet checksum
 } __attribute__((packed));
 
 class BL0940 : public PollingComponent, public uart::UARTDevice {
  public:
+  // Sensor setters
   void set_voltage_sensor(sensor::Sensor *voltage_sensor) { voltage_sensor_ = voltage_sensor; }
   void set_current_sensor(sensor::Sensor *current_sensor) { current_sensor_ = current_sensor; }
   void set_power_sensor(sensor::Sensor *power_sensor) { power_sensor_ = power_sensor; }
   void set_energy_sensor(sensor::Sensor *energy_sensor) { energy_sensor_ = energy_sensor; }
+
+  // Temperature sensor setters
   void set_internal_temperature_sensor(sensor::Sensor *internal_temperature_sensor) {
     internal_temperature_sensor_ = internal_temperature_sensor;
   }
@@ -68,42 +50,105 @@ class BL0940 : public PollingComponent, public uart::UARTDevice {
     external_temperature_sensor_ = external_temperature_sensor;
   }
 
+  // Configuration setters
+  void set_legacy_mode(bool enable) { this->legacy_mode_enabled_ = enable; }
+  void set_read_command(uint8_t read_command) { this->read_command_ = read_command; }
+  void set_write_command(uint8_t write_command) { this->write_command_ = write_command; }
+
+  // Reference value setters (used for calibration and conversion)
+  void set_current_reference(float current_ref) { this->current_reference_ = current_ref; }
+  void set_energy_reference(float energy_ref) { this->energy_reference_ = energy_ref; }
+  void set_power_reference(float power_ref) { this->power_reference_ = power_ref; }
+  void set_voltage_reference(float voltage_ref) { this->voltage_reference_ = voltage_ref; }
+
+#ifdef USE_NUMBER
+  // Calibration number setters (for Home Assistant number entities)
+  void set_current_calibration_number(number::Number *num) { this->current_calibration_number_ = num; }
+  void set_voltage_calibration_number(number::Number *num) { this->voltage_calibration_number_ = num; }
+  void set_power_calibration_number(number::Number *num) { this->power_calibration_number_ = num; }
+  void set_energy_calibration_number(number::Number *num) { this->energy_calibration_number_ = num; }
+#endif
+
+#ifdef USE_BUTTON
+  // Resets all calibration values to defaults (can be triggered by a button)
+  void reset_calibration();
+#endif
+
+  // Core component methods
   void loop() override;
-
   void update() override;
   void setup() override;
   void dump_config() override;
 
  protected:
-  sensor::Sensor *voltage_sensor_{nullptr};
-  sensor::Sensor *current_sensor_{nullptr};
-  // NB This may be negative as the circuits is seemingly able to measure
-  // power in both directions
-  sensor::Sensor *power_sensor_{nullptr};
-  sensor::Sensor *energy_sensor_{nullptr};
-  sensor::Sensor *internal_temperature_sensor_{nullptr};
-  sensor::Sensor *external_temperature_sensor_{nullptr};
-
-  // Max difference between two measurements of the temperature. Used to avoid noise.
-  float max_temperature_diff_{0};
-  // Divide by this to turn into Watt
-  float power_reference_ = BL0940_PREF;
-  // Divide by this to turn into Volt
-  float voltage_reference_ = BL0940_UREF;
-  // Divide by this to turn into Ampere
-  float current_reference_ = BL0940_IREF;
-  // Divide by this to turn into kWh
-  float energy_reference_ = BL0940_EREF;
-
-  float update_temp_(sensor::Sensor *sensor, ube16_t packed_temperature) const;
-
-  static uint32_t to_uint32_t(ube24_t input);
-
-  static int32_t to_int32_t(sbe24_t input);
-
-  static bool validate_checksum(const DataPacket *data);
-
-  void received_package_(const DataPacket *data) const;
+  // --- Sensor pointers ---
+  sensor::Sensor *voltage_sensor_{nullptr};               // Voltage sensor
+  sensor::Sensor *current_sensor_{nullptr};               // Current sensor
+  sensor::Sensor *power_sensor_{nullptr};                 // Power sensor (can be negative for bidirectional)
+  sensor::Sensor *energy_sensor_{nullptr};                // Energy sensor
+  sensor::Sensor *internal_temperature_sensor_{nullptr};  // Internal temperature sensor
+  sensor::Sensor *external_temperature_sensor_{nullptr};  // External temperature sensor
+
+#ifdef USE_NUMBER
+  // --- Calibration number entities (for dynamic calibration via HA UI) ---
+  number::Number *voltage_calibration_number_{nullptr};
+  number::Number *current_calibration_number_{nullptr};
+  number::Number *power_calibration_number_{nullptr};
+  number::Number *energy_calibration_number_{nullptr};
+#endif
+
+  // --- Internal state ---
+  uint32_t prev_cf_cnt_ = 0;       // Previous energy pulse count (for energy calculation)
+  float max_temperature_diff_{0};  // Max allowed temperature difference between two measurements (noise filter)
+
+  // --- Reference values for conversion ---
+  float power_reference_;        // Divider for raw power to get Watts
+  float power_reference_cal_;    // Calibrated power reference
+  float voltage_reference_;      // Divider for raw voltage to get Volts
+  float voltage_reference_cal_;  // Calibrated voltage reference
+  float current_reference_;      // Divider for raw current to get Amperes
+  float current_reference_cal_;  // Calibrated current reference
+  float energy_reference_;       // Divider for raw energy to get kWh
+  float energy_reference_cal_;   // Calibrated energy reference
+
+  // --- Home Assistant calibration values (multipliers, default 1) ---
+  float current_cal_{1};
+  float voltage_cal_{1};
+  float power_cal_{1};
+  float energy_cal_{1};
+
+  // --- Protocol commands ---
+  uint8_t read_command_;
+  uint8_t write_command_;
+
+  // --- Mode flags ---
+  bool legacy_mode_enabled_ = true;
+
+  // --- Methods ---
+  // Converts packed temperature value to float and updates the sensor
+  float update_temp_(sensor::Sensor *sensor, uint16_le_t packed_temperature) const;
+
+  // Validates the checksum of a received data packet
+  bool validate_checksum_(DataPacket *data);
+
+  // Handles a received data packet
+  void received_package_(DataPacket *data);
+
+  // Calculates reference values for calibration and conversion
+  float calculate_energy_reference_();
+  float calculate_power_reference_();
+  float calculate_calibration_value_(float state);
+
+  // Calibration update callbacks (used with number entities)
+  void current_calibration_callback_(float state);
+  void voltage_calibration_callback_(float state);
+  void power_calibration_callback_(float state);
+  void energy_calibration_callback_(float state);
+  void reset_calibration_callback_();
+
+  // Recalculates all reference values after calibration changes
+  void recalibrate_();
 };
+
 }  // namespace bl0940
 }  // namespace esphome

esphome/components/bl0940/button/__init__.py

@@ -0,0 +1,27 @@
+import esphome.codegen as cg
+from esphome.components import button
+import esphome.config_validation as cv
+from esphome.const import ENTITY_CATEGORY_CONFIG, ICON_RESTART
+
+from .. import CONF_BL0940_ID, bl0940_ns
+from ..sensor import BL0940
+
+CalibrationResetButton = bl0940_ns.class_(
+    "CalibrationResetButton", button.Button, cg.Component
+)
+
+CONFIG_SCHEMA = cv.All(
+    button.button_schema(
+        CalibrationResetButton,
+        entity_category=ENTITY_CATEGORY_CONFIG,
+        icon=ICON_RESTART,
+    )
+    .extend({cv.GenerateID(CONF_BL0940_ID): cv.use_id(BL0940)})
+    .extend(cv.COMPONENT_SCHEMA)
+)
+
+
+async def to_code(config):
+    var = await button.new_button(config)
+    await cg.register_component(var, config)
+    await cg.register_parented(var, config[CONF_BL0940_ID])

esphome/components/bl0940/button/calibration_reset_button.cpp

@@ -0,0 +1,20 @@
+#include "calibration_reset_button.h"
+#include "../bl0940.h"
+#include "esphome/core/hal.h"
+#include "esphome/core/log.h"
+#include "esphome/core/application.h"
+
+namespace esphome {
+namespace bl0940 {
+
+static const char *const TAG = "bl0940.button.calibration_reset";
+
+void CalibrationResetButton::dump_config() { LOG_BUTTON("", "Calibration Reset Button", this); }
+
+void CalibrationResetButton::press_action() {
+  ESP_LOGI(TAG, "Resetting calibration defaults...");
+  this->parent_->reset_calibration();
+}
+
+}  // namespace bl0940
+}  // namespace esphome

esphome/components/bl0940/button/calibration_reset_button.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/components/button/button.h"
+
+namespace esphome {
+namespace bl0940 {
+
+class BL0940;  // Forward declaration of BL0940 class
+
+class CalibrationResetButton : public button::Button, public Component, public Parented<BL0940> {
+ public:
+  void dump_config() override;
+
+  void press_action() override;
+};
+
+}  // namespace bl0940
+}  // namespace esphome

esphome/components/bl0940/number/__init__.py

@@ -0,0 +1,94 @@
+import esphome.codegen as cg
+from esphome.components import number
+import esphome.config_validation as cv
+from esphome.const import (
+    CONF_MAX_VALUE,
+    CONF_MIN_VALUE,
+    CONF_MODE,
+    CONF_RESTORE_VALUE,
+    CONF_STEP,
+    ENTITY_CATEGORY_CONFIG,
+    UNIT_PERCENT,
+)
+
+from .. import CONF_BL0940_ID, bl0940_ns
+from ..sensor import BL0940
+
+# Define calibration types
+CONF_CURRENT_CALIBRATION = "current_calibration"
+CONF_VOLTAGE_CALIBRATION = "voltage_calibration"
+CONF_POWER_CALIBRATION = "power_calibration"
+CONF_ENERGY_CALIBRATION = "energy_calibration"
+
+BL0940Number = bl0940_ns.class_("BL0940Number")
+
+CalibrationNumber = bl0940_ns.class_(
+    "CalibrationNumber", number.Number, cg.PollingComponent
+)
+
+
+def validate_min_max(config):
+    if config[CONF_MAX_VALUE] <= config[CONF_MIN_VALUE]:
+        raise cv.Invalid("max_value must be greater than min_value")
+    return config
+
+
+CALIBRATION_SCHEMA = cv.All(
+    number.number_schema(
+        CalibrationNumber,
+        entity_category=ENTITY_CATEGORY_CONFIG,
+        unit_of_measurement=UNIT_PERCENT,
+    )
+    .extend(
+        {
+            cv.Optional(CONF_MODE, default="BOX"): cv.enum(number.NUMBER_MODES),
+            cv.Optional(CONF_MAX_VALUE, default=10): cv.All(
+                cv.float_, cv.Range(max=50)
+            ),
+            cv.Optional(CONF_MIN_VALUE, default=-10): cv.All(
+                cv.float_, cv.Range(min=-50)
+            ),
+            cv.Optional(CONF_STEP, default=0.1): cv.positive_float,
+            cv.Optional(CONF_RESTORE_VALUE): cv.boolean,
+        }
+    )
+    .extend(cv.COMPONENT_SCHEMA),
+    validate_min_max,
+)
+
+# Configuration schema for BL0940 numbers
+CONFIG_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(): cv.declare_id(BL0940Number),
+        cv.GenerateID(CONF_BL0940_ID): cv.use_id(BL0940),
+        cv.Optional(CONF_CURRENT_CALIBRATION): CALIBRATION_SCHEMA,
+        cv.Optional(CONF_VOLTAGE_CALIBRATION): CALIBRATION_SCHEMA,
+        cv.Optional(CONF_POWER_CALIBRATION): CALIBRATION_SCHEMA,
+        cv.Optional(CONF_ENERGY_CALIBRATION): CALIBRATION_SCHEMA,
+    }
+)
+
+
+async def to_code(config):
+    # Get the BL0940 component instance
+    bl0940 = await cg.get_variable(config[CONF_BL0940_ID])
+
+    # Process all calibration types
+    for cal_type, setter_method in [
+        (CONF_CURRENT_CALIBRATION, "set_current_calibration_number"),
+        (CONF_VOLTAGE_CALIBRATION, "set_voltage_calibration_number"),
+        (CONF_POWER_CALIBRATION, "set_power_calibration_number"),
+        (CONF_ENERGY_CALIBRATION, "set_energy_calibration_number"),
+    ]:
+        if conf := config.get(cal_type):
+            var = await number.new_number(
+                conf,
+                min_value=conf.get(CONF_MIN_VALUE),
+                max_value=conf.get(CONF_MAX_VALUE),
+                step=conf.get(CONF_STEP),
+            )
+            await cg.register_component(var, conf)
+
+            if restore_value := config.get(CONF_RESTORE_VALUE):
+                cg.add(var.set_restore_value(restore_value))
+            cg.add(getattr(bl0940, setter_method)(var))

esphome/components/bl0940/number/calibration_number.cpp

@@ -0,0 +1,29 @@
+#include "calibration_number.h"
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace bl0940 {
+
+static const char *const TAG = "bl0940.number";
+
+void CalibrationNumber::setup() {
+  float value = 0.0f;
+  if (this->restore_value_) {
+    this->pref_ = global_preferences->make_preference<float>(this->get_object_id_hash());
+    if (!this->pref_.load(&value)) {
+      value = 0.0f;
+    }
+  }
+  this->publish_state(value);
+}
+
+void CalibrationNumber::control(float value) {
+  this->publish_state(value);
+  if (this->restore_value_)
+    this->pref_.save(&value);
+}
+
+void CalibrationNumber::dump_config() { LOG_NUMBER("", "Calibration Number", this); }
+
+}  // namespace bl0940
+}  // namespace esphome

esphome/components/bl0940/number/calibration_number.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "esphome/components/number/number.h"
+#include "esphome/core/component.h"
+#include "esphome/core/preferences.h"
+
+namespace esphome {
+namespace bl0940 {
+
+class CalibrationNumber : public number::Number, public Component {
+ public:
+  void setup() override;
+  void dump_config() override;
+  float get_setup_priority() const override { return setup_priority::HARDWARE; }
+
+  void set_restore_value(bool restore_value) { this->restore_value_ = restore_value; }
+
+ protected:
+  void control(float value) override;
+  bool restore_value_{true};
+
+  ESPPreferenceObject pref_;
+};
+
+}  // namespace bl0940
+}  // namespace esphome

esphome/components/bl0940/sensor.py

@@ -8,6 +8,7 @@ from esphome.const import (
     CONF_ID,
     CONF_INTERNAL_TEMPERATURE,
     CONF_POWER,
+    CONF_REFERENCE_VOLTAGE,
     CONF_VOLTAGE,
     DEVICE_CLASS_CURRENT,
     DEVICE_CLASS_ENERGY,
@@ -23,12 +24,133 @@ from esphome.const import (
     UNIT_WATT,
 )
 
-DEPENDENCIES = ["uart"]
+from . import bl0940_ns
 
+DEPENDENCIES = ["uart"]
 
-bl0940_ns = cg.esphome_ns.namespace("bl0940")
 BL0940 = bl0940_ns.class_("BL0940", cg.PollingComponent, uart.UARTDevice)
 
+CONF_LEGACY_MODE = "legacy_mode"
+
+CONF_READ_COMMAND = "read_command"
+CONF_WRITE_COMMAND = "write_command"
+
+CONF_RESISTOR_SHUNT = "resistor_shunt"
+CONF_RESISTOR_ONE = "resistor_one"
+CONF_RESISTOR_TWO = "resistor_two"
+
+CONF_CURRENT_REFERENCE = "current_reference"
+CONF_ENERGY_REFERENCE = "energy_reference"
+CONF_POWER_REFERENCE = "power_reference"
+CONF_VOLTAGE_REFERENCE = "voltage_reference"
+
+DEFAULT_BL0940_READ_COMMAND = 0x58
+DEFAULT_BL0940_WRITE_COMMAND = 0xA1
+
+# Values according to BL0940 application note:
+# https://www.belling.com.cn/media/file_object/bel_product/BL0940/guide/BL0940_APPNote_TSSOP14_V1.04_EN.pdf
+DEFAULT_BL0940_VREF = 1.218  # Vref = 1.218
+DEFAULT_BL0940_RL = 1  # RL = 1 mΩ
+DEFAULT_BL0940_R1 = 0.51  # R1 = 0.51 kΩ
+DEFAULT_BL0940_R2 = 1950  # R2 = 5 x 390 kΩ -> 1950 kΩ
+
+# ----------------------------------------------------
+# values from initial implementation
+DEFAULT_BL0940_LEGACY_READ_COMMAND = 0x50
+DEFAULT_BL0940_LEGACY_WRITE_COMMAND = 0xA0
+
+DEFAULT_BL0940_LEGACY_UREF = 33000
+DEFAULT_BL0940_LEGACY_IREF = 275000
+DEFAULT_BL0940_LEGACY_PREF = 1430
+# Measured to 297J  per click according to power consumption of 5 minutes
+# Converted to kWh (3.6MJ per kwH). Used to be 256 * 1638.4
+DEFAULT_BL0940_LEGACY_EREF = 3.6e6 / 297
+# ----------------------------------------------------
+
+
+# methods to calculate voltage and current reference values
+def calculate_voltage_reference(vref, r_one, r_two):
+    # formula: 79931 / Vref * (R1 * 1000) / (R1 + R2)
+    return 79931 / vref * (r_one * 1000) / (r_one + r_two)
+
+
+def calculate_current_reference(vref, r_shunt):
+    # formula: 324004 * RL / Vref
+    return 324004 * r_shunt / vref
+
+
+def calculate_power_reference(voltage_reference, current_reference):
+    # calculate power reference based on voltage and current reference
+    return voltage_reference * current_reference * 4046 / 324004 / 79931
+
+
+def calculate_energy_reference(power_reference):
+    # formula: power_reference * 3600000 / (1638.4 * 256)
+    return power_reference * 3600000 / (1638.4 * 256)
+
+
+def validate_legacy_mode(config):
+    # Only allow schematic calibration options if legacy_mode is False
+    if config.get(CONF_LEGACY_MODE, True):
+        forbidden = [
+            CONF_REFERENCE_VOLTAGE,
+            CONF_RESISTOR_SHUNT,
+            CONF_RESISTOR_ONE,
+            CONF_RESISTOR_TWO,
+        ]
+        for key in forbidden:
+            if key in config:
+                raise cv.Invalid(
+                    f"Option '{key}' is only allowed when legacy_mode: false"
+                )
+    return config
+
+
+def set_command_defaults(config):
+    # Set defaults for read_command and write_command based on legacy_mode
+    legacy = config.get(CONF_LEGACY_MODE, True)
+    if legacy:
+        config.setdefault(CONF_READ_COMMAND, DEFAULT_BL0940_LEGACY_READ_COMMAND)
+        config.setdefault(CONF_WRITE_COMMAND, DEFAULT_BL0940_LEGACY_WRITE_COMMAND)
+    else:
+        config.setdefault(CONF_READ_COMMAND, DEFAULT_BL0940_READ_COMMAND)
+        config.setdefault(CONF_WRITE_COMMAND, DEFAULT_BL0940_WRITE_COMMAND)
+    return config
+
+
+def set_reference_values(config):
+    # Set default reference values based on legacy_mode
+    if config.get(CONF_LEGACY_MODE, True):
+        config.setdefault(CONF_VOLTAGE_REFERENCE, DEFAULT_BL0940_LEGACY_UREF)
+        config.setdefault(CONF_CURRENT_REFERENCE, DEFAULT_BL0940_LEGACY_IREF)
+        config.setdefault(CONF_POWER_REFERENCE, DEFAULT_BL0940_LEGACY_PREF)
+        config.setdefault(CONF_ENERGY_REFERENCE, DEFAULT_BL0940_LEGACY_PREF)
+    else:
+        vref = config.get(CONF_VOLTAGE_REFERENCE, DEFAULT_BL0940_VREF)
+        r_one = config.get(CONF_RESISTOR_ONE, DEFAULT_BL0940_R1)
+        r_two = config.get(CONF_RESISTOR_TWO, DEFAULT_BL0940_R2)
+        r_shunt = config.get(CONF_RESISTOR_SHUNT, DEFAULT_BL0940_RL)
+
+        config.setdefault(
+            CONF_VOLTAGE_REFERENCE, calculate_voltage_reference(vref, r_one, r_two)
+        )
+        config.setdefault(
+            CONF_CURRENT_REFERENCE, calculate_current_reference(vref, r_shunt)
+        )
+        config.setdefault(
+            CONF_POWER_REFERENCE,
+            calculate_power_reference(
+                config.get(CONF_VOLTAGE_REFERENCE), config.get(CONF_CURRENT_REFERENCE)
+            ),
+        )
+        config.setdefault(
+            CONF_ENERGY_REFERENCE,
+            calculate_energy_reference(config.get(CONF_POWER_REFERENCE)),
+        )
+
+    return config
+
+
 CONFIG_SCHEMA = (
     cv.Schema(
         {
@@ -69,10 +191,24 @@ CONFIG_SCHEMA = (
                 device_class=DEVICE_CLASS_TEMPERATURE,
                 state_class=STATE_CLASS_MEASUREMENT,
             ),
+            cv.Optional(CONF_LEGACY_MODE, default=True): cv.boolean,
+            cv.Optional(CONF_READ_COMMAND): cv.hex_uint8_t,
+            cv.Optional(CONF_WRITE_COMMAND): cv.hex_uint8_t,
+            cv.Optional(CONF_REFERENCE_VOLTAGE): cv.float_,
+            cv.Optional(CONF_RESISTOR_SHUNT): cv.float_,
+            cv.Optional(CONF_RESISTOR_ONE): cv.float_,
+            cv.Optional(CONF_RESISTOR_TWO): cv.float_,
+            cv.Optional(CONF_CURRENT_REFERENCE): cv.float_,
+            cv.Optional(CONF_ENERGY_REFERENCE): cv.float_,
+            cv.Optional(CONF_POWER_REFERENCE): cv.float_,
+            cv.Optional(CONF_VOLTAGE_REFERENCE): cv.float_,
         }
     )
     .extend(cv.polling_component_schema("60s"))
     .extend(uart.UART_DEVICE_SCHEMA)
+    .add_extra(validate_legacy_mode)
+    .add_extra(set_command_defaults)
+    .add_extra(set_reference_values)
 )
 
 
@@ -99,3 +235,16 @@ async def to_code(config):
     if external_temperature_config := config.get(CONF_EXTERNAL_TEMPERATURE):
         sens = await sensor.new_sensor(external_temperature_config)
         cg.add(var.set_external_temperature_sensor(sens))
+
+    # enable legacy mode
+    cg.add(var.set_legacy_mode(config.get(CONF_LEGACY_MODE)))
+
+    # Set bl0940 commands after validator has determined which defaults to use if not set
+    cg.add(var.set_read_command(config.get(CONF_READ_COMMAND)))
+    cg.add(var.set_write_command(config.get(CONF_WRITE_COMMAND)))
+
+    # Set reference values after validator has set the values either from defaults or calculated
+    cg.add(var.set_current_reference(config.get(CONF_CURRENT_REFERENCE)))
+    cg.add(var.set_voltage_reference(config.get(CONF_VOLTAGE_REFERENCE)))
+    cg.add(var.set_power_reference(config.get(CONF_POWER_REFERENCE)))
+    cg.add(var.set_energy_reference(config.get(CONF_ENERGY_REFERENCE)))

esphome/components/bl0942/bl0942.cpp

@@ -149,7 +149,7 @@ void BL0942::setup() {
   this->write_reg_(BL0942_REG_USR_WRPROT, 0);
 
   if (this->read_reg_(BL0942_REG_MODE) != mode)
-    this->status_set_warning("BL0942 setup failed!");
+    this->status_set_warning(LOG_STR("BL0942 setup failed!"));
 
   this->flush();
 }

esphome/components/ble_client/output/__init__.py

@@ -27,7 +27,7 @@ CONFIG_SCHEMA = cv.All(
 )
 
 
-def to_code(config):
+async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     if len(config[CONF_SERVICE_UUID]) == len(esp32_ble_tracker.bt_uuid16_format):
         cg.add(
@@ -63,6 +63,6 @@ def to_code(config):
         )
         cg.add(var.set_char_uuid128(uuid128))
     cg.add(var.set_require_response(config[CONF_REQUIRE_RESPONSE]))
-    yield output.register_output(var, config)
-    yield ble_client.register_ble_node(var, config)
-    yield cg.register_component(var, config)
+    await output.register_output(var, config)
+    await ble_client.register_ble_node(var, config)
+    await cg.register_component(var, config)

esphome/components/bluetooth_proxy/__init__.py

@@ -80,7 +80,7 @@ CONFIG_SCHEMA = cv.All(
         cv.Schema(
             {
                 cv.GenerateID(): cv.declare_id(BluetoothProxy),
-                cv.Optional(CONF_ACTIVE, default=False): cv.boolean,
+                cv.Optional(CONF_ACTIVE, default=True): cv.boolean,
                 cv.SplitDefault(CONF_CACHE_SERVICES, esp32_idf=True): cv.All(
                     cv.only_with_esp_idf, cv.boolean
                 ),