esphome 2025.7.4__py3-none-any.whl → 2025.8.0b1__py3-none-any.whl

esphome/components/atm90e32/atm90e32.h

@@ -61,15 +61,29 @@ class ATM90E32Component : public PollingComponent,
     this->phase_[phase].harmonic_active_power_sensor_ = obj;
   }
   void set_peak_current_sensor(int phase, sensor::Sensor *obj) { this->phase_[phase].peak_current_sensor_ = obj; }
-  void set_volt_gain(int phase, uint16_t gain) { this->phase_[phase].voltage_gain_ = gain; }
-  void set_ct_gain(int phase, uint16_t gain) { this->phase_[phase].ct_gain_ = gain; }
-  void set_voltage_offset(uint8_t phase, int16_t offset) { this->offset_phase_[phase].voltage_offset_ = offset; }
-  void set_current_offset(uint8_t phase, int16_t offset) { this->offset_phase_[phase].current_offset_ = offset; }
+  void set_volt_gain(int phase, uint16_t gain) {
+    this->phase_[phase].voltage_gain_ = gain;
+    this->has_config_voltage_gain_[phase] = true;
+  }
+  void set_ct_gain(int phase, uint16_t gain) {
+    this->phase_[phase].ct_gain_ = gain;
+    this->has_config_current_gain_[phase] = true;
+  }
+  void set_voltage_offset(uint8_t phase, int16_t offset) {
+    this->offset_phase_[phase].voltage_offset_ = offset;
+    this->has_config_voltage_offset_[phase] = true;
+  }
+  void set_current_offset(uint8_t phase, int16_t offset) {
+    this->offset_phase_[phase].current_offset_ = offset;
+    this->has_config_current_offset_[phase] = true;
+  }
   void set_active_power_offset(uint8_t phase, int16_t offset) {
     this->power_offset_phase_[phase].active_power_offset = offset;
+    this->has_config_active_power_offset_[phase] = true;
   }
   void set_reactive_power_offset(uint8_t phase, int16_t offset) {
     this->power_offset_phase_[phase].reactive_power_offset = offset;
+    this->has_config_reactive_power_offset_[phase] = true;
   }
   void set_freq_sensor(sensor::Sensor *freq_sensor) { freq_sensor_ = freq_sensor; }
   void set_peak_current_signed(bool flag) { peak_current_signed_ = flag; }
@@ -126,8 +140,9 @@ class ATM90E32Component : public PollingComponent,
   number::Number *ref_currents_[3]{nullptr, nullptr, nullptr};
 #endif
   uint16_t read16_(uint16_t a_register);
+  uint16_t read16_transaction_(uint16_t a_register);
   int read32_(uint16_t addr_h, uint16_t addr_l);
-  void write16_(uint16_t a_register, uint16_t val);
+  void write16_(uint16_t a_register, uint16_t val, bool validate = true);
   float get_local_phase_voltage_(uint8_t phase);
   float get_local_phase_current_(uint8_t phase);
   float get_local_phase_active_power_(uint8_t phase);
@@ -159,12 +174,15 @@ class ATM90E32Component : public PollingComponent,
   void restore_offset_calibrations_();
   void restore_power_offset_calibrations_();
   void restore_gain_calibrations_();
+  void save_offset_calibration_to_memory_();
   void save_gain_calibration_to_memory_();
+  void save_power_offset_calibration_to_memory_();
   void write_offsets_to_registers_(uint8_t phase, int16_t voltage_offset, int16_t current_offset);
   void write_power_offsets_to_registers_(uint8_t phase, int16_t p_offset, int16_t q_offset);
   void write_gains_to_registers_();
   bool verify_gain_writes_();
   bool validate_spi_read_(uint16_t expected, const char *context = nullptr);
+  void log_calibration_status_();
 
   struct ATM90E32Phase {
     uint16_t voltage_gain_{0};
@@ -204,19 +222,33 @@ class ATM90E32Component : public PollingComponent,
     int16_t current_offset_{0};
   } offset_phase_[3];
 
+  OffsetCalibration config_offset_phase_[3];
+
   struct PowerOffsetCalibration {
     int16_t active_power_offset{0};
     int16_t reactive_power_offset{0};
   } power_offset_phase_[3];
 
