esphome 2025.5.1__py3-none-any.whl → 2025.6.0b1__py3-none-any.whl

esphome/components/openthread_info/openthread_info_text_sensor.h

@@ -0,0 +1,218 @@
+#pragma once
+
+#include "esphome/components/openthread/openthread.h"
+#include "esphome/components/text_sensor/text_sensor.h"
+#include "esphome/core/component.h"
+#ifdef USE_OPENTHREAD
+
+namespace esphome {
+namespace openthread_info {
+
+using esphome::openthread::InstanceLock;
+
+class OpenThreadInstancePollingComponent : public PollingComponent {
+ public:
+  void update() override {
+    auto lock = InstanceLock::try_acquire(10);
+    if (!lock) {
+      return;
+    }
+
+    this->update_instance(lock->get_instance());
+  }
+  float get_setup_priority() const override { return setup_priority::AFTER_WIFI; }
+
+ protected:
+  virtual void update_instance(otInstance *instance) = 0;
+};
+
+class IPAddressOpenThreadInfo : public PollingComponent, public text_sensor::TextSensor {
+ public:
+  void update() override {
+    std::optional<otIp6Address> address = openthread::global_openthread_component->get_omr_address();
+    if (!address) {
+      return;
+    }
+
+    char address_as_string[40];
+    otIp6AddressToString(&*address, address_as_string, 40);
+    std::string ip = address_as_string;
+
+    if (this->last_ip_ != ip) {
+      this->last_ip_ = ip;
+      this->publish_state(this->last_ip_);
+    }
+  }
+  float get_setup_priority() const override { return setup_priority::AFTER_WIFI; }
+  void dump_config() override;
+
+ protected:
+  std::string last_ip_;
+};
+
+class RoleOpenThreadInfo : public OpenThreadInstancePollingComponent, public text_sensor::TextSensor {
+ public:
+  void update_instance(otInstance *instance) override {
+    otDeviceRole role = otThreadGetDeviceRole(instance);
+
+    if (this->last_role_ != role) {
+      this->last_role_ = role;
+      this->publish_state(otThreadDeviceRoleToString(this->last_role_));
+    }
+  }
+  void dump_config() override;
+
+ protected:
+  otDeviceRole last_role_;
+};
+
+class Rloc16OpenThreadInfo : public OpenThreadInstancePollingComponent, public text_sensor::TextSensor {
+ public:
+  void update_instance(otInstance *instance) override {
+    uint16_t rloc16 = otThreadGetRloc16(instance);
+    if (this->last_rloc16_ != rloc16) {
+      this->last_rloc16_ = rloc16;
+      char buf[5];
+      snprintf(buf, sizeof(buf), "%04x", rloc16);
+      this->publish_state(buf);
+    }
+  }
+  float get_setup_priority() const override { return setup_priority::AFTER_WIFI; }
+  void dump_config() override;
+
+ protected:
+  uint16_t last_rloc16_;
+};
+
+class ExtAddrOpenThreadInfo : public OpenThreadInstancePollingComponent, public text_sensor::TextSensor {
+ public:
+  void update_instance(otInstance *instance) override {
+    const auto *extaddr = otLinkGetExtendedAddress(instance);
+    if (!std::equal(this->last_extaddr_.begin(), this->last_extaddr_.end(), extaddr->m8)) {
+      std::copy(extaddr->m8, extaddr->m8 + 8, this->last_extaddr_.begin());
+      this->publish_state(format_hex(extaddr->m8, 8));
+    }
+  }
+  float get_setup_priority() const override { return setup_priority::AFTER_WIFI; }
+  void dump_config() override;
+
+ protected:
+  std::array<uint8_t, 8> last_extaddr_{};
+};
+
+class Eui64OpenThreadInfo : public OpenThreadInstancePollingComponent, public text_sensor::TextSensor {
+ public:
+  void update_instance(otInstance *instance) override {
+    otExtAddress addr;
+    otLinkGetFactoryAssignedIeeeEui64(instance, &addr);
+
+    if (!std::equal(this->last_eui64_.begin(), this->last_eui64_.end(), addr.m8)) {
+      std::copy(addr.m8, addr.m8 + 8, this->last_eui64_.begin());
+      this->publish_state(format_hex(this->last_eui64_.begin(), 8));
+    }
+  }
+  float get_setup_priority() const override { return setup_priority::AFTER_WIFI; }
+  void dump_config() override;
+
+ protected:
+  std::array<uint8_t, 8> last_eui64_{};
+};
+
+class ChannelOpenThreadInfo : public OpenThreadInstancePollingComponent, public text_sensor::TextSensor {
+ public:
+  void update_instance(otInstance *instance) override {
+    uint8_t channel = otLinkGetChannel(instance);
+    if (this->last_channel_ != channel) {
+      this->last_channel_ = channel;
+      this->publish_state(std::to_string(this->last_channel_));
+    }
+  }
+  float get_setup_priority() const override { return setup_priority::AFTER_WIFI; }
+  void dump_config() override;
+
+ protected:
+  uint8_t last_channel_;
+};
+
+class DatasetOpenThreadInfo : public OpenThreadInstancePollingComponent {
+ public:
+  void update_instance(otInstance *instance) override {
+    otOperationalDataset dataset;
+    if (otDatasetGetActive(instance, &dataset) != OT_ERROR_NONE) {
+      return;
+    }
+
+    this->update_dataset(&dataset);
+  }
+
+ protected:
+  virtual void update_dataset(otOperationalDataset *dataset) = 0;
+};
+
+class NetworkNameOpenThreadInfo : public DatasetOpenThreadInfo, public text_sensor::TextSensor {
+ public:
+  void update_dataset(otOperationalDataset *dataset) override {
+    if (this->last_network_name_ != dataset->mNetworkName.m8) {
+      this->last_network_name_ = dataset->mNetworkName.m8;
+      this->publish_state(this->last_network_name_);
+    }
+  }
+  float get_setup_priority() const override { return setup_priority::AFTER_WIFI; }
+  void dump_config() override;
+
+ protected:
+  std::string last_network_name_;
+};
+
+class NetworkKeyOpenThreadInfo : public DatasetOpenThreadInfo, public text_sensor::TextSensor {
+ public:
+  void update_dataset(otOperationalDataset *dataset) override {
+    if (!std::equal(this->last_key_.begin(), this->last_key_.end(), dataset->mNetworkKey.m8)) {
+      std::copy(dataset->mNetworkKey.m8, dataset->mNetworkKey.m8 + 16, this->last_key_.begin());
+      this->publish_state(format_hex(dataset->mNetworkKey.m8, 16));
+    }
+  }
+  float get_setup_priority() const override { return setup_priority::AFTER_WIFI; }
+  void dump_config() override;
+
+ protected:
+  std::array<uint8_t, 16> last_key_{};
+};
+
+class PanIdOpenThreadInfo : public DatasetOpenThreadInfo, public text_sensor::TextSensor {
+ public:
+  void update_dataset(otOperationalDataset *dataset) override {
+    uint16_t panid = dataset->mPanId;
+    if (this->last_panid_ != panid) {
+      this->last_panid_ = panid;
+      char buf[5];
+      snprintf(buf, sizeof(buf), "%04x", panid);
+      this->publish_state(buf);
+    }
+  }
+  float get_setup_priority() const override { return setup_priority::AFTER_WIFI; }
+  void dump_config() override;
+
+ protected:
+  uint16_t last_panid_;
+};
+
+class ExtPanIdOpenThreadInfo : public DatasetOpenThreadInfo, public text_sensor::TextSensor {
+ public:
+  void update_dataset(otOperationalDataset *dataset) override {
+    if (!std::equal(this->last_extpanid_.begin(), this->last_extpanid_.end(), dataset->mExtendedPanId.m8)) {
+      std::copy(dataset->mExtendedPanId.m8, dataset->mExtendedPanId.m8 + 8, this->last_extpanid_.begin());
+      this->publish_state(format_hex(this->last_extpanid_.begin(), 8));
+    }
+  }
+
+  float get_setup_priority() const override { return setup_priority::AFTER_WIFI; }
+  void dump_config() override;
+
+ protected:
+  std::array<uint8_t, 8> last_extpanid_{};
+};
+
+}  // namespace openthread_info
+}  // namespace esphome
+#endif

