esphome 2025.7.5__py3-none-any.whl → 2025.8.0b2__py3-none-any.whl

esphome/components/gpio_expander/cached_gpio.h

@@ -2,10 +2,11 @@
 
 #include <array>
 #include <cstdint>
+#include <cstring>
+#include <limits>
 #include "esphome/core/hal.h"
 
-namespace esphome {
-namespace gpio_expander {
+namespace esphome::gpio_expander {
 
 /// @brief A class to cache the read state of a GPIO expander.
 ///        This class caches reads between GPIO Pins which are on the same bank.
@@ -17,12 +18,22 @@ namespace gpio_expander {
 ///           N - Number of pins
 template<typename T, T N> class CachedGpioExpander {
  public:
+  /// @brief Read the state of the given pin. This will invalidate the cache for the given pin number.
+  /// @param pin Pin number to read
+  /// @return Pin state
   bool digital_read(T pin) {
-    uint8_t bank = pin / (sizeof(T) * BITS_PER_BYTE);
-    if (this->read_cache_invalidated_[bank]) {
-      this->read_cache_invalidated_[bank] = false;
+    const uint8_t bank = pin / BANK_SIZE;
+    const T pin_mask = (1 << (pin % BANK_SIZE));
+    // Check if specific pin cache is valid
+    if (this->read_cache_valid_[bank] & pin_mask) {
+      // Invalidate pin
+      this->read_cache_valid_[bank] &= ~pin_mask;
+    } else {
+      // Read whole bank from hardware
       if (!this->digital_read_hw(pin))
         return false;
+      // Mark bank cache as valid except the pin that is being returned now
+      this->read_cache_valid_[bank] = std::numeric_limits<T>::max() & ~pin_mask;
     }
     return this->digital_read_cache(pin);
   }
@@ -36,18 +47,16 @@ template<typename T, T N> class CachedGpioExpander {
   virtual bool digital_read_cache(T pin) = 0;
   /// @brief Call component low level function to write GPIO state to device
   virtual void digital_write_hw(T pin, bool value) = 0;
-  const uint8_t cache_byte_size_ = N / (sizeof(T) * BITS_PER_BYTE);
 
   /// @brief Invalidate cache. This function should be called in component loop().
-  void reset_pin_cache_() {
-    for (T i = 0; i < this->cache_byte_size_; i++) {
-      this->read_cache_invalidated_[i] = true;
-    }
-  }
+  void reset_pin_cache_() { memset(this->read_cache_valid_, 0x00, CACHE_SIZE_BYTES); }
+
+  static constexpr uint8_t BITS_PER_BYTE = 8;
+  static constexpr uint8_t BANK_SIZE = sizeof(T) * BITS_PER_BYTE;
+  static constexpr size_t BANKS = N / BANK_SIZE;
+  static constexpr size_t CACHE_SIZE_BYTES = BANKS * sizeof(T);
 
-  static const uint8_t BITS_PER_BYTE = 8;
-  std::array<bool, N / (sizeof(T) * BITS_PER_BYTE)> read_cache_invalidated_{};
+  T read_cache_valid_[BANKS]{0};
 };
 
-}  // namespace gpio_expander
-}  // namespace esphome
+}  // namespace esphome::gpio_expander

esphome/components/gps/__init__.py

@@ -84,7 +84,6 @@ CONFIG_SCHEMA = cv.All(
     )
     .extend(cv.polling_component_schema("20s"))
     .extend(uart.UART_DEVICE_SCHEMA),
-    cv.only_with_arduino,
 )
 FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema("gps", require_rx=True)
 
@@ -123,4 +122,9 @@ async def to_code(config):
         cg.add(var.set_hdop_sensor(sens))
 
     # https://platformio.org/lib/show/1655/TinyGPSPlus
-    cg.add_library("mikalhart/TinyGPSPlus", "1.1.0")
+    # Using fork of TinyGPSPlus patched to build on ESP-IDF
+    cg.add_library(
+        "TinyGPSPlus",
+        None,
+        "https://github.com/esphome/TinyGPSPlus.git#v1.1.0",
+    )

esphome/components/gps/gps.cpp

@@ -1,5 +1,3 @@
-#ifdef USE_ARDUINO
-
 #include "gps.h"
 #include "esphome/core/log.h"
 
@@ -22,73 +20,76 @@ void GPS::dump_config() {
 }
 
 void GPS::update() {
-  if (this->latitude_sensor_ != nullptr)
+  if (this->latitude_sensor_ != nullptr) {
     this->latitude_sensor_->publish_state(this->latitude_);
+  }
 
-  if (this->longitude_sensor_ != nullptr)
+  if (this->longitude_sensor_ != nullptr) {
     this->longitude_sensor_->publish_state(this->longitude_);
+  }
 
-  if (this->speed_sensor_ != nullptr)
+  if (this->speed_sensor_ != nullptr) {
     this->speed_sensor_->publish_state(this->speed_);
+  }
 
-  if (this->course_sensor_ != nullptr)
+  if (this->course_sensor_ != nullptr) {
     this->course_sensor_->publish_state(this->course_);
+  }
 
-  if (this->altitude_sensor_ != nullptr)
+  if (this->altitude_sensor_ != nullptr) {
     this->altitude_sensor_->publish_state(this->altitude_);
+  }
 
-  if (this->satellites_sensor_ != nullptr)
+  if (this->satellites_sensor_ != nullptr) {
     this->satellites_sensor_->publish_state(this->satellites_);
+  }
 
-  if (this->hdop_sensor_ != nullptr)
+  if (this->hdop_sensor_ != nullptr) {
     this->hdop_sensor_->publish_state(this->hdop_);
+  }
 }
 
 void GPS::loop() {
   while (this->available() > 0 && !this->has_time_) {
-    if (this->tiny_gps_.encode(this->read())) {
-      if (this->tiny_gps_.location.isUpdated()) {
-        this->latitude_ = this->tiny_gps_.location.lat();
-        this->longitude_ = this->tiny_gps_.location.lng();
-
-        ESP_LOGD(TAG, "Location:");
-        ESP_LOGD(TAG, "  Lat: %.6f °", this->latitude_);
-        ESP_LOGD(TAG, "  Lon: %.6f °", this->longitude_);
-      }
-
-      if (this->tiny_gps_.speed.isUpdated()) {
-        this->speed_ = this->tiny_gps_.speed.kmph();
-        ESP_LOGD(TAG, "Speed: %.3f km/h", this->speed_);
-      }
-
-      if (this->tiny_gps_.course.isUpdated()) {
-        this->course_ = this->tiny_gps_.course.deg();
-        ESP_LOGD(TAG, "Course: %.2f °", this->course_);
-      }
-
-      if (this->tiny_gps_.altitude.isUpdated()) {
-        this->altitude_ = this->tiny_gps_.altitude.meters();
-        ESP_LOGD(TAG, "Altitude: %.2f m", this->altitude_);
-      }
-
-      if (this->tiny_gps_.satellites.isUpdated()) {
-        this->satellites_ = this->tiny_gps_.satellites.value();
-        ESP_LOGD(TAG, "Satellites: %d", this->satellites_);
-      }
-
-      if (this->tiny_gps_.hdop.isUpdated()) {
-        this->hdop_ = this->tiny_gps_.hdop.hdop();
-        ESP_LOGD(TAG, "HDOP: %.3f", this->hdop_);
-      }
-
-      for (auto *listener : this->listeners_) {
-        listener->on_update(this->tiny_gps_);
-      }
+    if (!this->tiny_gps_.encode(this->read())) {
+      continue;
+    }
+    if (this->tiny_gps_.location.isUpdated()) {
+      this->latitude_ = this->tiny_gps_.location.lat();
+      this->longitude_ = this->tiny_gps_.location.lng();
+      ESP_LOGV(TAG, "Latitude, Longitude: %.6f°, %.6f°", this->latitude_, this->longitude_);
+    }
+
+    if (this->tiny_gps_.speed.isUpdated()) {
+      this->speed_ = this->tiny_gps_.speed.kmph();
+      ESP_LOGV(TAG, "Speed: %.3f km/h", this->speed_);
+    }
+
+    if (this->tiny_gps_.course.isUpdated()) {
+      this->course_ = this->tiny_gps_.course.deg();
+      ESP_LOGV(TAG, "Course: %.2f°", this->course_);
+    }
+
+    if (this->tiny_gps_.altitude.isUpdated()) {
+      this->altitude_ = this->tiny_gps_.altitude.meters();
+      ESP_LOGV(TAG, "Altitude: %.2f m", this->altitude_);
+    }
+
+    if (this->tiny_gps_.satellites.isUpdated()) {
+      this->satellites_ = this->tiny_gps_.satellites.value();
+      ESP_LOGV(TAG, "Satellites: %d", this->satellites_);
+    }
+
+    if (this->tiny_gps_.hdop.isUpdated()) {
+      this->hdop_ = this->tiny_gps_.hdop.hdop();
+      ESP_LOGV(TAG, "HDOP: %.3f", this->hdop_);
+    }
+
+    for (auto *listener : this->listeners_) {
+      listener->on_update(this->tiny_gps_);
     }
   }
 }
 
 }  // namespace gps
 }  // namespace esphome
-
-#endif  // USE_ARDUINO

esphome/components/gps/gps.h

@@ -1,10 +1,8 @@
 #pragma once
 
-#ifdef USE_ARDUINO
-
-#include "esphome/core/component.h"
-#include "esphome/components/uart/uart.h"
 #include "esphome/components/sensor/sensor.h"
+#include "esphome/components/uart/uart.h"
+#include "esphome/core/component.h"
 #include <TinyGPSPlus.h>
 
 #include <vector>
@@ -53,8 +51,9 @@ class GPS : public PollingComponent, public uart::UARTDevice {
   float speed_{NAN};
   float course_{NAN};
   float altitude_{NAN};
-  uint16_t satellites_{0};
   float hdop_{NAN};
+  uint16_t satellites_{0};
+  bool has_time_{false};
 
   sensor::Sensor *latitude_sensor_{nullptr};
   sensor::Sensor *longitude_sensor_{nullptr};
@@ -64,12 +63,9 @@ class GPS : public PollingComponent, public uart::UARTDevice {
   sensor::Sensor *satellites_sensor_{nullptr};
   sensor::Sensor *hdop_sensor_{nullptr};
 
-  bool has_time_{false};
   TinyGPSPlus tiny_gps_;
   std::vector<GPSListener *> listeners_{};
 };
 
 }  // namespace gps
 }  // namespace esphome