+  PowerOffsetCalibration config_power_offset_phase_[3];
+
   struct GainCalibration {
     uint16_t voltage_gain{1};
     uint16_t current_gain{1};
   } gain_phase_[3];
 
+  GainCalibration config_gain_phase_[3];
+
+  bool has_config_voltage_offset_[3]{false, false, false};
+  bool has_config_current_offset_[3]{false, false, false};
+  bool has_config_active_power_offset_[3]{false, false, false};
+  bool has_config_reactive_power_offset_[3]{false, false, false};
+  bool has_config_voltage_gain_[3]{false, false, false};
+  bool has_config_current_gain_[3]{false, false, false};
+
   ESPPreferenceObject offset_pref_;
   ESPPreferenceObject power_offset_pref_;
   ESPPreferenceObject gain_calibration_pref_;
+  std::string cs_summary_;
 
   sensor::Sensor *freq_sensor_{nullptr};
 #ifdef USE_TEXT_SENSOR
@@ -231,6 +263,13 @@ class ATM90E32Component : public PollingComponent,
   bool peak_current_signed_{false};
   bool enable_offset_calibration_{false};
   bool enable_gain_calibration_{false};
+  bool restored_offset_calibration_{false};
+  bool restored_power_offset_calibration_{false};
+  bool restored_gain_calibration_{false};
+  bool calibration_message_printed_{false};
+  bool offset_calibration_mismatch_[3]{false, false, false};
+  bool power_offset_calibration_mismatch_[3]{false, false, false};
+  bool gain_calibration_mismatch_[3]{false, false, false};
 };
 
 }  // namespace atm90e32

esphome/components/audio/audio.h