esphome/components/openthread_info/text_sensor.py

@@ -0,0 +1,105 @@
+import esphome.codegen as cg
+from esphome.components import text_sensor
+from esphome.components.openthread.const import (
+    CONF_EXT_PAN_ID,
+    CONF_NETWORK_KEY,
+    CONF_NETWORK_NAME,
+    CONF_PAN_ID,
+)
+import esphome.config_validation as cv
+from esphome.const import CONF_CHANNEL, CONF_IP_ADDRESS, ENTITY_CATEGORY_DIAGNOSTIC
+
+CONF_ROLE = "role"
+CONF_RLOC16 = "rloc16"
+CONF_EUI64 = "eui64"
+CONF_EXT_ADDR = "ext_addr"
+
+
+DEPENDENCIES = ["openthread"]
+
+openthread_info_ns = cg.esphome_ns.namespace("openthread_info")
+IPAddressOpenThreadInfo = openthread_info_ns.class_(
+    "IPAddressOpenThreadInfo", text_sensor.TextSensor, cg.PollingComponent
+)
+RoleOpenThreadInfo = openthread_info_ns.class_(
+    "RoleOpenThreadInfo", text_sensor.TextSensor, cg.PollingComponent
+)
+Rloc16OpenThreadInfo = openthread_info_ns.class_(
+    "Rloc16OpenThreadInfo", text_sensor.TextSensor, cg.PollingComponent
+)
+ExtAddrOpenThreadInfo = openthread_info_ns.class_(
+    "ExtAddrOpenThreadInfo", text_sensor.TextSensor, cg.PollingComponent
+)
+Eui64OpenThreadInfo = openthread_info_ns.class_(
+    "Eui64OpenThreadInfo", text_sensor.TextSensor, cg.Component
+)
+ChannelOpenThreadInfo = openthread_info_ns.class_(
+    "ChannelOpenThreadInfo", text_sensor.TextSensor, cg.PollingComponent
+)
+NetworkNameOpenThreadInfo = openthread_info_ns.class_(
+    "NetworkNameOpenThreadInfo", text_sensor.TextSensor, cg.PollingComponent
+)
+NetworkKeyOpenThreadInfo = openthread_info_ns.class_(
+    "NetworkKeyOpenThreadInfo", text_sensor.TextSensor, cg.PollingComponent
+)
+PanIdOpenThreadInfo = openthread_info_ns.class_(
+    "PanIdOpenThreadInfo", text_sensor.TextSensor, cg.PollingComponent
+)
+ExtPanIdOpenThreadInfo = openthread_info_ns.class_(
+    "ExtPanIdOpenThreadInfo", text_sensor.TextSensor, cg.PollingComponent
+)
+
+
+CONFIG_SCHEMA = cv.Schema(
+    {
+        cv.Optional(CONF_IP_ADDRESS): text_sensor.text_sensor_schema(
+            IPAddressOpenThreadInfo, entity_category=ENTITY_CATEGORY_DIAGNOSTIC
+        ),
+        cv.Optional(CONF_ROLE): text_sensor.text_sensor_schema(
+            RoleOpenThreadInfo, entity_category=ENTITY_CATEGORY_DIAGNOSTIC
+        ).extend(cv.polling_component_schema("1s")),
+        cv.Optional(CONF_RLOC16): text_sensor.text_sensor_schema(
+            Rloc16OpenThreadInfo, entity_category=ENTITY_CATEGORY_DIAGNOSTIC
+        ).extend(cv.polling_component_schema("1s")),
+        cv.Optional(CONF_EXT_ADDR): text_sensor.text_sensor_schema(
+            ExtAddrOpenThreadInfo, entity_category=ENTITY_CATEGORY_DIAGNOSTIC
+        ).extend(cv.polling_component_schema("1s")),
+        cv.Optional(CONF_EUI64): text_sensor.text_sensor_schema(
+            Eui64OpenThreadInfo, entity_category=ENTITY_CATEGORY_DIAGNOSTIC
+        ).extend(cv.polling_component_schema("1h")),
+        cv.Optional(CONF_CHANNEL): text_sensor.text_sensor_schema(
+            ChannelOpenThreadInfo, entity_category=ENTITY_CATEGORY_DIAGNOSTIC
+        ).extend(cv.polling_component_schema("1s")),
+        cv.Optional(CONF_NETWORK_NAME): text_sensor.text_sensor_schema(
+            NetworkNameOpenThreadInfo, entity_category=ENTITY_CATEGORY_DIAGNOSTIC
+        ).extend(cv.polling_component_schema("1s")),
+        cv.Optional(CONF_NETWORK_KEY): text_sensor.text_sensor_schema(
+            NetworkKeyOpenThreadInfo, entity_category=ENTITY_CATEGORY_DIAGNOSTIC
+        ).extend(cv.polling_component_schema("1s")),
+        cv.Optional(CONF_PAN_ID): text_sensor.text_sensor_schema(  # noqa: F821
+            PanIdOpenThreadInfo, entity_category=ENTITY_CATEGORY_DIAGNOSTIC
+        ).extend(cv.polling_component_schema("1s")),
+        cv.Optional(CONF_EXT_PAN_ID): text_sensor.text_sensor_schema(
+            ExtPanIdOpenThreadInfo, entity_category=ENTITY_CATEGORY_DIAGNOSTIC
+        ).extend(cv.polling_component_schema("1s")),
+    }
+)
+
+
+async def setup_conf(config: dict, key: str):
+    if conf := config.get(key):
+        var = await text_sensor.new_text_sensor(conf)
+        await cg.register_component(var, conf)
+
+
+async def to_code(config):
+    await setup_conf(config, CONF_IP_ADDRESS)
+    await setup_conf(config, CONF_ROLE)
+    await setup_conf(config, CONF_RLOC16)
+    await setup_conf(config, CONF_EXT_ADDR)
+    await setup_conf(config, CONF_EUI64)
+    await setup_conf(config, CONF_CHANNEL)
+    await setup_conf(config, CONF_NETWORK_NAME)
+    await setup_conf(config, CONF_NETWORK_KEY)
+    await setup_conf(config, CONF_PAN_ID)
+    await setup_conf(config, CONF_EXT_PAN_ID)

