diff --git a/esphome/components/ade7880/ade7880.cpp b/esphome/components/ade7880/ade7880.cpp
index f6a15190cd..8fb3e55b91 100644
--- a/esphome/components/ade7880/ade7880.cpp
+++ b/esphome/components/ade7880/ade7880.cpp
@@ -121,7 +121,7 @@ void ADE7880::update() {
     this->update_sensor_from_s32_register16_(chan->forward_active_energy, AFWATTHR, [&chan](float val) {
       return chan->forward_active_energy_total += val / 14400.0f;
     });
-    this->update_sensor_from_s32_register16_(chan->reverse_active_energy, AFWATTHR, [&chan](float val) {
+    this->update_sensor_from_s32_register16_(chan->reverse_active_energy, ARWATTHR, [&chan](float val) {
       return chan->reverse_active_energy_total += val / 14400.0f;
     });
   }
@@ -137,7 +137,7 @@ void ADE7880::update() {
     this->update_sensor_from_s32_register16_(chan->forward_active_energy, BFWATTHR, [&chan](float val) {
       return chan->forward_active_energy_total += val / 14400.0f;
     });
-    this->update_sensor_from_s32_register16_(chan->reverse_active_energy, BFWATTHR, [&chan](float val) {
+    this->update_sensor_from_s32_register16_(chan->reverse_active_energy, BRWATTHR, [&chan](float val) {
       return chan->reverse_active_energy_total += val / 14400.0f;
     });
   }
@@ -153,7 +153,7 @@ void ADE7880::update() {
     this->update_sensor_from_s32_register16_(chan->forward_active_energy, CFWATTHR, [&chan](float val) {
       return chan->forward_active_energy_total += val / 14400.0f;
     });
-    this->update_sensor_from_s32_register16_(chan->reverse_active_energy, CFWATTHR, [&chan](float val) {
+    this->update_sensor_from_s32_register16_(chan->reverse_active_energy, CRWATTHR, [&chan](float val) {
       return chan->reverse_active_energy_total += val / 14400.0f;
     });
   }
diff --git a/esphome/components/ade7880/ade7880_registers.h b/esphome/components/ade7880/ade7880_registers.h
index 8b5b68abb0..9fd8ca3bf5 100644
--- a/esphome/components/ade7880/ade7880_registers.h
+++ b/esphome/components/ade7880/ade7880_registers.h
@@ -85,6 +85,9 @@ constexpr uint16_t CWATTHR = 0xE402;
 constexpr uint16_t AFWATTHR = 0xE403;
 constexpr uint16_t BFWATTHR = 0xE404;
 constexpr uint16_t CFWATTHR = 0xE405;
+constexpr uint16_t ARWATTHR = 0xE406;
+constexpr uint16_t BRWATTHR = 0xE407;
+constexpr uint16_t CRWATTHR = 0xE408;
 constexpr uint16_t AFVARHR = 0xE409;
 constexpr uint16_t BFVARHR = 0xE40A;
 constexpr uint16_t CFVARHR = 0xE40B;
diff --git a/esphome/components/beken_spi_led_strip/led_strip.cpp b/esphome/components/beken_spi_led_strip/led_strip.cpp
index 67b8472257..f425f3ca5c 100644
--- a/esphome/components/beken_spi_led_strip/led_strip.cpp
+++ b/esphome/components/beken_spi_led_strip/led_strip.cpp
@@ -78,7 +78,7 @@ static void spi_set_clock(uint32_t max_hz) {
   int source_clk = 0;
   int spi_clk = 0;
   int div = 0;
-  uint32_t param;
+  uint32_t param = PWD_SPI_CLK_BIT;
   if (max_hz > 4333000) {
     if (max_hz > 30000000) {
       spi_clk = 30000000;
diff --git a/esphome/components/bl0906/bl0906.cpp b/esphome/components/bl0906/bl0906.cpp
index c1cd48a1ac..7b643bba98 100644
--- a/esphome/components/bl0906/bl0906.cpp
+++ b/esphome/components/bl0906/bl0906.cpp
@@ -10,7 +10,9 @@ static const char *const TAG = "bl0906";
 
 constexpr uint32_t to_uint32_t(ube24_t input) { return input.h << 16 | input.m << 8 | input.l; }
 
-constexpr int32_t to_int32_t(sbe24_t input) { return input.h << 16 | input.m << 8 | input.l; }
+constexpr int32_t to_int32_t(sbe24_t input) {
+  return static_cast<int32_t>(encode_uint32((uint8_t) input.h, input.m, input.l, 0)) >> 8;
+}
 
 // The SUM byte is (Addr+Data_L+Data_M+Data_H)&0xFF negated;
 constexpr uint8_t bl0906_checksum(const uint8_t address, const DataPacket *data) {
diff --git a/esphome/components/bmp581_base/bmp581_base.cpp b/esphome/components/bmp581_base/bmp581_base.cpp
index c4a96ebc39..89a92de31d 100644
--- a/esphome/components/bmp581_base/bmp581_base.cpp
+++ b/esphome/components/bmp581_base/bmp581_base.cpp
@@ -429,7 +429,7 @@ bool BMP581Component::read_temperature_(float &temperature) {
   }
 
   // temperature MSB is in data[2], LSB is in data[1], XLSB in data[0]
-  int32_t raw_temp = (int32_t) data[2] << 16 | (int32_t) data[1] << 8 | (int32_t) data[0];
+  int32_t raw_temp = static_cast<int32_t>(encode_uint32(data[2], data[1], data[0], 0)) >> 8;
   temperature = (float) (raw_temp / 65536.0);  // convert measurement to degrees Celsius (page 22 of datasheet)
 
   return true;
@@ -458,7 +458,7 @@ bool BMP581Component::read_temperature_and_pressure_(float &temperature, float &
   }
 
   // temperature MSB is in data[2], LSB is in data[1], XLSB in data[0]
-  int32_t raw_temp = (int32_t) data[2] << 16 | (int32_t) data[1] << 8 | (int32_t) data[0];
+  int32_t raw_temp = static_cast<int32_t>(encode_uint32(data[2], data[1], data[0], 0)) >> 8;
   temperature = (float) (raw_temp / 65536.0);  // convert measurement to degrees Celsius (page 22 of datasheet)
 
   // pressure MSB is in data[5], LSB is in data[4], XLSB in data[3]
diff --git a/esphome/components/bytebuffer/bytebuffer.h b/esphome/components/bytebuffer/bytebuffer.h
index 030484ce32..3c68094dbc 100644
--- a/esphome/components/bytebuffer/bytebuffer.h
+++ b/esphome/components/bytebuffer/bytebuffer.h
@@ -263,7 +263,7 @@ class ByteBuffer {
 
   void put_uint8(uint8_t value, size_t offset) { this->data_[offset] = value; }
   void put_uint16(uint16_t value, size_t offset) { this->put(value, offset); }
-  void put_uint24(uint32_t value, size_t offset) { this->put(value, offset); }
+  void put_uint24(uint32_t value, size_t offset) { this->put_uint32_(value, offset, 3); }
   void put_uint32(uint32_t value, size_t offset) { this->put(value, offset); }
   void put_uint64(uint64_t value, size_t offset) { this->put(value, offset); }
   // Signed versions of the put functions
diff --git a/esphome/components/cap1188/cap1188.cpp b/esphome/components/cap1188/cap1188.cpp
index 9e8c87d147..64bdc620cd 100644
--- a/esphome/components/cap1188/cap1188.cpp
+++ b/esphome/components/cap1188/cap1188.cpp
@@ -92,7 +92,7 @@ void CAP1188Component::loop() {
     this->read_register(CAP1188_MAIN, &data, 1);
     data = data & ~CAP1188_MAIN_INT;
 
-    this->write_register(CAP1188_MAIN, &data, 2);
+    this->write_register(CAP1188_MAIN, &data, 1);
   }
 
   for (auto *channel : this->channels_) {
diff --git a/esphome/components/esp32_ble_server/ble_characteristic.cpp b/esphome/components/esp32_ble_server/ble_characteristic.cpp
index d4ccefd9b2..1806354712 100644
--- a/esphome/components/esp32_ble_server/ble_characteristic.cpp
+++ b/esphome/components/esp32_ble_server/ble_characteristic.cpp
@@ -310,8 +310,8 @@ void BLECharacteristic::gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt
           (*this->on_write_callback_)(this->value_, param->exec_write.conn_id);
         }
       }
-      esp_err_t err =
-          esp_ble_gatts_send_response(gatts_if, param->write.conn_id, param->write.trans_id, ESP_GATT_OK, nullptr);
+      esp_err_t err = esp_ble_gatts_send_response(gatts_if, param->exec_write.conn_id, param->exec_write.trans_id,
+                                                  ESP_GATT_OK, nullptr);
       if (err != ESP_OK) {
         ESP_LOGE(TAG, "esp_ble_gatts_send_response failed: %d", err);
       }
diff --git a/esphome/components/hte501/hte501.cpp b/esphome/components/hte501/hte501.cpp
index 972e72c170..ef9ef1fabf 100644
--- a/esphome/components/hte501/hte501.cpp
+++ b/esphome/components/hte501/hte501.cpp
@@ -49,7 +49,7 @@ void HTE501Component::update() {
   this->set_timeout(50, [this]() {
     uint8_t i2c_response[6];
     this->read(i2c_response, 6);
-    if (i2c_response[2] != crc8(i2c_response, 2, 0xFF, 0x31, true) &&
+    if (i2c_response[2] != crc8(i2c_response, 2, 0xFF, 0x31, true) ||
         i2c_response[5] != crc8(i2c_response + 3, 2, 0xFF, 0x31, true)) {
       this->error_code_ = CRC_CHECK_FAILED;
       this->status_set_warning();
diff --git a/esphome/components/iaqcore/iaqcore.cpp b/esphome/components/iaqcore/iaqcore.cpp
index 274f9086b6..c414eb8f60 100644
--- a/esphome/components/iaqcore/iaqcore.cpp
+++ b/esphome/components/iaqcore/iaqcore.cpp
@@ -10,11 +10,13 @@ static const char *const TAG = "iaqcore";
 
 enum IAQCoreErrorCode : uint8_t { ERROR_OK = 0, ERROR_RUNIN = 0x10, ERROR_BUSY = 0x01, ERROR_ERROR = 0x80 };
 
+static constexpr size_t SENSOR_DATA_LENGTH = 9;
+
 struct SensorData {
-  uint16_t co2;
-  IAQCoreErrorCode status;
   int32_t resistance;
+  uint16_t co2;
   uint16_t tvoc;
+  IAQCoreErrorCode status;
 
   SensorData(const uint8_t *buffer) {
     this->co2 = encode_uint16(buffer[0], buffer[1]);
@@ -33,9 +35,9 @@ void IAQCore::setup() {
 }
 
 void IAQCore::update() {
-  uint8_t buffer[sizeof(SensorData)];
+  uint8_t buffer[SENSOR_DATA_LENGTH];
 
-  if (this->read_register(0xB5, buffer, sizeof(buffer)) != i2c::ERROR_OK) {
+  if (this->read_register(0xB5, buffer, SENSOR_DATA_LENGTH) != i2c::ERROR_OK) {
     ESP_LOGD(TAG, "Read failed");
     this->status_set_warning();
     this->publish_nans_();
diff --git a/esphome/components/ina2xx_base/ina2xx_base.cpp b/esphome/components/ina2xx_base/ina2xx_base.cpp
index 8a20192c1e..9f510eef74 100644
--- a/esphome/components/ina2xx_base/ina2xx_base.cpp
+++ b/esphome/components/ina2xx_base/ina2xx_base.cpp
@@ -599,11 +599,7 @@ bool INA2XX::read_unsigned_16_(uint8_t reg, uint16_t &out) {
 }
 
 int64_t INA2XX::two_complement_(uint64_t value, uint8_t bits) {
-  if (value > (1ULL << (bits - 1))) {
-    return (int64_t) (value - (1ULL << bits));
-  } else {
-    return (int64_t) value;
-  }
+  return (int64_t) (value << (64 - bits)) >> (64 - bits);
 }
 }  // namespace ina2xx_base
 }  // namespace esphome
diff --git a/esphome/components/inkplate/inkplate.cpp b/esphome/components/inkplate/inkplate.cpp
index df9c2b29c7..7551c6fc77 100644
--- a/esphome/components/inkplate/inkplate.cpp
+++ b/esphome/components/inkplate/inkplate.cpp
@@ -407,7 +407,7 @@ void Inkplate::display1b_() {
       break;
   }
 
-  uint32_t clock = (1 << this->cl_pin_->get_pin());
+  uint32_t clock = (1UL << this->cl_pin_->get_pin());
   uint32_t data_mask = this->get_data_pin_mask_();
   ESP_LOGV(TAG, "Display1b start loops (%ums)", millis() - start_time);
 
@@ -575,7 +575,7 @@ void Inkplate::display3b_() {
       break;
   }
 
-  uint32_t clock = (1 << this->cl_pin_->get_pin());
+  uint32_t clock = (1UL << this->cl_pin_->get_pin());
   uint32_t data_mask = this->get_data_pin_mask_();
   uint32_t pos;
   uint32_t data;
@@ -646,7 +646,7 @@ bool Inkplate::partial_update_() {
   int rep = (this->model_ == INKPLATE_6_V2) ? 6 : 5;
 
   eink_on_();
-  uint32_t clock = (1 << this->cl_pin_->get_pin());
+  uint32_t clock = (1UL << this->cl_pin_->get_pin());
   uint32_t data_mask = this->get_data_pin_mask_();
   for (int k = 0; k < rep; k++) {
     vscan_start_();
@@ -704,7 +704,7 @@ void Inkplate::vscan_start_() {
 }
 
 void Inkplate::hscan_start_(uint32_t d) {
-  uint8_t clock = (1 << this->cl_pin_->get_pin());
+  uint32_t clock = (1UL << this->cl_pin_->get_pin());
   this->sph_pin_->digital_write(false);
   GPIO.out_w1ts = d | clock;
   GPIO.out_w1tc = this->get_data_pin_mask_() | clock;
@@ -751,7 +751,7 @@ void Inkplate::clean_fast_(uint8_t c, uint8_t rep) {
 
   uint32_t send = ((data & 0b00000011) << 4) | (((data & 0b00001100) >> 2) << 18) | (((data & 0b00010000) >> 4) << 23) |
                   (((data & 0b11100000) >> 5) << 25);
-  uint32_t clock = (1 << this->cl_pin_->get_pin());
+  uint32_t clock = (1UL << this->cl_pin_->get_pin());
 
   for (int k = 0; k < rep; k++) {
     vscan_start_();
diff --git a/esphome/components/lightwaverf/LwRx.cpp b/esphome/components/lightwaverf/LwRx.cpp
index 2b1ad5e870..9710457850 100644
--- a/esphome/components/lightwaverf/LwRx.cpp
+++ b/esphome/components/lightwaverf/LwRx.cpp
@@ -8,6 +8,7 @@
 
 #include "LwRx.h"
 #include <cstring>
+#include "esphome/core/helpers.h"
 
 namespace esphome {
 namespace lightwaverf {
@@ -185,13 +186,20 @@ bool LwRx::lwrx_getmessage(uint8_t *buf, uint8_t len) {
   bool ret = true;
   int16_t j = 0;  // int
   if (this->rx_msgcomplete && len <= RX_MSGLEN) {
+    // Copy message under interrupt lock to prevent ISR overwriting rx_msg mid-read
+    uint8_t msg_copy[RX_MSGLEN];
+    {
+      InterruptLock lock;
+      memcpy(msg_copy, this->rx_msg, RX_MSGLEN);
+      this->rx_msgcomplete = false;
+    }
     for (uint8_t i = 0; ret && i < RX_MSGLEN; i++) {
       if (this->rx_translate || (len != RX_MSGLEN)) {
-        j = this->rx_find_nibble_(this->rx_msg[i]);
+        j = this->rx_find_nibble_(msg_copy[i]);
         if (j < 0)
           ret = false;
       } else {
-        j = this->rx_msg[i];
+        j = msg_copy[i];
       }
       switch (len) {
         case 4:
@@ -199,6 +207,7 @@ bool LwRx::lwrx_getmessage(uint8_t *buf, uint8_t len) {
             buf[2] = j;
           if (i == 2)
             buf[3] = j;
+          [[fallthrough]];
         case 2:
           if (i == 3)
             buf[0] = j;
@@ -212,7 +221,6 @@ bool LwRx::lwrx_getmessage(uint8_t *buf, uint8_t len) {
           break;
       }
     }
-    this->rx_msgcomplete = false;
   } else {
     ret = false;
   }
diff --git a/esphome/components/lightwaverf/LwRx.h b/esphome/components/lightwaverf/LwRx.h
index 7200f9a51c..8b34de9fbb 100644
--- a/esphome/components/lightwaverf/LwRx.h
+++ b/esphome/components/lightwaverf/LwRx.h
@@ -105,8 +105,8 @@ class LwRx {
 
   uint32_t rx_prev;  // time of previous interrupt in microseconds
 
-  bool rx_msgcomplete = false;  // set high when message available
-  bool rx_translate = true;     // Set false to get raw data
+  volatile bool rx_msgcomplete = false;  // set high when message available
+  bool rx_translate = true;              // Set false to get raw data
 
   uint8_t rx_state = 0;
 
diff --git a/esphome/components/lightwaverf/LwTx.cpp b/esphome/components/lightwaverf/LwTx.cpp
index b69b93b978..8852935bfd 100644
--- a/esphome/components/lightwaverf/LwTx.cpp
+++ b/esphome/components/lightwaverf/LwTx.cpp
@@ -192,7 +192,8 @@ void LwTx::lwtx_set_gap_multiplier(uint8_t gap_multiplier) { this->tx_gap_multip
 void LwTx::lw_timer_start() {
   {
     InterruptLock lock;
-    static LwTx *arg = this;  // NOLINT
+    static LwTx *arg;
+    arg = this;
     timer1_attachInterrupt([] { isr_t_xtimer(arg); });
     timer1_enable(TIM_DIV16, TIM_EDGE, TIM_LOOP);
     timer1_write(this->espPeriod);
diff --git a/esphome/components/lightwaverf/LwTx.h b/esphome/components/lightwaverf/LwTx.h
index fe7b942a3a..9192426440 100644
--- a/esphome/components/lightwaverf/LwTx.h
+++ b/esphome/components/lightwaverf/LwTx.h
@@ -62,8 +62,8 @@ class LwTx {
   uint8_t tx_repeats = 12;  // Number of repeats of message sent
   uint8_t txon = 1;
   uint8_t txoff = 0;
-  bool tx_msg_active = false;  // set true to activate message sending
-  bool tx_translate = true;    // Set false to send raw data
+  volatile bool tx_msg_active = false;  // set true to activate message sending
+  bool tx_translate = true;             // Set false to send raw data
 
   uint8_t tx_buf[TX_MSGLEN];  // the message buffer during reception
   uint8_t tx_repeat = 0;      // counter for repeats
diff --git a/esphome/components/ltr501/ltr501.cpp b/esphome/components/ltr501/ltr501.cpp
index 04de91e362..4c9006be1d 100644
--- a/esphome/components/ltr501/ltr501.cpp
+++ b/esphome/components/ltr501/ltr501.cpp
@@ -146,7 +146,6 @@ void LTRAlsPs501Component::update() {
 
 void LTRAlsPs501Component::loop() {
   ErrorCode err = i2c::ERROR_OK;
-  static uint8_t tries{0};
 
   switch (this->state_) {
     case State::DELAYED_SETUP:
@@ -175,20 +174,20 @@ void LTRAlsPs501Component::loop() {
 
     case State::WAITING_FOR_DATA:
       if (this->is_als_data_ready_(this->als_readings_) == LtrDataAvail::LTR_DATA_OK) {
-        tries = 0;
+        this->tries_ = 0;
         ESP_LOGV(TAG, "Reading sensor data assuming gain = %.0fx, time = %d ms",
                  get_gain_coeff(this->als_readings_.gain), get_itime_ms(this->als_readings_.integration_time));
         this->read_sensor_data_(this->als_readings_);
         this->apply_lux_calculation_(this->als_readings_);
         this->state_ = State::DATA_COLLECTED;
-      } else if (tries >= MAX_TRIES) {
+      } else if (this->tries_ >= MAX_TRIES) {
         ESP_LOGW(TAG, "Can't get data after several tries. Aborting.");
-        tries = 0;
+        this->tries_ = 0;
         this->status_set_warning();
         this->state_ = State::IDLE;
         return;
       } else {
-        tries++;
+        this->tries_++;
       }
       break;
 
@@ -230,21 +229,21 @@ void LTRAlsPs501Component::loop() {
 }
 
 void LTRAlsPs501Component::check_and_trigger_ps_() {
-  static uint32_t last_high_trigger_time{0};
-  static uint32_t last_low_trigger_time{0};
   uint16_t ps_data = this->read_ps_data_();
   uint32_t now = millis();
 
   if (ps_data != this->ps_readings_) {
     this->ps_readings_ = ps_data;
     // Higher values - object is closer to sensor
-    if (ps_data > this->ps_threshold_high_ && now - last_high_trigger_time >= this->ps_cooldown_time_s_ * 1000) {
-      last_high_trigger_time = now;
+    if (ps_data > this->ps_threshold_high_ &&
+        now - this->last_ps_high_trigger_time_ >= this->ps_cooldown_time_s_ * 1000) {
+      this->last_ps_high_trigger_time_ = now;
       ESP_LOGD(TAG, "Proximity high threshold triggered. Value = %d, Trigger level = %d", ps_data,
                this->ps_threshold_high_);
       this->on_ps_high_trigger_callback_.call();
-    } else if (ps_data < this->ps_threshold_low_ && now - last_low_trigger_time >= this->ps_cooldown_time_s_ * 1000) {
-      last_low_trigger_time = now;
+    } else if (ps_data < this->ps_threshold_low_ &&
+               now - this->last_ps_low_trigger_time_ >= this->ps_cooldown_time_s_ * 1000) {
+      this->last_ps_low_trigger_time_ = now;
       ESP_LOGD(TAG, "Proximity low threshold triggered. Value = %d, Trigger level = %d", ps_data,
                this->ps_threshold_low_);
       this->on_ps_low_trigger_callback_.call();
diff --git a/esphome/components/ltr501/ltr501.h b/esphome/components/ltr501/ltr501.h
index 02c025da30..d9a53c9bd4 100644
--- a/esphome/components/ltr501/ltr501.h
+++ b/esphome/components/ltr501/ltr501.h
@@ -74,6 +74,7 @@ class LTRAlsPs501Component : public PollingComponent, public i2c::I2CDevice {
     READY_TO_PUBLISH,
     KEEP_PUBLISHING
   } state_{State::NOT_INITIALIZED};
+  uint8_t tries_{0};
 
   LtrType ltr_type_{LtrType::LTR_TYPE_ALS_ONLY};
 
@@ -130,6 +131,8 @@ class LTRAlsPs501Component : public PollingComponent, public i2c::I2CDevice {
   PsGain501 ps_gain_{PsGain501::PS_GAIN_1};
   uint16_t ps_threshold_high_{0xffff};
   uint16_t ps_threshold_low_{0x0000};
+  uint32_t last_ps_high_trigger_time_{0};
+  uint32_t last_ps_low_trigger_time_{0};
 
   //
   //   Sensors for publishing data
diff --git a/esphome/components/lvgl/lvgl_esphome.cpp b/esphome/components/lvgl/lvgl_esphome.cpp
index 3e447e9169..66cb25b864 100644
--- a/esphome/components/lvgl/lvgl_esphome.cpp
+++ b/esphome/components/lvgl/lvgl_esphome.cpp
@@ -422,6 +422,9 @@ void LvglComponent::write_random_() {
     auto row = random_uint32() % this->disp_drv_.ver_res;
     row = row / this->draw_rounding * this->draw_rounding;
     auto size = ((random_uint32() % 32) / this->draw_rounding + 2) * this->draw_rounding - 1;
+    // clamp size so the square fits within the draw buffer
+    if ((size + 1) * (size + 1) > this->draw_buf_.size)
+      size = static_cast<decltype(size)>(sqrtf(this->draw_buf_.size)) - 1;
     lv_area_t area;
     area.x1 = col;
     area.y1 = row;
diff --git a/esphome/components/msa3xx/msa3xx.cpp b/esphome/components/msa3xx/msa3xx.cpp
index e46bfed193..6d6b21e6af 100644
--- a/esphome/components/msa3xx/msa3xx.cpp
+++ b/esphome/components/msa3xx/msa3xx.cpp
@@ -364,11 +364,7 @@ void MSA3xxComponent::setup_offset_(float offset_x, float offset_y, float offset
 }
 
 int64_t MSA3xxComponent::twos_complement_(uint64_t value, uint8_t bits) {
-  if (value > (1ULL << (bits - 1))) {
-    return (int64_t) (value - (1ULL << bits));
-  } else {
-    return (int64_t) value;
-  }
+  return (int64_t) (value << (64 - bits)) >> (64 - bits);
 }
 
 void binary_event_debounce(bool state, bool old_state, uint32_t now, uint32_t &last_ms, Trigger<> &trigger,
diff --git a/esphome/components/nextion/nextion_component.cpp b/esphome/components/nextion/nextion_component.cpp
index 324ad87372..30c8b80524 100644
--- a/esphome/components/nextion/nextion_component.cpp
+++ b/esphome/components/nextion/nextion_component.cpp
@@ -88,7 +88,7 @@ void NextionComponent::update_component_settings(bool force_update) {
     this->send_state_to_nextion();
   }
 
-  if (this->component_flags_.bco_needs_update || (force_update && this->component_flags_.bco2_is_set)) {
+  if (this->component_flags_.bco_needs_update || (force_update && this->component_flags_.bco_is_set)) {
     this->nextion_->set_component_background_color(this->variable_name_.c_str(), this->bco_);
     this->component_flags_.bco_needs_update = false;
   }
diff --git a/esphome/components/nfc/ndef_record_text.cpp b/esphome/components/nfc/ndef_record_text.cpp
index 80b0108b46..8a9a2cb014 100644
--- a/esphome/components/nfc/ndef_record_text.cpp
+++ b/esphome/components/nfc/ndef_record_text.cpp
@@ -14,6 +14,11 @@ NdefRecordText::NdefRecordText(const std::vector<uint8_t> &payload) {
 
   uint8_t language_code_length = payload[0] & 0b00111111;  // Todo, make use of encoding bit?
 
+  if (1 + language_code_length > payload.size()) {
+    ESP_LOGE(TAG, "Record payload too short for language code");
+    return;
+  }
+
   this->language_code_ = std::string(payload.begin() + 1, payload.begin() + 1 + language_code_length);
 
   this->text_ = std::string(payload.begin() + 1 + language_code_length, payload.end());
diff --git a/esphome/components/nfc/nfc.cpp b/esphome/components/nfc/nfc.cpp
index 8567b0969a..55543cd292 100644
--- a/esphome/components/nfc/nfc.cpp
+++ b/esphome/components/nfc/nfc.cpp
@@ -35,7 +35,7 @@ uint8_t guess_tag_type(uint8_t uid_length) {
   }
 }
 
-uint8_t get_mifare_classic_ndef_start_index(std::vector<uint8_t> &data) {
+int8_t get_mifare_classic_ndef_start_index(std::vector<uint8_t> &data) {
   for (uint8_t i = 0; i < MIFARE_CLASSIC_BLOCK_SIZE; i++) {
     if (data[i] == 0x00) {
       // Do nothing, skip
@@ -49,17 +49,25 @@ uint8_t get_mifare_classic_ndef_start_index(std::vector<uint8_t> &data) {
 }
 
 bool decode_mifare_classic_tlv(std::vector<uint8_t> &data, uint32_t &message_length, uint8_t &message_start_index) {
+  if (data.size() < MIFARE_CLASSIC_BLOCK_SIZE) {
+    ESP_LOGE(TAG, "Error, data too short for NDEF detection.");
+    return false;
+  }
   auto i = get_mifare_classic_ndef_start_index(data);
-  if (data[i] != 0x03) {
+  if (i < 0 || data[i] != 0x03) {
     ESP_LOGE(TAG, "Error, Can't decode message length.");
     return false;
   }
-  if (data[i + 1] == 0xFF) {
-    message_length = ((0xFF & data[i + 2]) << 8) | (0xFF & data[i + 3]);
-    message_start_index = i + MIFARE_CLASSIC_LONG_TLV_SIZE;
+  uint8_t idx = static_cast<uint8_t>(i);
+  if (idx + 4 <= data.size() && data[idx + 1] == 0xFF) {
+    message_length = ((0xFF & data[idx + 2]) << 8) | (0xFF & data[idx + 3]);
+    message_start_index = idx + MIFARE_CLASSIC_LONG_TLV_SIZE;
+  } else if (idx + 2 <= data.size()) {
+    message_length = data[idx + 1];
+    message_start_index = idx + MIFARE_CLASSIC_SHORT_TLV_SIZE;
   } else {
-    message_length = data[i + 1];
-    message_start_index = i + MIFARE_CLASSIC_SHORT_TLV_SIZE;
+    ESP_LOGE(TAG, "Error, TLV data too short.");
+    return false;
   }
   return true;
 }
diff --git a/esphome/components/nfc/nfc.h b/esphome/components/nfc/nfc.h
index cdaea82af6..8ca5cb7ea4 100644
--- a/esphome/components/nfc/nfc.h
+++ b/esphome/components/nfc/nfc.h
@@ -72,7 +72,7 @@ ESPDEPRECATED("Use format_bytes_to() with stack buffer instead. Removed in 2026.
 std::string format_bytes(std::span<const uint8_t> bytes);
 
 uint8_t guess_tag_type(uint8_t uid_length);
-uint8_t get_mifare_classic_ndef_start_index(std::vector<uint8_t> &data);
+int8_t get_mifare_classic_ndef_start_index(std::vector<uint8_t> &data);
 bool decode_mifare_classic_tlv(std::vector<uint8_t> &data, uint32_t &message_length, uint8_t &message_start_index);
 uint32_t get_mifare_classic_buffer_size(uint32_t message_length);
 
diff --git a/esphome/components/packet_transport/packet_transport.cpp b/esphome/components/packet_transport/packet_transport.cpp
index 6f1286b469..964037a02c 100644
--- a/esphome/components/packet_transport/packet_transport.cpp
+++ b/esphome/components/packet_transport/packet_transport.cpp
@@ -137,6 +137,8 @@ class PacketDecoder {
       return DECODE_EMPTY;
     if (this->buffer_[this->position_] != key)
       return DECODE_UNMATCHED;
+    if (this->position_ + 1 + sizeof(T) > this->len_)
+      return DECODE_ERROR;
     this->position_++;
     T value = 0;
     for (size_t i = 0; i != sizeof(T); ++i) {
diff --git a/esphome/components/pid/pid_autotuner.cpp b/esphome/components/pid/pid_autotuner.cpp
index d1d9c200cf..e1ddd1d7c6 100644
--- a/esphome/components/pid/pid_autotuner.cpp
+++ b/esphome/components/pid/pid_autotuner.cpp
@@ -97,7 +97,7 @@ PIDAutotuner::PIDAutotuneResult PIDAutotuner::update(float setpoint, float proce
   }
 
   bool zc_symmetrical = this->frequency_detector_.is_increase_decrease_symmetrical();
-  bool amplitude_convergent = this->frequency_detector_.is_increase_decrease_symmetrical();
+  bool amplitude_convergent = this->amplitude_detector_.is_amplitude_convergent();
   if (!zc_symmetrical || !amplitude_convergent) {
     // The frequency/amplitude is not fully accurate yet, try to wait
     // until the fault clears, or terminate after a while anyway
@@ -362,7 +362,7 @@ bool PIDAutotuner::OscillationAmplitudeDetector::is_amplitude_convergent() const
   for (auto v : this->phase_mins)
     global_min = std::min(global_min, v);
   for (auto v : this->phase_maxs)
-    global_max = std::min(global_max, v);
+    global_max = std::max(global_max, v);
   float global_amplitude = (global_max - global_min) / 2.0f;
   float mean_amplitude = this->get_mean_oscillation_amplitude();
   return (mean_amplitude - global_amplitude) / (global_amplitude) < 0.05f;
diff --git a/esphome/components/pipsolar/pipsolar.cpp b/esphome/components/pipsolar/pipsolar.cpp
index 9c5caec775..eb6d3931e0 100644
--- a/esphome/components/pipsolar/pipsolar.cpp
+++ b/esphome/components/pipsolar/pipsolar.cpp
@@ -647,6 +647,7 @@ void Pipsolar::handle_qpiws_(const char *message) {
       case 34:
         this->publish_binary_sensor_(enabled, this->warning_high_ac_input_during_bus_soft_start_);
         value_warnings_present |= enabled.value_or(false);
+        break;
       case 35:
         this->publish_binary_sensor_(enabled, this->warning_battery_equalization_);
         value_warnings_present |= enabled.value_or(false);
diff --git a/esphome/components/pn532_i2c/pn532_i2c.cpp b/esphome/components/pn532_i2c/pn532_i2c.cpp
index b306222a21..41f0f079aa 100644
--- a/esphome/components/pn532_i2c/pn532_i2c.cpp
+++ b/esphome/components/pn532_i2c/pn532_i2c.cpp
@@ -49,7 +49,7 @@ bool PN532I2C::read_response(uint8_t command, std::vector<uint8_t> &data) {
     return false;
   }
 
-  if (data[1] != 0x00 && data[2] != 0x00 && data[3] != 0xFF) {
+  if (data[1] != 0x00 || data[2] != 0x00 || data[3] != 0xFF) {
     // invalid packet
     ESP_LOGV(TAG, "read data invalid preamble!");
     return false;
@@ -95,7 +95,7 @@ uint8_t PN532I2C::read_response_length_() {
     return 0;
   }
 
-  if (data[1] != 0x00 && data[2] != 0x00 && data[3] != 0xFF) {
+  if (data[1] != 0x00 || data[2] != 0x00 || data[3] != 0xFF) {
     // invalid packet
     ESP_LOGV(TAG, "read data invalid preamble!");
     return 0;
diff --git a/esphome/components/pvvx_mithermometer/pvvx_mithermometer.cpp b/esphome/components/pvvx_mithermometer/pvvx_mithermometer.cpp
index 239a1e74fe..35badf48bb 100644
--- a/esphome/components/pvvx_mithermometer/pvvx_mithermometer.cpp
+++ b/esphome/components/pvvx_mithermometer/pvvx_mithermometer.cpp
@@ -66,12 +66,11 @@ optional<ParseResult> PVVXMiThermometer::parse_header_(const esp32_ble_tracker::
     return {};
   }
 
-  static uint8_t last_frame_count = 0;
-  if (last_frame_count == raw[13]) {
-    ESP_LOGVV(TAG, "parse_header(): duplicate data packet received (%hhu).", last_frame_count);
+  if (this->last_frame_count_ == raw[13]) {
+    ESP_LOGVV(TAG, "parse_header(): duplicate data packet received (%hhu).", this->last_frame_count_);
     return {};
   }
-  last_frame_count = raw[13];
+  this->last_frame_count_ = raw[13];
 
   return result;
 }
diff --git a/esphome/components/pvvx_mithermometer/pvvx_mithermometer.h b/esphome/components/pvvx_mithermometer/pvvx_mithermometer.h
index c15e1e7e22..09b5e91a16 100644
--- a/esphome/components/pvvx_mithermometer/pvvx_mithermometer.h
+++ b/esphome/components/pvvx_mithermometer/pvvx_mithermometer.h
@@ -39,6 +39,8 @@ class PVVXMiThermometer : public Component, public esp32_ble_tracker::ESPBTDevic
   sensor::Sensor *battery_voltage_{nullptr};
   sensor::Sensor *signal_strength_{nullptr};
 
+  uint8_t last_frame_count_{0};
+
   optional<ParseResult> parse_header_(const esp32_ble_tracker::ServiceData &service_data);
   bool parse_message_(const std::vector<uint8_t> &message, ParseResult &result);
   bool report_results_(const optional<ParseResult> &result, const char *address);
diff --git a/esphome/components/scd30/scd30.cpp b/esphome/components/scd30/scd30.cpp
index 3c2c06fd68..e61d0142be 100644
--- a/esphome/components/scd30/scd30.cpp
+++ b/esphome/components/scd30/scd30.cpp
@@ -222,7 +222,7 @@ bool SCD30Component::force_recalibration_with_reference(uint16_t co2_reference)
 }
 
 uint16_t SCD30Component::get_forced_calibration_reference() {
-  uint16_t forced_calibration_reference;
+  uint16_t forced_calibration_reference = 0;
   // Get current CO2 calibration
   if (!this->get_register(SCD30_CMD_FORCED_CALIBRATION, forced_calibration_reference)) {
     ESP_LOGE(TAG, "Unable to read forced calibration reference.");
diff --git a/esphome/components/seeed_mr60fda2/seeed_mr60fda2.cpp b/esphome/components/seeed_mr60fda2/seeed_mr60fda2.cpp
index 5d571618d3..c6527a948e 100644
--- a/esphome/components/seeed_mr60fda2/seeed_mr60fda2.cpp
+++ b/esphome/components/seeed_mr60fda2/seeed_mr60fda2.cpp
@@ -149,28 +149,25 @@ void MR60FDA2Component::split_frame_(uint8_t buffer) {
   switch (this->current_frame_locate_) {
     case LOCATE_FRAME_HEADER:  // starting buffer
       if (buffer == FRAME_HEADER_BUFFER) {
-        this->current_frame_len_ = 1;
-        this->current_frame_buf_[this->current_frame_len_ - 1] = buffer;
+        this->current_frame_len_ = 0;
+        this->current_frame_buf_[this->current_frame_len_++] = buffer;
         this->current_frame_locate_++;
       }
       break;
     case LOCATE_ID_FRAME1:
       this->current_frame_id_ = buffer << 8;
-      this->current_frame_len_++;
-      this->current_frame_buf_[this->current_frame_len_ - 1] = buffer;
+      this->current_frame_buf_[this->current_frame_len_++] = buffer;
       this->current_frame_locate_++;
       break;
     case LOCATE_ID_FRAME2:
       this->current_frame_id_ += buffer;
-      this->current_frame_len_++;
-      this->current_frame_buf_[this->current_frame_len_ - 1] = buffer;
+      this->current_frame_buf_[this->current_frame_len_++] = buffer;
       this->current_frame_locate_++;
       break;
     case LOCATE_LENGTH_FRAME_H:
       this->current_data_frame_len_ = buffer << 8;
-      if (this->current_data_frame_len_ == 0x00) {
-        this->current_frame_len_++;
-        this->current_frame_buf_[this->current_frame_len_ - 1] = buffer;
+      if (this->current_data_frame_len_ == 0) {
+        this->current_frame_buf_[this->current_frame_len_++] = buffer;
         this->current_frame_locate_++;
       } else {
         this->current_frame_locate_ = LOCATE_FRAME_HEADER;
@@ -181,15 +178,13 @@ void MR60FDA2Component::split_frame_(uint8_t buffer) {
       if (this->current_data_frame_len_ > DATA_BUF_MAX_SIZE) {
         this->current_frame_locate_ = LOCATE_FRAME_HEADER;
       } else {
-        this->current_frame_len_++;
-        this->current_frame_buf_[this->current_frame_len_ - 1] = buffer;
+        this->current_frame_buf_[this->current_frame_len_++] = buffer;
         this->current_frame_locate_++;
       }
       break;
     case LOCATE_TYPE_FRAME1:
       this->current_frame_type_ = buffer << 8;
-      this->current_frame_len_++;
-      this->current_frame_buf_[this->current_frame_len_ - 1] = buffer;
+      this->current_frame_buf_[this->current_frame_len_++] = buffer;
       this->current_frame_locate_++;
       break;
     case LOCATE_TYPE_FRAME2:
@@ -198,8 +193,7 @@ void MR60FDA2Component::split_frame_(uint8_t buffer) {
           (this->current_frame_type_ == PEOPLE_EXIST_TYPE_BUFFER) ||
           (this->current_frame_type_ == RESULT_INSTALL_HEIGHT) || (this->current_frame_type_ == RESULT_PARAMETERS) ||
           (this->current_frame_type_ == RESULT_HEIGHT_THRESHOLD) || (this->current_frame_type_ == RESULT_SENSITIVITY)) {
-        this->current_frame_len_++;
-        this->current_frame_buf_[this->current_frame_len_ - 1] = buffer;
+        this->current_frame_buf_[this->current_frame_len_++] = buffer;
         this->current_frame_locate_++;
       } else {
         this->current_frame_locate_ = LOCATE_FRAME_HEADER;
@@ -207,8 +201,7 @@ void MR60FDA2Component::split_frame_(uint8_t buffer) {
       break;
     case LOCATE_HEAD_CKSUM_FRAME:
       if (validate_checksum(this->current_frame_buf_, this->current_frame_len_, buffer)) {
-        this->current_frame_len_++;
-        this->current_frame_buf_[this->current_frame_len_ - 1] = buffer;
+        this->current_frame_buf_[this->current_frame_len_++] = buffer;
         this->current_frame_locate_++;
       } else {
         ESP_LOGD(TAG, "HEAD_CKSUM_FRAME ERROR: 0x%02x", buffer);
@@ -223,21 +216,20 @@ void MR60FDA2Component::split_frame_(uint8_t buffer) {
       }
       break;
     case LOCATE_DATA_FRAME:
-      this->current_frame_len_++;
-      this->current_frame_buf_[this->current_frame_len_ - 1] = buffer;
-      this->current_data_buf_[this->current_frame_len_ - LEN_TO_DATA_FRAME] = buffer;
-      if (this->current_frame_len_ - LEN_TO_HEAD_CKSUM == this->current_data_frame_len_) {
-        this->current_frame_locate_++;
-      }
-      if (this->current_frame_len_ > FRAME_BUF_MAX_SIZE) {
+      if (this->current_frame_len_ >= FRAME_BUF_MAX_SIZE) {
         ESP_LOGD(TAG, "PRACTICE_DATA_FRAME_LEN ERROR: %d", this->current_frame_len_ - LEN_TO_HEAD_CKSUM);
         this->current_frame_locate_ = LOCATE_FRAME_HEADER;
+        break;
+      }
+      this->current_data_buf_[this->current_frame_len_ - LEN_TO_DATA_FRAME + 1] = buffer;
+      this->current_frame_buf_[this->current_frame_len_++] = buffer;
+      if (this->current_frame_len_ - LEN_TO_HEAD_CKSUM == this->current_data_frame_len_) {
+        this->current_frame_locate_++;
       }
       break;
     case LOCATE_DATA_CKSUM_FRAME:
       if (validate_checksum(this->current_data_buf_, this->current_data_frame_len_, buffer)) {
-        this->current_frame_len_++;
-        this->current_frame_buf_[this->current_frame_len_ - 1] = buffer;
+        this->current_frame_buf_[this->current_frame_len_++] = buffer;
         this->current_frame_locate_++;
         this->process_frame_();
       } else {
diff --git a/esphome/components/sen21231/sen21231.cpp b/esphome/components/sen21231/sen21231.cpp
index 67001c3f14..8c9f3d7134 100644
--- a/esphome/components/sen21231/sen21231.cpp
+++ b/esphome/components/sen21231/sen21231.cpp
@@ -20,7 +20,12 @@ void Sen21231Sensor::dump_config() {
 
 void Sen21231Sensor::read_data_() {
   person_sensor_results_t results;
-  this->read_bytes(PERSON_SENSOR_I2C_ADDRESS, (uint8_t *) &results, sizeof(results));
+  if (!this->read_bytes(PERSON_SENSOR_I2C_ADDRESS, (uint8_t *) &results, sizeof(results))) {
+    ESP_LOGW(TAG, "Failed to read data from SEN21231");
+    this->status_set_warning();
+    return;
+  }
+  this->status_clear_warning();
   ESP_LOGD(TAG, "SEN21231: %d faces detected", results.num_faces);
   this->publish_state(results.num_faces);
   if (results.num_faces == 1) {
diff --git a/esphome/components/shelly_dimmer/shelly_dimmer.cpp b/esphome/components/shelly_dimmer/shelly_dimmer.cpp
index bdb33d31af..88fcbcbfe1 100644
--- a/esphome/components/shelly_dimmer/shelly_dimmer.cpp
+++ b/esphome/components/shelly_dimmer/shelly_dimmer.cpp
@@ -188,8 +188,8 @@ bool ShellyDimmer::upgrade_firmware_() {
       break;
     }
 
-    std::memcpy(buffer, p, BUFFER_SIZE);
-    p += BUFFER_SIZE;
+    std::memcpy(buffer, p, len);
+    p += len;
 
     if (stm32_write_memory(stm32, addr, buffer, len) != STM32_ERR_OK) {
       ESP_LOGW(TAG, "Failed to write to STM32 flash memory");
diff --git a/esphome/components/smt100/smt100.cpp b/esphome/components/smt100/smt100.cpp
index 1bcb964264..105cc06edb 100644
--- a/esphome/components/smt100/smt100.cpp
+++ b/esphome/components/smt100/smt100.cpp
@@ -12,10 +12,9 @@ void SMT100Component::update() {
 }
 
 void SMT100Component::loop() {
-  static char buffer[MAX_LINE_LENGTH];
   while (this->available() != 0) {
-    if (readline_(read(), buffer, MAX_LINE_LENGTH) > 0) {
-      int counts = (int) strtol((strtok(buffer, ",")), nullptr, 10);
+    if (this->readline_(this->read(), this->readline_buffer_, MAX_LINE_LENGTH) > 0) {
+      int counts = (int) strtol((strtok(this->readline_buffer_, ",")), nullptr, 10);
       float permittivity = (float) strtod((strtok(nullptr, ",")), nullptr);
       float moisture = (float) strtod((strtok(nullptr, ",")), nullptr);
       float temperature = (float) strtod((strtok(nullptr, ",")), nullptr);
@@ -56,7 +55,6 @@ void SMT100Component::dump_config() {
 }
 
 int SMT100Component::readline_(int readch, char *buffer, int len) {
-  static int pos = 0;
   int rpos;
 
   if (readch > 0) {
@@ -64,13 +62,13 @@ int SMT100Component::readline_(int readch, char *buffer, int len) {
       case '\n':  // Ignore new-lines
         break;
       case '\r':  // Return on CR
-        rpos = pos;
-        pos = 0;  // Reset position index ready for next time
+        rpos = this->readline_pos_;
+        this->readline_pos_ = 0;  // Reset position index ready for next time
         return rpos;
       default:
-        if (pos < len - 1) {
-          buffer[pos++] = readch;
-          buffer[pos] = 0;
+        if (this->readline_pos_ < len - 1) {
+          buffer[this->readline_pos_++] = readch;
+          buffer[this->readline_pos_] = 0;
         }
     }
   }
diff --git a/esphome/components/smt100/smt100.h b/esphome/components/smt100/smt100.h
index df8803e1c6..cb01b1ed55 100644
--- a/esphome/components/smt100/smt100.h
+++ b/esphome/components/smt100/smt100.h
@@ -28,6 +28,9 @@ class SMT100Component : public PollingComponent, public uart::UARTDevice {
  protected:
   int readline_(int readch, char *buffer, int len);
 
+  char readline_buffer_[MAX_LINE_LENGTH]{};
+  int readline_pos_{0};
+
   sensor::Sensor *counts_sensor_{nullptr};
   sensor::Sensor *permittivity_sensor_{nullptr};
   sensor::Sensor *moisture_sensor_{nullptr};
diff --git a/esphome/components/template/text/template_text.h b/esphome/components/template/text/template_text.h
index 88c6afdf2c..7f176db09e 100644
--- a/esphome/components/template/text/template_text.h
+++ b/esphome/components/template/text/template_text.h
@@ -52,7 +52,11 @@ template<uint8_t SZ> class TextSaver : public TemplateTextSaverBase {
     bool hasdata = this->pref_.load(&temp);
 
     if (hasdata) {
-      value.assign(temp + 1, (size_t) temp[0]);
+      size_t len = static_cast<uint8_t>(temp[0]);
+      if (len > SZ) {
+        len = SZ;
+      }
+      value.assign(temp + 1, len);
     }
 
     this->prev_.assign(value);
diff --git a/esphome/components/weikai/weikai.cpp b/esphome/components/weikai/weikai.cpp
index 1d835daf1e..3f5d6c787c 100644
--- a/esphome/components/weikai/weikai.cpp
+++ b/esphome/components/weikai/weikai.cpp
@@ -445,6 +445,7 @@ void WeikaiChannel::flush() {
 }
 
 size_t WeikaiChannel::xfer_fifo_to_buffer_() {
+  size_t total = 0;
   size_t to_transfer;
   size_t free;
   while ((to_transfer = this->rx_in_fifo_()) && (free = this->receive_buffer_.free())) {
@@ -458,9 +459,10 @@ size_t WeikaiChannel::xfer_fifo_to_buffer_() {
       this->reg(0).read_fifo(data, to_transfer);
       for (size_t i = 0; i < to_transfer; i++)
         this->receive_buffer_.push(data[i]);
+      total += to_transfer;
     }
   }  // while work to do
-  return to_transfer;
+  return total;
 }
 
 ///
diff --git a/esphome/core/component.cpp b/esphome/core/component.cpp
index 73b2ab544c..364a27a7ca 100644
--- a/esphome/core/component.cpp
+++ b/esphome/core/component.cpp
@@ -437,15 +437,11 @@ void Component::status_set_error(const LogString *message) {
     store_component_error_message(this, LOG_STR_ARG(message), true);
   }
 }
-void Component::status_clear_warning() {
-  if ((this->component_state_ & STATUS_LED_WARNING) == 0)
-    return;
+void Component::status_clear_warning_slow_path_() {
   this->component_state_ &= ~STATUS_LED_WARNING;
   ESP_LOGW(TAG, "%s cleared Warning flag", LOG_STR_ARG(this->get_component_log_str()));
 }
-void Component::status_clear_error() {
-  if ((this->component_state_ & STATUS_LED_ERROR) == 0)
-    return;
+void Component::status_clear_error_slow_path_() {
   this->component_state_ &= ~STATUS_LED_ERROR;
   ESP_LOGE(TAG, "%s cleared Error flag", LOG_STR_ARG(this->get_component_log_str()));
 }
diff --git a/esphome/core/component.h b/esphome/core/component.h
index 59222dc4f4..7266f57e15 100644
--- a/esphome/core/component.h
+++ b/esphome/core/component.h
@@ -251,9 +251,17 @@ class Component {
   void status_set_error(const char *message);
   void status_set_error(const LogString *message);
 
-  void status_clear_warning();
+  void status_clear_warning() {
+    if ((this->component_state_ & STATUS_LED_WARNING) == 0)
+      return;
+    this->status_clear_warning_slow_path_();
+  }
 
-  void status_clear_error();
+  void status_clear_error() {
+    if ((this->component_state_ & STATUS_LED_ERROR) == 0)
+      return;
+    this->status_clear_error_slow_path_();
+  }
 
   /** Set warning status flag and automatically clear it after a timeout.
    *
@@ -505,6 +513,9 @@ class Component {
   bool cancel_defer(const char *name);         // NOLINT
   bool cancel_defer(uint32_t id);              // NOLINT
 
+  void status_clear_warning_slow_path_();
+  void status_clear_error_slow_path_();
+
   // Ordered for optimal packing on 32-bit systems
   const LogString *component_source_{nullptr};
   uint16_t warn_if_blocking_over_{WARN_IF_BLOCKING_OVER_MS};  ///< Warn if blocked for this many ms (max 65.5s)