-
-#endif  // USE_ARDUINO

esphome/components/gps/time/gps_time.cpp

@@ -1,5 +1,3 @@
-#ifdef USE_ARDUINO
-
 #include "gps_time.h"
 #include "esphome/core/log.h"
 
@@ -9,12 +7,10 @@ namespace gps {
 static const char *const TAG = "gps.time";
 
 void GPSTime::from_tiny_gps_(TinyGPSPlus &tiny_gps) {
-  if (!tiny_gps.time.isValid() || !tiny_gps.date.isValid())
-    return;
-  if (!tiny_gps.time.isUpdated() || !tiny_gps.date.isUpdated())
-    return;
-  if (tiny_gps.date.year() < 2019)
+  if (!tiny_gps.time.isValid() || !tiny_gps.date.isValid() || !tiny_gps.time.isUpdated() ||
+      !tiny_gps.date.isUpdated() || tiny_gps.date.year() < 2025) {
     return;
+  }
 
   ESPTime val{};
   val.year = tiny_gps.date.year();
@@ -34,5 +30,3 @@ void GPSTime::from_tiny_gps_(TinyGPSPlus &tiny_gps) {
 
 }  // namespace gps
 }  // namespace esphome
-
-#endif  // USE_ARDUINO

esphome/components/gps/time/gps_time.h

@@ -1,10 +1,8 @@
 #pragma once
 
-#ifdef USE_ARDUINO
-
-#include "esphome/core/component.h"
-#include "esphome/components/time/real_time_clock.h"
 #include "esphome/components/gps/gps.h"
+#include "esphome/components/time/real_time_clock.h"
+#include "esphome/core/component.h"
 
 namespace esphome {
 namespace gps {
@@ -13,8 +11,9 @@ class GPSTime : public time::RealTimeClock, public GPSListener {
  public:
   void update() override { this->from_tiny_gps_(this->get_tiny_gps()); };
   void on_update(TinyGPSPlus &tiny_gps) override {
-    if (!this->has_time_)
+    if (!this->has_time_) {
       this->from_tiny_gps_(tiny_gps);
+    }
   }
 
  protected:
@@ -24,5 +23,3 @@ class GPSTime : public time::RealTimeClock, public GPSListener {
 
 }  // namespace gps
 }  // namespace esphome
-
-#endif  // USE_ARDUINO

esphome/components/graph/__init__.py

@@ -116,7 +116,7 @@ GRAPH_SCHEMA = cv.Schema(
 
 
 def _relocate_fields_to_subfolder(config, subfolder, subschema):
-    fields = [k.schema for k in subschema.schema.keys()]
+    fields = [k.schema for k in subschema.schema]
     fields.remove(CONF_ID)
     if subfolder in config:
         # Ensure no ambiguous fields in base of config

esphome/components/grove_gas_mc_v2/grove_gas_mc_v2.cpp

@@ -33,7 +33,6 @@ bool GroveGasMultichannelV2Component::read_sensor_(uint8_t address, sensor::Sens
 }
 
 void GroveGasMultichannelV2Component::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
   // Before reading sensor values, must preheat sensor
   if (!(this->write_bytes(GROVE_GAS_MC_V2_HEAT_ON, {}))) {
     this->mark_failed();

esphome/components/grove_tb6612fng/grove_tb6612fng.cpp

@@ -24,7 +24,6 @@ void GroveMotorDriveTB6612FNG::dump_config() {
 }
 
 void GroveMotorDriveTB6612FNG::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
   if (!this->standby()) {
     this->mark_failed();
     return;

esphome/components/gt911/touchscreen/gt911_touchscreen.cpp

@@ -20,13 +20,11 @@ static const size_t MAX_BUTTONS = 4;  // max number of buttons scanned
 
 #define ERROR_CHECK(err) \
   if ((err) != i2c::ERROR_OK) { \
-    this->status_set_warning("Communication failure"); \
+    this->status_set_warning(ESP_LOG_MSG_COMM_FAIL); \
     return; \
   }
 
 void GT911Touchscreen::setup() {
-  i2c::ErrorCode err;
-  ESP_LOGCONFIG(TAG, "Running setup");
   if (this->reset_pin_ != nullptr) {
     this->reset_pin_->setup();
     this->reset_pin_->digital_write(false);
@@ -36,9 +34,14 @@ void GT911Touchscreen::setup() {
       this->interrupt_pin_->digital_write(false);
     }
     delay(2);
-    this->reset_pin_->digital_write(true);
-    delay(50);  // NOLINT
+    this->reset_pin_->digital_write(true);  // wait 50ms after reset
+    this->set_timeout(50, [this] { this->setup_internal_(); });
+    return;
   }
+  this->setup_internal_();
+}
+
+void GT911Touchscreen::setup_internal_() {
   if (this->interrupt_pin_ != nullptr) {
     // set pre-configured input mode
     this->interrupt_pin_->setup();
@@ -46,7 +49,7 @@ void GT911Touchscreen::setup() {
 
   // check the configuration of the int line.
   uint8_t data[4];
-  err = this->write(GET_SWITCHES, sizeof(GET_SWITCHES));
+  i2c::ErrorCode err = this->write(GET_SWITCHES, sizeof(GET_SWITCHES));
   if (err != i2c::ERROR_OK && this->address_ == PRIMARY_ADDRESS) {
     this->address_ = SECONDARY_ADDRESS;
     err = this->write(GET_SWITCHES, sizeof(GET_SWITCHES));
@@ -54,7 +57,7 @@ void GT911Touchscreen::setup() {
   if (err == i2c::ERROR_OK) {
     err = this->read(data, 1);
     if (err == i2c::ERROR_OK) {
-      ESP_LOGD(TAG, "Read from switches at address 0x%02X: 0x%02X", this->address_, data[0]);
+      ESP_LOGD(TAG, "Switches ADDR: 0x%02X DATA: 0x%02X", this->address_, data[0]);
       if (this->interrupt_pin_ != nullptr) {
         this->attach_interrupt_(this->interrupt_pin_,
                                 (data[0] & 1) ? gpio::INTERRUPT_FALLING_EDGE : gpio::INTERRUPT_RISING_EDGE);
@@ -76,18 +79,24 @@ void GT911Touchscreen::setup() {
       }
     }
     if (err != i2c::ERROR_OK) {
-      this->mark_failed("Failed to read calibration");
+      this->mark_failed("Calibration error");
       return;
     }
   }
+
   if (err != i2c::ERROR_OK) {
-    this->mark_failed("Failed to communicate");
+    this->mark_failed(ESP_LOG_MSG_COMM_FAIL);
+    return;
   }
-
-  ESP_LOGCONFIG(TAG, "GT911 Touchscreen setup complete");
+  this->setup_done_ = true;
 }
 
 void GT911Touchscreen::update_touches() {
+  this->skip_update_ = true;  // skip send touch events by default, set to false after successful error checks
+  if (!this->setup_done_) {
+    return;
+  }
+
   i2c::ErrorCode err;
   uint8_t touch_state = 0;
   uint8_t data[MAX_TOUCHES + 1][8];  // 8 bytes each for each point, plus extra space for the key byte
@@ -100,7 +109,6 @@ void GT911Touchscreen::update_touches() {
   uint8_t num_of_touches = touch_state & 0x07;
 
   if ((touch_state & 0x80) == 0 || num_of_touches > MAX_TOUCHES) {
-    this->skip_update_ = true;  // skip send touch events, touchscreen is not ready yet.
     return;
   }
 
@@ -110,6 +118,7 @@ void GT911Touchscreen::update_touches() {
   err = this->read(data[0], sizeof(data[0]) * num_of_touches + 1);
   ERROR_CHECK(err);
 
+  this->skip_update_ = false;  // All error checks passed, send touch events
   for (uint8_t i = 0; i != num_of_touches; i++) {
     uint16_t id = data[i][0];
     uint16_t x = encode_uint16(data[i][2], data[i][1]);

esphome/components/gt911/touchscreen/gt911_touchscreen.h

@@ -15,8 +15,20 @@ class GT911ButtonListener {
 
 class GT911Touchscreen : public touchscreen::Touchscreen, public i2c::I2CDevice {
  public:
+  /// @brief Initialize the GT911 touchscreen.
+  ///
+  /// If @ref reset_pin_ is set, the touchscreen will be hardware reset,
+  /// and the rest of the setup will be scheduled to run 50ms later using @ref set_timeout()
+  /// to allow the device to stabilize after reset.
+  ///
+  /// If @ref interrupt_pin_ is set, it will be temporarily configured during reset
+  /// to control I2C address selection.
+  ///
+  /// After the timeout, or immediately if no reset is performed, @ref setup_internal_()
+  /// is called to complete the initialization.
   void setup() override;
   void dump_config() override;
+  bool can_proceed() override { return this->setup_done_; }
 
   void set_interrupt_pin(InternalGPIOPin *pin) { this->interrupt_pin_ = pin; }
   void set_reset_pin(GPIOPin *pin) { this->reset_pin_ = pin; }
@@ -25,8 +37,20 @@ class GT911Touchscreen : public touchscreen::Touchscreen, public i2c::I2CDevice
  protected:
   void update_touches() override;
 
-  InternalGPIOPin *interrupt_pin_{};
-  GPIOPin *reset_pin_{};
+  /// @brief Perform the internal setup routine for the GT911 touchscreen.
+  ///
+  /// This function checks the I2C address, configures the interrupt pin (if available),
+  /// reads the touchscreen mode from the controller, and attempts to read calibration
+  /// data (maximum X and Y values) if not already set.
+  ///
+  /// On success, sets @ref setup_done_ to true.
+  /// On failure, calls @ref mark_failed() with an appropriate error message.
+  void setup_internal_();
+  /// @brief True if the touchscreen setup has completed successfully.
+  bool setup_done_{false};
+
+  InternalGPIOPin *interrupt_pin_{nullptr};
+  GPIOPin *reset_pin_{nullptr};
   std::vector<GT911ButtonListener *> button_listeners_;
   uint8_t button_state_{0xFF};  // last button state. Initial FF guarantees first update.
 };

esphome/components/haier/climate.py

@@ -330,8 +330,7 @@ HAIER_HON_BASE_ACTION_SCHEMA = automation.maybe_simple_id(
 )
 async def display_action_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
-    var = cg.new_Pvariable(action_id, template_arg, paren)
-    return var
+    return cg.new_Pvariable(action_id, template_arg, paren)
 
 
 @automation.register_action(
@@ -342,8 +341,7 @@ async def display_action_to_code(config, action_id, template_arg, args):
 )
 async def beeper_action_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
-    var = cg.new_Pvariable(action_id, template_arg, paren)
-    return var
+    return cg.new_Pvariable(action_id, template_arg, paren)
 
 
 # Start self cleaning or steri-cleaning action action
@@ -359,8 +357,7 @@ async def beeper_action_to_code(config, action_id, template_arg, args):
 )
 async def start_cleaning_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
-    var = cg.new_Pvariable(action_id, template_arg, paren)
-    return var
+    return cg.new_Pvariable(action_id, template_arg, paren)
 
 
 # Set vertical airflow direction action
@@ -417,8 +414,7 @@ async def haier_set_horizontal_airflow_to_code(config, action_id, template_arg,
 )
 async def health_action_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
-    var = cg.new_Pvariable(action_id, template_arg, paren)
-    return var
+    return cg.new_Pvariable(action_id, template_arg, paren)
 
 
 @automation.register_action(
@@ -432,8 +428,7 @@ async def health_action_to_code(config, action_id, template_arg, args):
 )
 async def power_action_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
-    var = cg.new_Pvariable(action_id, template_arg, paren)
-    return var
+    return cg.new_Pvariable(action_id, template_arg, paren)
 
 
 def _final_validate(config):

esphome/components/haier/haier_base.cpp

@@ -242,7 +242,6 @@ haier_protocol::HandlerError HaierClimateBase::timeout_default_handler_(haier_pr
 }
 
 void HaierClimateBase::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
   // Set timestamp here to give AC time to boot
   this->last_request_timestamp_ = std::chrono::steady_clock::now();
   this->set_phase(ProtocolPhases::SENDING_INIT_1);

esphome/components/hbridge/switch/hbridge_switch.cpp

@@ -10,8 +10,6 @@ static const char *const TAG = "switch.hbridge";
 
 float HBridgeSwitch::get_setup_priority() const { return setup_priority::HARDWARE; }
 void HBridgeSwitch::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup for '%s'", this->name_.c_str());
-
   optional<bool> initial_state = this->get_initial_state_with_restore_mode();
 
   // Like GPIOSwitch does, set the pin state both before and after pin setup()

esphome/components/hdc1080/hdc1080.cpp

@@ -13,8 +13,6 @@ static const uint8_t HDC1080_CMD_TEMPERATURE = 0x00;
 static const uint8_t HDC1080_CMD_HUMIDITY = 0x01;
 
 void HDC1080Component::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
-
   const uint8_t data[2] = {
       0b00000000,  // resolution 14bit for both humidity and temperature
       0b00000000   // reserved

esphome/components/heatpumpir/climate.py

@@ -126,6 +126,6 @@ async def to_code(config):
     cg.add(var.set_max_temperature(config[CONF_MAX_TEMPERATURE]))
     cg.add(var.set_min_temperature(config[CONF_MIN_TEMPERATURE]))
 
-    cg.add_library("tonia/HeatpumpIR", "1.0.35")
-    if CORE.is_libretiny:
+    cg.add_library("tonia/HeatpumpIR", "1.0.37")
+    if CORE.is_libretiny or CORE.is_esp32:
         CORE.add_platformio_option("lib_ignore", "IRremoteESP8266")

esphome/components/hlw8012/hlw8012.cpp

@@ -11,7 +11,6 @@ static const uint32_t HLW8012_CLOCK_FREQUENCY = 3579000;
 
 void HLW8012Component::setup() {
   float reference_voltage = 0;
-  ESP_LOGCONFIG(TAG, "Running setup");
   this->sel_pin_->setup();
   this->sel_pin_->digital_write(this->current_mode_);
   this->cf_store_.pulse_counter_setup(this->cf_pin_);

esphome/components/hm3301/hm3301.cpp

@@ -11,7 +11,6 @@ static const uint8_t PM_2_5_VALUE_INDEX = 6;
 static const uint8_t PM_10_0_VALUE_INDEX = 7;
 
 void HM3301Component::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
   if (i2c::ERROR_OK != this->write(&SELECT_COMM_CMD, 1)) {
     error_code_ = ERROR_COMM;
     this->mark_failed();

esphome/components/hmc5883l/hmc5883l.cpp

@@ -22,7 +22,6 @@ static const uint8_t HMC5883L_REGISTER_IDENTIFICATION_B = 0x0B;
 static const uint8_t HMC5883L_REGISTER_IDENTIFICATION_C = 0x0C;
 
 void HMC5883LComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
   uint8_t id[3];
   if (!this->read_byte(HMC5883L_REGISTER_IDENTIFICATION_A, &id[0]) ||
       !this->read_byte(HMC5883L_REGISTER_IDENTIFICATION_B, &id[1]) ||

esphome/components/homeassistant/__init__.py

@@ -38,3 +38,4 @@ def setup_home_assistant_entity(var, config):
     cg.add(var.set_entity_id(config[CONF_ENTITY_ID]))
     if CONF_ATTRIBUTE in config:
         cg.add(var.set_attribute(config[CONF_ATTRIBUTE]))
+    cg.add_define("USE_API_HOMEASSISTANT_STATES")

esphome/components/homeassistant/number/__init__.py

@@ -23,6 +23,7 @@ CONFIG_SCHEMA = (
 
 
 async def to_code(config):
+    cg.add_define("USE_API_HOMEASSISTANT_SERVICES")
     var = await number.new_number(
         config,
         min_value=0,

esphome/components/homeassistant/number/homeassistant_number.cpp

@@ -83,18 +83,22 @@ void HomeassistantNumber::control(float value) {
 
   this->publish_state(value);
 
+  static constexpr auto SERVICE_NAME = StringRef::from_lit("number.set_value");
+  static constexpr auto ENTITY_ID_KEY = StringRef::from_lit("entity_id");
+  static constexpr auto VALUE_KEY = StringRef::from_lit("value");
+
   api::HomeassistantServiceResponse resp;
-  resp.service = "number.set_value";
+  resp.set_service(SERVICE_NAME);
 
-  api::HomeassistantServiceMap entity_id;
-  entity_id.key = "entity_id";
+  resp.data.emplace_back();
+  auto &entity_id = resp.data.back();
+  entity_id.set_key(ENTITY_ID_KEY);
   entity_id.value = this->entity_id_;
-  resp.data.push_back(entity_id);
 
-  api::HomeassistantServiceMap entity_value;
-  entity_value.key = "value";
+  resp.data.emplace_back();
+  auto &entity_value = resp.data.back();
+  entity_value.set_key(VALUE_KEY);
   entity_value.value = to_string(value);
-  resp.data.push_back(entity_value);
 
   api::global_api_server->send_homeassistant_service_call(resp);
 }

esphome/components/homeassistant/switch/__init__.py

@@ -37,6 +37,7 @@ CONFIG_SCHEMA = cv.All(
 
 
 async def to_code(config):
+    cg.add_define("USE_API_HOMEASSISTANT_SERVICES")
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
     await switch.register_switch(var, config)