esphome/components/output/float_output.cpp

@@ -1,6 +1,6 @@
 #include "float_output.h"
-#include "esphome/core/log.h"
 #include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 
 namespace esphome {
 namespace output {

esphome/components/output/switch/output_switch.cpp

@@ -8,7 +8,7 @@ static const char *const TAG = "output.switch";
 
 void OutputSwitch::dump_config() { LOG_SWITCH("", "Output Switch", this); }
 void OutputSwitch::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up Output Switch '%s'...", this->name_.c_str());
+  ESP_LOGCONFIG(TAG, "Running setup for '%s'", this->name_.c_str());
 
   bool initial_state = this->get_initial_state_with_restore_mode().value_or(false);
 

esphome/components/packet_transport/packet_transport.cpp

@@ -474,10 +474,12 @@ void PacketTransport::process_(const std::vector<uint8_t> &data) {
 }
 
 void PacketTransport::dump_config() {
-  ESP_LOGCONFIG(TAG, "Packet Transport:");
-  ESP_LOGCONFIG(TAG, "  Platform: %s", this->platform_name_);
-  ESP_LOGCONFIG(TAG, "  Encrypted: %s", YESNO(this->is_encrypted_()));
-  ESP_LOGCONFIG(TAG, "  Ping-pong: %s", YESNO(this->ping_pong_enable_));
+  ESP_LOGCONFIG(TAG,
+                "Packet Transport:\n"
+                "  Platform: %s\n"
+                "  Encrypted: %s\n"
+                "  Ping-pong: %s",
+                this->platform_name_, YESNO(this->is_encrypted_()), YESNO(this->ping_pong_enable_));
 #ifdef USE_SENSOR
   for (auto sensor : this->sensors_)
     ESP_LOGCONFIG(TAG, "  Sensor: %s", sensor.id);

esphome/components/pca6416a/pca6416a.cpp

@@ -24,7 +24,7 @@ enum PCA6416AGPIORegisters {
 static const char *const TAG = "pca6416a";
 
 void PCA6416AComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up PCA6416A...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   // Test to see if device exists
   uint8_t value;
   if (!this->read_register_(PCA6416A_INPUT0, &value)) {
@@ -60,7 +60,7 @@ void PCA6416AComponent::dump_config() {
   }
   LOG_I2C_DEVICE(this)
   if (this->is_failed()) {
-    ESP_LOGE(TAG, "Communication with PCA6416A failed!");
+    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
   }
 }
 

esphome/components/pca9554/pca9554.cpp

@@ -13,7 +13,7 @@ const uint8_t CONFIG_REG = 3;
 static const char *const TAG = "pca9554";
 
 void PCA9554Component::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up PCA9554/PCA9554A...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   this->reg_width_ = (this->pin_count_ + 7) / 8;
   // Test to see if device exists
   if (!this->read_inputs_()) {
@@ -45,11 +45,13 @@ void PCA9554Component::loop() {
 }
 
 void PCA9554Component::dump_config() {
-  ESP_LOGCONFIG(TAG, "PCA9554:");
-  ESP_LOGCONFIG(TAG, "  I/O Pins: %d", this->pin_count_);
+  ESP_LOGCONFIG(TAG,
+                "PCA9554:\n"
+                "  I/O Pins: %d",
+                this->pin_count_);
   LOG_I2C_DEVICE(this)
   if (this->is_failed()) {
-    ESP_LOGE(TAG, "Communication with PCA9554 failed!");
+    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
   }
 }
 

esphome/components/pca9685/pca9685_output.cpp

@@ -1,7 +1,7 @@
 #include "pca9685_output.h"
-#include "esphome/core/log.h"
-#include "esphome/core/helpers.h"
 #include "esphome/core/hal.h"
+#include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 
 namespace esphome {
 namespace pca9685 {
@@ -26,9 +26,9 @@ static const uint8_t PCA9685_MODE1_AUTOINC = 0b00100000;
 static const uint8_t PCA9685_MODE1_SLEEP = 0b00010000;
 
 void PCA9685Output::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up PCA9685OutputComponent...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 
-  ESP_LOGV(TAG, "  Resetting devices...");
+  ESP_LOGV(TAG, "  Resetting devices");
   if (!this->write_bytes(PCA9685_REGISTER_SOFTWARE_RESET, nullptr, 0)) {
     this->mark_failed();
     return;
@@ -83,13 +83,17 @@ void PCA9685Output::setup() {
 }
 
 void PCA9685Output::dump_config() {
-  ESP_LOGCONFIG(TAG, "PCA9685:");
-  ESP_LOGCONFIG(TAG, "  Mode: 0x%02X", this->mode_);
+  ESP_LOGCONFIG(TAG,
+                "PCA9685:\n"
+                "  Mode: 0x%02X",
+                this->mode_);
   if (this->extclk_) {
     ESP_LOGCONFIG(TAG, "  EXTCLK: enabled");
   } else {
-    ESP_LOGCONFIG(TAG, "  EXTCLK: disabled");
-    ESP_LOGCONFIG(TAG, "  Frequency: %.0f Hz", this->frequency_);
+    ESP_LOGCONFIG(TAG,
+                  "  EXTCLK: disabled\n"
+                  "  Frequency: %.0f Hz",
+                  this->frequency_);
   }
   if (this->is_failed()) {
     ESP_LOGE(TAG, "Setting up PCA9685 failed!");

esphome/components/pcd8544/pcd_8544.cpp

@@ -1,7 +1,7 @@
 #include "pcd_8544.h"
-#include "esphome/core/log.h"
 #include "esphome/core/application.h"
 #include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 
 namespace esphome {
 namespace pcd8544 {

esphome/components/pcf85063/pcf85063.cpp

@@ -10,7 +10,7 @@ namespace pcf85063 {
 static const char *const TAG = "pcf85063";
 
 void PCF85063Component::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up PCF85063...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   if (!this->read_rtc_()) {
     this->mark_failed();
   }
@@ -22,7 +22,7 @@ void PCF85063Component::dump_config() {
   ESP_LOGCONFIG(TAG, "PCF85063:");
   LOG_I2C_DEVICE(this);
   if (this->is_failed()) {
-    ESP_LOGE(TAG, "Communication with PCF85063 failed!");
+    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
   }
   ESP_LOGCONFIG(TAG, "  Timezone: '%s'", this->timezone_.c_str());
 }

esphome/components/pcf8563/pcf8563.cpp

@@ -10,7 +10,7 @@ namespace pcf8563 {
 static const char *const TAG = "PCF8563";
 
 void PCF8563Component::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up PCF8563...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   if (!this->read_rtc_()) {
     this->mark_failed();
   }
@@ -22,7 +22,7 @@ void PCF8563Component::dump_config() {
   ESP_LOGCONFIG(TAG, "PCF8563:");
   LOG_I2C_DEVICE(this);
   if (this->is_failed()) {
-    ESP_LOGE(TAG, "Communication with PCF8563 failed!");
+    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
   }
   ESP_LOGCONFIG(TAG, "  Timezone: '%s'", this->timezone_.c_str());
 }

esphome/components/pcf8574/pcf8574.cpp

@@ -7,7 +7,7 @@ namespace pcf8574 {
 static const char *const TAG = "pcf8574";
 
 void PCF8574Component::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up PCF8574...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   if (!this->read_gpio_()) {
     ESP_LOGE(TAG, "PCF8574 not available under 0x%02X", this->address_);
     this->mark_failed();
@@ -22,7 +22,7 @@ void PCF8574Component::dump_config() {
   LOG_I2C_DEVICE(this)
   ESP_LOGCONFIG(TAG, "  Is PCF8575: %s", YESNO(this->pcf8575_));
   if (this->is_failed()) {
-    ESP_LOGE(TAG, "Communication with PCF8574 failed!");
+    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
   }
 }
 bool PCF8574Component::digital_read(uint8_t pin) {

esphome/components/pid/pid_climate.cpp

@@ -73,15 +73,18 @@ climate::ClimateTraits PIDClimate::traits() {
 }
 void PIDClimate::dump_config() {
   LOG_CLIMATE("", "PID Climate", this);
-  ESP_LOGCONFIG(TAG, "  Control Parameters:");
-  ESP_LOGCONFIG(TAG, "    kp: %.5f, ki: %.5f, kd: %.5f, output samples: %d", controller_.kp_, controller_.ki_,
-                controller_.kd_, controller_.output_samples_);
+  ESP_LOGCONFIG(TAG,
+                "  Control Parameters:\n"
+                "    kp: %.5f, ki: %.5f, kd: %.5f, output samples: %d",
+                controller_.kp_, controller_.ki_, controller_.kd_, controller_.output_samples_);
 
   if (controller_.threshold_low_ == 0 && controller_.threshold_high_ == 0) {
     ESP_LOGCONFIG(TAG, "  Deadband disabled.");
   } else {
-    ESP_LOGCONFIG(TAG, "  Deadband Parameters:");
-    ESP_LOGCONFIG(TAG, "    threshold: %0.5f to %0.5f, multipliers(kp: %.5f, ki: %.5f, kd: %.5f), output samples: %d",
+    ESP_LOGCONFIG(TAG,
+                  "  Deadband Parameters:\n"
+                  "    threshold: %0.5f to %0.5f, multipliers(kp: %.5f, ki: %.5f, kd: %.5f), "
+                  "output samples: %d",
                   controller_.threshold_low_, controller_.threshold_high_, controller_.kp_multiplier_,
                   controller_.ki_multiplier_, controller_.kd_multiplier_, controller_.deadband_output_samples_);
   }

esphome/components/pid/pid_climate.h

@@ -1,8 +1,8 @@
 #pragma once
 
+#include "esphome/core/automation.h"
 #include "esphome/core/component.h"
 #include "esphome/core/helpers.h"
-#include "esphome/core/automation.h"
 #include "esphome/components/climate/climate.h"
 #include "esphome/components/sensor/sensor.h"
 #include "esphome/components/output/float_output.h"

esphome/components/pid/sensor/pid_climate_sensor.cpp

@@ -1,6 +1,6 @@
 #include "pid_climate_sensor.h"
-#include "esphome/core/log.h"
 #include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 
 namespace esphome {
 namespace pid {

esphome/components/pipsolar/output/pipsolar_output.cpp

@@ -1,6 +1,6 @@
 #include "pipsolar_output.h"
-#include "esphome/core/log.h"
 #include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 
 namespace esphome {
 namespace pipsolar {

esphome/components/pipsolar/pipsolar.cpp

@@ -1,6 +1,6 @@
 #include "pipsolar.h"
-#include "esphome/core/log.h"
 #include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 
 namespace esphome {
 namespace pipsolar {
@@ -861,8 +861,8 @@ void Pipsolar::switch_command(const std::string &command) {
   queue_command_(command.c_str(), command.length());
 }
 void Pipsolar::dump_config() {
-  ESP_LOGCONFIG(TAG, "Pipsolar:");
-  ESP_LOGCONFIG(TAG, "used commands:");
+  ESP_LOGCONFIG(TAG, "Pipsolar:\n"
+                     "used commands:");
   for (auto &used_polling_command : this->used_polling_commands_) {
     if (used_polling_command.length != 0) {
       ESP_LOGCONFIG(TAG, "%s", used_polling_command.command);

esphome/components/pm1006/pm1006.cpp

@@ -55,8 +55,8 @@ uint8_t PM1006Component::pm1006_checksum_(const uint8_t *command_data, uint8_t l
 }
 
 optional<bool> PM1006Component::check_byte_() const {
-  uint8_t index = this->data_index_;
-  uint8_t byte = this->data_[index];
+  const uint8_t index = this->data_index_;
+  const uint8_t byte = this->data_[index];
 
   // index 0..2 are the fixed header
   if (index < sizeof(PM1006_RESPONSE_HEADER)) {
@@ -86,7 +86,7 @@ optional<bool> PM1006Component::check_byte_() const {
 }
 
 void PM1006Component::parse_data_() {
-  const int pm_2_5_concentration = this->get_16_bit_uint_(5);
+  const uint16_t pm_2_5_concentration = this->get_16_bit_uint_(5);
 
   ESP_LOGD(TAG, "Got PM2.5 Concentration: %d µg/m³", pm_2_5_concentration);
 
@@ -95,9 +95,5 @@ void PM1006Component::parse_data_() {
   }
 }
 
-uint16_t PM1006Component::get_16_bit_uint_(uint8_t start_index) const {
-  return encode_uint16(this->data_[start_index], this->data_[start_index + 1]);
-}
-
 }  // namespace pm1006
 }  // namespace esphome

esphome/components/pm1006/pm1006.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "esphome/core/component.h"
+#include "esphome/core/helpers.h"
 #include "esphome/components/sensor/sensor.h"
 #include "esphome/components/uart/uart.h"
 
@@ -22,8 +23,10 @@ class PM1006Component : public PollingComponent, public uart::UARTDevice {
  protected:
   optional<bool> check_byte_() const;
   void parse_data_();
-  uint16_t get_16_bit_uint_(uint8_t start_index) const;
   uint8_t pm1006_checksum_(const uint8_t *command_data, uint8_t length) const;
+  uint16_t get_16_bit_uint_(uint8_t start_index) const {
+    return encode_uint16(this->data_[start_index], this->data_[start_index + 1]);
+  }
 
   sensor::Sensor *pm_2_5_sensor_{nullptr};