@@ -15,7 +15,7 @@ class AudioStreamInfo {
    *  - An audio sample represents a unit of audio for one channel.
    *  - A frame represents a unit of audio with a sample for every channel.
    *
-   * In gneneral, converting between bytes, samples, and frames shouldn't result in rounding errors so long as frames
+   * In general, converting between bytes, samples, and frames shouldn't result in rounding errors so long as frames
    * are used as the main unit when transferring audio data. Durations may result in rounding for certain sample rates;
    * e.g., 44.1 KHz. The ``frames_to_milliseconds_with_remainder`` function should be used for accuracy, as it takes
    * into account the remainder rather than just ignoring any rounding.
@@ -76,7 +76,7 @@ class AudioStreamInfo {
 
   /// @brief Computes the duration, in microseconds, the given amount of frames represents.
   /// @param frames Number of audio frames
-  /// @return Duration in microseconds `frames` respresents. May be slightly inaccurate due to integer divison rounding
+  /// @return Duration in microseconds `frames` represents. May be slightly inaccurate due to integer division rounding
   ///         for certain sample rates.
   uint32_t frames_to_microseconds(uint32_t frames) const;
 

esphome/components/axs15231/touchscreen/axs15231_touchscreen.cpp

@@ -17,7 +17,6 @@ constexpr static const uint8_t AXS_READ_TOUCHPAD[11] = {0xb5, 0xab, 0xa5, 0x5a,
   }
 
 void AXS15231Touchscreen::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
   if (this->reset_pin_ != nullptr) {
     this->reset_pin_->setup();
     this->reset_pin_->digital_write(false);
@@ -36,7 +35,6 @@ void AXS15231Touchscreen::setup() {
   if (this->y_raw_max_ == 0) {
     this->y_raw_max_ = this->display_->get_native_height();
   }
-  ESP_LOGCONFIG(TAG, "AXS15231 Touchscreen setup complete");
 }
 
 void AXS15231Touchscreen::update_touches() {

esphome/components/beken_spi_led_strip/led_strip.cpp

@@ -121,8 +121,6 @@ void spi_dma_tx_finish_callback(unsigned int param) {
 }
 
 void BekenSPILEDStripLightOutput::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
-
   size_t buffer_size = this->get_buffer_size_();
   size_t dma_buffer_size = (buffer_size * 8) + (2 * 64);
 

esphome/components/bh1750/bh1750.cpp

@@ -38,7 +38,6 @@ MTreg:
 */
 
 void BH1750Sensor::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup for '%s'", this->name_.c_str());
   uint8_t turn_on = BH1750_COMMAND_POWER_ON;
   if (this->write(&turn_on, 1) != i2c::ERROR_OK) {
     this->mark_failed();

esphome/components/binary_sensor/__init__.py

@@ -266,8 +266,10 @@ async def delayed_off_filter_to_code(config, filter_id):
 async def autorepeat_filter_to_code(config, filter_id):
     timings = []
     if len(config) > 0:
-        for conf in config:
-            timings.append((conf[CONF_DELAY], conf[CONF_TIME_OFF], conf[CONF_TIME_ON]))
+        timings.extend(
+            (conf[CONF_DELAY], conf[CONF_TIME_OFF], conf[CONF_TIME_ON])
+            for conf in config
+        )
     else:
         timings.append(
             (
@@ -514,6 +516,7 @@ def binary_sensor_schema(
     icon: str = cv.UNDEFINED,
     entity_category: str = cv.UNDEFINED,
     device_class: str = cv.UNDEFINED,
+    filters: list = cv.UNDEFINED,
 ) -> cv.Schema:
     schema = {}
 
@@ -525,6 +528,7 @@ def binary_sensor_schema(
         (CONF_ICON, icon, cv.icon),
         (CONF_ENTITY_CATEGORY, entity_category, cv.entity_category),
         (CONF_DEVICE_CLASS, device_class, validate_device_class),
+        (CONF_FILTERS, filters, validate_filters),
     ]:
         if default is not cv.UNDEFINED:
             schema[cv.Optional(key, default=default)] = validator
@@ -573,16 +577,15 @@ async def setup_binary_sensor_core_(var, config):
         await automation.build_automation(trigger, [], conf)
 
     for conf in config.get(CONF_ON_MULTI_CLICK, []):
-        timings = []
-        for tim in conf[CONF_TIMING]:
-            timings.append(
-                cg.StructInitializer(
-                    MultiClickTriggerEvent,
-                    ("state", tim[CONF_STATE]),
-                    ("min_length", tim[CONF_MIN_LENGTH]),
-                    ("max_length", tim.get(CONF_MAX_LENGTH, 4294967294)),
-                )
+        timings = [
+            cg.StructInitializer(
+                MultiClickTriggerEvent,
+                ("state", tim[CONF_STATE]),
+                ("min_length", tim[CONF_MIN_LENGTH]),
+                ("max_length", tim.get(CONF_MAX_LENGTH, 4294967294)),
             )
+            for tim in conf[CONF_TIMING]
+        ]
         trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var, timings)
         if CONF_INVALID_COOLDOWN in conf:
             cg.add(trigger.set_invalid_cooldown(conf[CONF_INVALID_COOLDOWN]))
@@ -651,7 +654,6 @@ async def binary_sensor_is_off_to_code(config, condition_id, template_arg, args)
 
 @coroutine_with_priority(100.0)
 async def to_code(config):
-    cg.add_define("USE_BINARY_SENSOR")
     cg.add_global(binary_sensor_ns.using)
 
 

esphome/components/ble_client/__init__.py

@@ -175,8 +175,7 @@ BLE_REMOVE_BOND_ACTION_SCHEMA = cv.Schema(
 )
 async def ble_disconnect_to_code(config, action_id, template_arg, args):
     parent = await cg.get_variable(config[CONF_ID])
-    var = cg.new_Pvariable(action_id, template_arg, parent)
-    return var
+    return cg.new_Pvariable(action_id, template_arg, parent)
 
 
 @automation.register_action(
@@ -184,8 +183,7 @@ async def ble_disconnect_to_code(config, action_id, template_arg, args):
 )
 async def ble_connect_to_code(config, action_id, template_arg, args):
     parent = await cg.get_variable(config[CONF_ID])
-    var = cg.new_Pvariable(action_id, template_arg, parent)
-    return var
+    return cg.new_Pvariable(action_id, template_arg, parent)
 
 
 @automation.register_action(
@@ -282,14 +280,13 @@ async def passkey_reply_to_code(config, action_id, template_arg, args):
 )
 async def remove_bond_to_code(config, action_id, template_arg, args):
     parent = await cg.get_variable(config[CONF_ID])
-    var = cg.new_Pvariable(action_id, template_arg, parent)
-
-    return var
+    return cg.new_Pvariable(action_id, template_arg, parent)
 
 
 async def to_code(config):
     # Register the loggers this component needs
     esp32_ble.register_bt_logger(BTLoggers.GATT, BTLoggers.SMP)
+    cg.add_define("USE_ESP32_BLE_UUID")
 
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)

esphome/components/bluetooth_proxy/__init__.py

@@ -1,13 +1,19 @@
+import logging
+
 import esphome.codegen as cg
 from esphome.components import esp32_ble, esp32_ble_client, esp32_ble_tracker
 from esphome.components.esp32 import add_idf_sdkconfig_option
 from esphome.components.esp32_ble import BTLoggers
 import esphome.config_validation as cv
 from esphome.const import CONF_ACTIVE, CONF_ID
+from esphome.core import CORE
+from esphome.log import AnsiFore, color
 
 AUTO_LOAD = ["esp32_ble_client", "esp32_ble_tracker"]
 DEPENDENCIES = ["api", "esp32"]
-CODEOWNERS = ["@jesserockz"]
+CODEOWNERS = ["@jesserockz", "@bdraco"]
+
+_LOGGER = logging.getLogger(__name__)
 
 CONF_CONNECTION_SLOTS = "connection_slots"
 CONF_CACHE_SERVICES = "cache_services"
@@ -41,6 +47,27 @@ def validate_connections(config):
         esp32_ble_tracker.consume_connection_slots(connection_slots, "bluetooth_proxy")(
             config
         )
+
+        # Warn about connection slot waste when using Arduino framework
+        if CORE.using_arduino and connection_slots:
+            _LOGGER.warning(
+                "Bluetooth Proxy with active connections on Arduino framework has suboptimal performance.\n"
+                "If BLE connections fail, they can waste connection slots for 10 seconds because\n"
+                "Arduino doesn't allow configuring the BLE connection timeout (fixed at 30s).\n"
+                "ESP-IDF framework allows setting it to 20s to match client timeouts.\n"
+                "\n"
+                "To switch to ESP-IDF, add this to your YAML:\n"
+                "  esp32:\n"
+                "    framework:\n"
+                "      type: esp-idf\n"
+                "\n"
+                "For detailed migration instructions, see:\n"
+                "%s",
+                color(
+                    AnsiFore.BLUE, "https://esphome.io/guides/esp32_arduino_to_idf.html"
+                ),
+            )
+
         return {
             **config,
             CONF_CONNECTIONS: [CONNECTION_SCHEMA({}) for _ in range(connection_slots)],
@@ -85,13 +112,23 @@ async def to_code(config):
     await cg.register_component(var, config)
 
     cg.add(var.set_active(config[CONF_ACTIVE]))
-    await esp32_ble_tracker.register_ble_device(var, config)
+    await esp32_ble_tracker.register_raw_ble_device(var, config)
+
+    # Define max connections for protobuf fixed array
+    connection_count = len(config.get(CONF_CONNECTIONS, []))
+    cg.add_define("BLUETOOTH_PROXY_MAX_CONNECTIONS", connection_count)
+
+    # Define batch size for BLE advertisements
+    # Each advertisement is up to 80 bytes when packaged (including protocol overhead)
+    # 16 advertisements × 80 bytes (worst case) = 1280 bytes out of ~1320 bytes usable payload
+    # This achieves ~97% WiFi MTU utilization while staying under the limit
+    cg.add_define("BLUETOOTH_PROXY_ADVERTISEMENT_BATCH_SIZE", 16)
 
     for connection_conf in config.get(CONF_CONNECTIONS, []):
         connection_var = cg.new_Pvariable(connection_conf[CONF_ID])
         await cg.register_component(connection_var, connection_conf)
         cg.add(var.register_connection(connection_var))
-        await esp32_ble_tracker.register_client(connection_var, connection_conf)
+        await esp32_ble_tracker.register_raw_client(connection_var, connection_conf)
 
     if config.get(CONF_CACHE_SERVICES):
         add_idf_sdkconfig_option("CONFIG_BT_GATTC_CACHE_NVS_FLASH", True)