From f8a1bd4e79449a07420f09b5a88321dbf1ca6d35 Mon Sep 17 00:00:00 2001
From: Jesse Hills <3060199+jesserockz@users.noreply.github.com>
Date: Wed, 11 May 2022 12:50:42 +1200
Subject: [PATCH 01/60] Bump version to 2022.6.0-dev

---
 esphome/const.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/esphome/const.py b/esphome/const.py
index fc928dc530..9a2e41d69f 100644
--- a/esphome/const.py
+++ b/esphome/const.py
@@ -1,6 +1,6 @@
 """Constants used by esphome."""
 
-__version__ = "2022.5.0-dev"
+__version__ = "2022.6.0-dev"
 
 ALLOWED_NAME_CHARS = "abcdefghijklmnopqrstuvwxyz0123456789-_"
 

From 3f678e218d22194de8f2c19dd2a9fa5b009d5d77 Mon Sep 17 00:00:00 2001
From: Maurice Makaay <account+github@makaay.nl>
Date: Wed, 11 May 2022 23:25:00 +0200
Subject: [PATCH 02/60] On epoch sync, restore local TZ (#3462)

Co-authored-by: Maurice Makaay <mmakaay1@xs4all.net>
---
 esphome/components/time/real_time_clock.cpp | 12 ++++++++++--
 esphome/components/time/real_time_clock.h   |  1 +
 2 files changed, 11 insertions(+), 2 deletions(-)

diff --git a/esphome/components/time/real_time_clock.cpp b/esphome/components/time/real_time_clock.cpp
index 36c5f4161d..7b5f0aa49b 100644
--- a/esphome/components/time/real_time_clock.cpp
+++ b/esphome/components/time/real_time_clock.cpp
@@ -13,11 +13,11 @@ static const char *const TAG = "time";
 
 RealTimeClock::RealTimeClock() = default;
 void RealTimeClock::call_setup() {
-  setenv("TZ", this->timezone_.c_str(), 1);
-  tzset();
+  this->apply_timezone_();
   PollingComponent::call_setup();
 }
 void RealTimeClock::synchronize_epoch_(uint32_t epoch) {
+  // Update UTC epoch time.
   struct timeval timev {
     .tv_sec = static_cast<time_t>(epoch), .tv_usec = 0,
   };
@@ -30,6 +30,9 @@ void RealTimeClock::synchronize_epoch_(uint32_t epoch) {
     ret = settimeofday(&timev, nullptr);
   }
 
+  // Move timezone back to local timezone.
+  this->apply_timezone_();
+
   if (ret != 0) {
     ESP_LOGW(TAG, "setimeofday() failed with code %d", ret);
   }
@@ -41,6 +44,11 @@ void RealTimeClock::synchronize_epoch_(uint32_t epoch) {
   this->time_sync_callback_.call();
 }
 
+void RealTimeClock::apply_timezone_() {
+  setenv("TZ", this->timezone_.c_str(), 1);
+  tzset();
+}
+
 size_t ESPTime::strftime(char *buffer, size_t buffer_len, const char *format) {
   struct tm c_tm = this->to_c_tm();
   return ::strftime(buffer, buffer_len, format, &c_tm);
diff --git a/esphome/components/time/real_time_clock.h b/esphome/components/time/real_time_clock.h
index b22c6f04d7..7f4afee306 100644
--- a/esphome/components/time/real_time_clock.h
+++ b/esphome/components/time/real_time_clock.h
@@ -137,6 +137,7 @@ class RealTimeClock : public PollingComponent {
   void synchronize_epoch_(uint32_t epoch);
 
   std::string timezone_{};
+  void apply_timezone_();
 
   CallbackManager<void()> time_sync_callback_;
 };

From c2aaae4818266bf82cfb8650650e9929ad954331 Mon Sep 17 00:00:00 2001
From: Niclas Larsson <niclas@edgesystems.se>
Date: Thu, 12 May 2022 00:26:51 +0200
Subject: [PATCH 03/60] Shelly dimmer: Use unique_ptr to handle the lifetime of
 stm32_t (#3400)

Co-authored-by: Martin <25747549+martgras@users.noreply.github.com>
Co-authored-by: Jesse Hills <3060199+jesserockz@users.noreply.github.com>
---
 .../shelly_dimmer/shelly_dimmer.cpp           |   9 +-
 .../components/shelly_dimmer/stm32flash.cpp   | 119 +++++++++---------
 esphome/components/shelly_dimmer/stm32flash.h |  28 +++--
 3 files changed, 79 insertions(+), 77 deletions(-)

diff --git a/esphome/components/shelly_dimmer/shelly_dimmer.cpp b/esphome/components/shelly_dimmer/shelly_dimmer.cpp
index 3b79d0bf57..32c556da5e 100644
--- a/esphome/components/shelly_dimmer/shelly_dimmer.cpp
+++ b/esphome/components/shelly_dimmer/shelly_dimmer.cpp
@@ -158,11 +158,8 @@ bool ShellyDimmer::upgrade_firmware_() {
   ESP_LOGW(TAG, "Starting STM32 firmware upgrade");
   this->reset_dfu_boot_();
 
-  // Could be constexpr in c++17
-  static const auto CLOSE = [](stm32_t *stm32) { stm32_close(stm32); };
-
   // Cleanup with RAII
-  std::unique_ptr<stm32_t, decltype(CLOSE)> stm32{stm32_init(this, STREAM_SERIAL, 1), CLOSE};
+  auto stm32 = stm32_init(this, STREAM_SERIAL, 1);
 
   if (!stm32) {
     ESP_LOGW(TAG, "Failed to initialize STM32");
@@ -170,7 +167,7 @@ bool ShellyDimmer::upgrade_firmware_() {
   }
 
   // Erase STM32 flash.
-  if (stm32_erase_memory(stm32.get(), 0, STM32_MASS_ERASE) != STM32_ERR_OK) {
+  if (stm32_erase_memory(stm32, 0, STM32_MASS_ERASE) != STM32_ERR_OK) {
     ESP_LOGW(TAG, "Failed to erase STM32 flash memory");
     return false;
   }
@@ -196,7 +193,7 @@ bool ShellyDimmer::upgrade_firmware_() {
     std::memcpy(buffer, p, BUFFER_SIZE);
     p += BUFFER_SIZE;
 
-    if (stm32_write_memory(stm32.get(), addr, buffer, len) != STM32_ERR_OK) {
+    if (stm32_write_memory(stm32, addr, buffer, len) != STM32_ERR_OK) {
       ESP_LOGW(TAG, "Failed to write to STM32 flash memory");
       return false;
     }
diff --git a/esphome/components/shelly_dimmer/stm32flash.cpp b/esphome/components/shelly_dimmer/stm32flash.cpp
index 4c777776fb..e688f2de36 100644
--- a/esphome/components/shelly_dimmer/stm32flash.cpp
+++ b/esphome/components/shelly_dimmer/stm32flash.cpp
@@ -117,7 +117,7 @@ namespace shelly_dimmer {
 
 namespace {
 
-int flash_addr_to_page_ceil(const stm32_t *stm, uint32_t addr) {
+int flash_addr_to_page_ceil(const stm32_unique_ptr &stm, uint32_t addr) {
   if (!(addr >= stm->dev->fl_start && addr <= stm->dev->fl_end))
     return 0;
 
@@ -135,7 +135,7 @@ int flash_addr_to_page_ceil(const stm32_t *stm, uint32_t addr) {
   return addr ? page + 1 : page;
 }
 
-stm32_err_t stm32_get_ack_timeout(const stm32_t *stm, uint32_t timeout) {
+stm32_err_t stm32_get_ack_timeout(const stm32_unique_ptr &stm, uint32_t timeout) {
   auto *stream = stm->stream;
   uint8_t rxbyte;
 
@@ -168,9 +168,9 @@ stm32_err_t stm32_get_ack_timeout(const stm32_t *stm, uint32_t timeout) {
   } while (true);
 }
 
-stm32_err_t stm32_get_ack(const stm32_t *stm) { return stm32_get_ack_timeout(stm, 0); }
+stm32_err_t stm32_get_ack(const stm32_unique_ptr &stm) { return stm32_get_ack_timeout(stm, 0); }
 
-stm32_err_t stm32_send_command_timeout(const stm32_t *stm, const uint8_t cmd, const uint32_t timeout) {
+stm32_err_t stm32_send_command_timeout(const stm32_unique_ptr &stm, const uint8_t cmd, const uint32_t timeout) {
   auto *const stream = stm->stream;
 
   static constexpr auto BUFFER_SIZE = 2;
@@ -194,12 +194,12 @@ stm32_err_t stm32_send_command_timeout(const stm32_t *stm, const uint8_t cmd, co
   return STM32_ERR_UNKNOWN;
 }
 
-stm32_err_t stm32_send_command(const stm32_t *stm, const uint8_t cmd) {
+stm32_err_t stm32_send_command(const stm32_unique_ptr &stm, const uint8_t cmd) {
   return stm32_send_command_timeout(stm, cmd, 0);
 }
 
 /* if we have lost sync, send a wrong command and expect a NACK */
-stm32_err_t stm32_resync(const stm32_t *stm) {
+stm32_err_t stm32_resync(const stm32_unique_ptr &stm) {
   auto *const stream = stm->stream;
   uint32_t t0 = millis();
   auto t1 = t0;
@@ -238,7 +238,7 @@ stm32_err_t stm32_resync(const stm32_t *stm) {
  *
  * len is value of the first byte in the frame.
  */
-stm32_err_t stm32_guess_len_cmd(const stm32_t *stm, const uint8_t cmd, uint8_t *const data, unsigned int len) {
+stm32_err_t stm32_guess_len_cmd(const stm32_unique_ptr &stm, const uint8_t cmd, uint8_t *const data, unsigned int len) {
   auto *const stream = stm->stream;
 
   if (stm32_send_command(stm, cmd) != STM32_ERR_OK)
@@ -286,7 +286,7 @@ stm32_err_t stm32_guess_len_cmd(const stm32_t *stm, const uint8_t cmd, uint8_t *
  * This function sends the init sequence and, in case of timeout, recovers
  * the interface.
  */
-stm32_err_t stm32_send_init_seq(const stm32_t *stm) {
+stm32_err_t stm32_send_init_seq(const stm32_unique_ptr &stm) {
   auto *const stream = stm->stream;
 
   stream->write_array(&STM32_CMD_INIT, 1);
@@ -320,7 +320,7 @@ stm32_err_t stm32_send_init_seq(const stm32_t *stm) {
   return STM32_ERR_UNKNOWN;
 }
 
-stm32_err_t stm32_mass_erase(const stm32_t *stm) {
+stm32_err_t stm32_mass_erase(const stm32_unique_ptr &stm) {
   auto *const stream = stm->stream;
 
   if (stm32_send_command(stm, stm->cmd->er) != STM32_ERR_OK) {
@@ -364,7 +364,7 @@ template<typename T> std::unique_ptr<T[], void (*)(T *memory)> malloc_array_raii
                                                  DELETOR};
 }
 
-stm32_err_t stm32_pages_erase(const stm32_t *stm, const uint32_t spage, const uint32_t pages) {
+stm32_err_t stm32_pages_erase(const stm32_unique_ptr &stm, const uint32_t spage, const uint32_t pages) {
   auto *const stream = stm->stream;
   uint8_t cs = 0;
   int i = 0;
@@ -474,6 +474,18 @@ template<size_t N> void populate_buffer_with_address(uint8_t (&buffer)[N], uint3
   buffer[4] = static_cast<uint8_t>(buffer[0] ^ buffer[1] ^ buffer[2] ^ buffer[3]);
 }
 
+template<typename T> stm32_unique_ptr make_stm32_with_deletor(T ptr) {
+  static const auto CLOSE = [](stm32_t *stm32) {
+    if (stm32) {
+      free(stm32->cmd);  // NOLINT
+    }
+    free(stm32);  // NOLINT
+  };
+
+  // Cleanup with RAII
+  return std::unique_ptr<stm32_t, decltype(CLOSE)>{ptr, CLOSE};
+}
+
 }  // Anonymous namespace
 
 }  // namespace shelly_dimmer
@@ -485,48 +497,44 @@ namespace shelly_dimmer {
 /* find newer command by higher code */
 #define newer(prev, a) (((prev) == STM32_CMD_ERR) ? (a) : (((prev) > (a)) ? (prev) : (a)))
 
-stm32_t *stm32_init(uart::UARTDevice *stream, const uint8_t flags, const char init) {
+stm32_unique_ptr stm32_init(uart::UARTDevice *stream, const uint8_t flags, const char init) {
   uint8_t buf[257];
 
-  // Could be constexpr in c++17
-  static const auto CLOSE = [](stm32_t *stm32) { stm32_close(stm32); };
-
-  // Cleanup with RAII
-  std::unique_ptr<stm32_t, decltype(CLOSE)> stm{static_cast<stm32_t *>(calloc(sizeof(stm32_t), 1)),  // NOLINT
-                                                CLOSE};
+  auto stm = make_stm32_with_deletor(static_cast<stm32_t *>(calloc(sizeof(stm32_t), 1)));  // NOLINT
 
   if (!stm) {
-    return nullptr;
+    return make_stm32_with_deletor(nullptr);
   }
   stm->stream = stream;
   stm->flags = flags;
 
   stm->cmd = static_cast<stm32_cmd_t *>(malloc(sizeof(stm32_cmd_t)));  // NOLINT
   if (!stm->cmd) {
-    return nullptr;
+    return make_stm32_with_deletor(nullptr);
   }
   memset(stm->cmd, STM32_CMD_ERR, sizeof(stm32_cmd_t));
 
   if ((stm->flags & STREAM_OPT_CMD_INIT) && init) {
-    if (stm32_send_init_seq(stm.get()) != STM32_ERR_OK)
-      return nullptr;  // NOLINT
+    if (stm32_send_init_seq(stm) != STM32_ERR_OK)
+      return make_stm32_with_deletor(nullptr);
   }
 
   /* get the version and read protection status  */
-  if (stm32_send_command(stm.get(), STM32_CMD_GVR) != STM32_ERR_OK) {
-    return nullptr;  // NOLINT
+  if (stm32_send_command(stm, STM32_CMD_GVR) != STM32_ERR_OK) {
+    return make_stm32_with_deletor(nullptr);
   }
 
   /* From AN, only UART bootloader returns 3 bytes */
   {
     const auto len = (stm->flags & STREAM_OPT_GVR_ETX) ? 3 : 1;
     if (!stream->read_array(buf, len))
-      return nullptr;  // NOLINT
+      return make_stm32_with_deletor(nullptr);
+
     stm->version = buf[0];
     stm->option1 = (stm->flags & STREAM_OPT_GVR_ETX) ? buf[1] : 0;
     stm->option2 = (stm->flags & STREAM_OPT_GVR_ETX) ? buf[2] : 0;
-    if (stm32_get_ack(stm.get()) != STM32_ERR_OK) {
-      return nullptr;
+    if (stm32_get_ack(stm) != STM32_ERR_OK) {
+      return make_stm32_with_deletor(nullptr);
     }
   }
 
@@ -544,8 +552,8 @@ stm32_t *stm32_init(uart::UARTDevice *stream, const uint8_t flags, const char in
       return STM32_CMD_GET_LENGTH;
     })();
 
-    if (stm32_guess_len_cmd(stm.get(), STM32_CMD_GET, buf, len) != STM32_ERR_OK)
-      return nullptr;
+    if (stm32_guess_len_cmd(stm, STM32_CMD_GET, buf, len) != STM32_ERR_OK)
+      return make_stm32_with_deletor(nullptr);
   }
 
   const auto stop = buf[0] + 1;
@@ -607,23 +615,23 @@ stm32_t *stm32_init(uart::UARTDevice *stream, const uint8_t flags, const char in
   }
   if (new_cmds)
     ESP_LOGD(TAG, ")");
-  if (stm32_get_ack(stm.get()) != STM32_ERR_OK) {
-    return nullptr;
+  if (stm32_get_ack(stm) != STM32_ERR_OK) {
+    return make_stm32_with_deletor(nullptr);
   }
 
   if (stm->cmd->get == STM32_CMD_ERR || stm->cmd->gvr == STM32_CMD_ERR || stm->cmd->gid == STM32_CMD_ERR) {
     ESP_LOGD(TAG, "Error: bootloader did not returned correct information from GET command");
-    return nullptr;
+    return make_stm32_with_deletor(nullptr);
   }
 
   /* get the device ID */
-  if (stm32_guess_len_cmd(stm.get(), stm->cmd->gid, buf, 1) != STM32_ERR_OK) {
-    return nullptr;
+  if (stm32_guess_len_cmd(stm, stm->cmd->gid, buf, 1) != STM32_ERR_OK) {
+    return make_stm32_with_deletor(nullptr);
   }
   const auto returned = buf[0] + 1;
   if (returned < 2) {
     ESP_LOGD(TAG, "Only %d bytes sent in the PID, unknown/unsupported device", returned);
-    return nullptr;
+    return make_stm32_with_deletor(nullptr);
   }
   stm->pid = (buf[1] << 8) | buf[2];
   if (returned > 2) {
@@ -631,8 +639,8 @@ stm32_t *stm32_init(uart::UARTDevice *stream, const uint8_t flags, const char in
     for (auto i = 2; i <= returned; i++)
       ESP_LOGD(TAG, " %02x", buf[i]);
   }
-  if (stm32_get_ack(stm.get()) != STM32_ERR_OK) {
-    return nullptr;
+  if (stm32_get_ack(stm) != STM32_ERR_OK) {
+    return make_stm32_with_deletor(nullptr);
   }
 
   stm->dev = DEVICES;
@@ -641,21 +649,14 @@ stm32_t *stm32_init(uart::UARTDevice *stream, const uint8_t flags, const char in
 
   if (!stm->dev->id) {
     ESP_LOGD(TAG, "Unknown/unsupported device (Device ID: 0x%03x)", stm->pid);
-    return nullptr;
+    return make_stm32_with_deletor(nullptr);
   }
 
-  // TODO: Would be much better if the unique_ptr was returned from this function
-  // Release ownership of unique_ptr
-  return stm.release();  // NOLINT
+  return stm;
 }
 
-void stm32_close(stm32_t *stm) {
-  if (stm)
-    free(stm->cmd);  // NOLINT
-  free(stm);         // NOLINT
-}
-
-stm32_err_t stm32_read_memory(const stm32_t *stm, const uint32_t address, uint8_t *data, const unsigned int len) {
+stm32_err_t stm32_read_memory(const stm32_unique_ptr &stm, const uint32_t address, uint8_t *data,
+                              const unsigned int len) {
   auto *const stream = stm->stream;
 
   if (!len)
@@ -693,7 +694,8 @@ stm32_err_t stm32_read_memory(const stm32_t *stm, const uint32_t address, uint8_
   return STM32_ERR_OK;
 }
 
-stm32_err_t stm32_write_memory(const stm32_t *stm, uint32_t address, const uint8_t *data, const unsigned int len) {
+stm32_err_t stm32_write_memory(const stm32_unique_ptr &stm, uint32_t address, const uint8_t *data,
+                               const unsigned int len) {
   auto *const stream = stm->stream;
 
   if (!len)
@@ -753,7 +755,7 @@ stm32_err_t stm32_write_memory(const stm32_t *stm, uint32_t address, const uint8
   return STM32_ERR_OK;
 }
 
-stm32_err_t stm32_wunprot_memory(const stm32_t *stm) {
+stm32_err_t stm32_wunprot_memory(const stm32_unique_ptr &stm) {
   if (stm->cmd->uw == STM32_CMD_ERR) {
     ESP_LOGD(TAG, "Error: WRITE UNPROTECT command not implemented in bootloader.");
     return STM32_ERR_NO_CMD;
@@ -766,7 +768,7 @@ stm32_err_t stm32_wunprot_memory(const stm32_t *stm) {
                                  []() { ESP_LOGD(TAG, "Error: Failed to WRITE UNPROTECT"); });
 }
 
-stm32_err_t stm32_wprot_memory(const stm32_t *stm) {
+stm32_err_t stm32_wprot_memory(const stm32_unique_ptr &stm) {
   if (stm->cmd->wp == STM32_CMD_ERR) {
     ESP_LOGD(TAG, "Error: WRITE PROTECT command not implemented in bootloader.");
     return STM32_ERR_NO_CMD;
@@ -779,7 +781,7 @@ stm32_err_t stm32_wprot_memory(const stm32_t *stm) {
                                  []() { ESP_LOGD(TAG, "Error: Failed to WRITE PROTECT"); });
 }
 
-stm32_err_t stm32_runprot_memory(const stm32_t *stm) {
+stm32_err_t stm32_runprot_memory(const stm32_unique_ptr &stm) {
   if (stm->cmd->ur == STM32_CMD_ERR) {
     ESP_LOGD(TAG, "Error: READOUT UNPROTECT command not implemented in bootloader.");
     return STM32_ERR_NO_CMD;
@@ -792,7 +794,7 @@ stm32_err_t stm32_runprot_memory(const stm32_t *stm) {
                                  []() { ESP_LOGD(TAG, "Error: Failed to READOUT UNPROTECT"); });
 }
 
-stm32_err_t stm32_readprot_memory(const stm32_t *stm) {
+stm32_err_t stm32_readprot_memory(const stm32_unique_ptr &stm) {
   if (stm->cmd->rp == STM32_CMD_ERR) {
     ESP_LOGD(TAG, "Error: READOUT PROTECT command not implemented in bootloader.");
     return STM32_ERR_NO_CMD;
@@ -805,7 +807,7 @@ stm32_err_t stm32_readprot_memory(const stm32_t *stm) {
                                  []() { ESP_LOGD(TAG, "Error: Failed to READOUT PROTECT"); });
 }
 
-stm32_err_t stm32_erase_memory(const stm32_t *stm, uint32_t spage, uint32_t pages) {
+stm32_err_t stm32_erase_memory(const stm32_unique_ptr &stm, uint32_t spage, uint32_t pages) {
   if (!pages || spage > STM32_MAX_PAGES || ((pages != STM32_MASS_ERASE) && ((spage + pages) > STM32_MAX_PAGES)))
     return STM32_ERR_OK;
 
@@ -847,7 +849,7 @@ stm32_err_t stm32_erase_memory(const stm32_t *stm, uint32_t spage, uint32_t page
   return STM32_ERR_OK;
 }
 
-static stm32_err_t stm32_run_raw_code(const stm32_t *stm, uint32_t target_address, const uint8_t *code,
+static stm32_err_t stm32_run_raw_code(const stm32_unique_ptr &stm, uint32_t target_address, const uint8_t *code,
                                       uint32_t code_size) {
   static constexpr uint32_t BUFFER_SIZE = 256;
 
@@ -893,7 +895,7 @@ static stm32_err_t stm32_run_raw_code(const stm32_t *stm, uint32_t target_addres
   return stm32_go(stm, target_address);
 }
 
-stm32_err_t stm32_go(const stm32_t *stm, const uint32_t address) {
+stm32_err_t stm32_go(const stm32_unique_ptr &stm, const uint32_t address) {
   auto *const stream = stm->stream;
 
   if (stm->cmd->go == STM32_CMD_ERR) {
@@ -916,7 +918,7 @@ stm32_err_t stm32_go(const stm32_t *stm, const uint32_t address) {
   return STM32_ERR_OK;
 }
 
-stm32_err_t stm32_reset_device(const stm32_t *stm) {
+stm32_err_t stm32_reset_device(const stm32_unique_ptr &stm) {
   const auto target_address = stm->dev->ram_start;
 
   if (stm->dev->flags & F_OBLL) {
@@ -927,7 +929,8 @@ stm32_err_t stm32_reset_device(const stm32_t *stm) {
   }
 }
 
-stm32_err_t stm32_crc_memory(const stm32_t *stm, const uint32_t address, const uint32_t length, uint32_t *const crc) {
+stm32_err_t stm32_crc_memory(const stm32_unique_ptr &stm, const uint32_t address, const uint32_t length,
+                             uint32_t *const crc) {
   static constexpr auto BUFFER_SIZE = 5;
   auto *const stream = stm->stream;
 
@@ -1022,7 +1025,7 @@ uint32_t stm32_sw_crc(uint32_t crc, uint8_t *buf, unsigned int len) {
   return crc;
 }
 
-stm32_err_t stm32_crc_wrapper(const stm32_t *stm, uint32_t address, uint32_t length, uint32_t *crc) {
+stm32_err_t stm32_crc_wrapper(const stm32_unique_ptr &stm, uint32_t address, uint32_t length, uint32_t *crc) {
   static constexpr uint32_t CRC_INIT_VALUE = 0xFFFFFFFF;
   static constexpr uint32_t BUFFER_SIZE = 256;
 
diff --git a/esphome/components/shelly_dimmer/stm32flash.h b/esphome/components/shelly_dimmer/stm32flash.h
index c561375c38..d973b35222 100644
--- a/esphome/components/shelly_dimmer/stm32flash.h
+++ b/esphome/components/shelly_dimmer/stm32flash.h
@@ -23,6 +23,7 @@
 #ifdef USE_SHD_FIRMWARE_DATA
 
 #include <cstdint>
+#include <memory>
 #include "esphome/components/uart/uart.h"
 
 namespace esphome {
@@ -108,19 +109,20 @@ struct VarlenCmd {
   uint8_t length;
 };
 
-stm32_t *stm32_init(uart::UARTDevice *stream, uint8_t flags, char init);
-void stm32_close(stm32_t *stm);
-stm32_err_t stm32_read_memory(const stm32_t *stm, uint32_t address, uint8_t *data, unsigned int len);
-stm32_err_t stm32_write_memory(const stm32_t *stm, uint32_t address, const uint8_t *data, unsigned int len);
-stm32_err_t stm32_wunprot_memory(const stm32_t *stm);
-stm32_err_t stm32_wprot_memory(const stm32_t *stm);
-stm32_err_t stm32_erase_memory(const stm32_t *stm, uint32_t spage, uint32_t pages);
-stm32_err_t stm32_go(const stm32_t *stm, uint32_t address);
-stm32_err_t stm32_reset_device(const stm32_t *stm);
-stm32_err_t stm32_readprot_memory(const stm32_t *stm);
-stm32_err_t stm32_runprot_memory(const stm32_t *stm);
-stm32_err_t stm32_crc_memory(const stm32_t *stm, uint32_t address, uint32_t length, uint32_t *crc);
-stm32_err_t stm32_crc_wrapper(const stm32_t *stm, uint32_t address, uint32_t length, uint32_t *crc);
+using stm32_unique_ptr = std::unique_ptr<stm32_t, void (*)(stm32_t *)>;
+
+stm32_unique_ptr stm32_init(uart::UARTDevice *stream, uint8_t flags, char init);
+stm32_err_t stm32_read_memory(const stm32_unique_ptr &stm, uint32_t address, uint8_t *data, unsigned int len);
+stm32_err_t stm32_write_memory(const stm32_unique_ptr &stm, uint32_t address, const uint8_t *data, unsigned int len);
+stm32_err_t stm32_wunprot_memory(const stm32_unique_ptr &stm);
+stm32_err_t stm32_wprot_memory(const stm32_unique_ptr &stm);
+stm32_err_t stm32_erase_memory(const stm32_unique_ptr &stm, uint32_t spage, uint32_t pages);
+stm32_err_t stm32_go(const stm32_unique_ptr &stm, uint32_t address);
+stm32_err_t stm32_reset_device(const stm32_unique_ptr &stm);
+stm32_err_t stm32_readprot_memory(const stm32_unique_ptr &stm);
+stm32_err_t stm32_runprot_memory(const stm32_unique_ptr &stm);
+stm32_err_t stm32_crc_memory(const stm32_unique_ptr &stm, uint32_t address, uint32_t length, uint32_t *crc);
+stm32_err_t stm32_crc_wrapper(const stm32_unique_ptr &stm, uint32_t address, uint32_t length, uint32_t *crc);
 uint32_t stm32_sw_crc(uint32_t crc, uint8_t *buf, unsigned int len);
 
 }  // namespace shelly_dimmer

From 01c4d3c225fca32bc62a39ec7126637262e8957d Mon Sep 17 00:00:00 2001
From: James Szalay <jamestgissendanerjr@gmail.com>
Date: Wed, 11 May 2022 23:26:14 -0400
Subject: [PATCH 04/60] Use heat mode for heat. Move EXT HT to custom presets.
 (#3437)

* Use heat mode for heat. Move EXT HT to custom presets.

* Fix syntax error.
---
 esphome/components/bedjet/bedjet.cpp | 6 ++++--
 esphome/components/bedjet/bedjet.h   | 2 ++
 2 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/esphome/components/bedjet/bedjet.cpp b/esphome/components/bedjet/bedjet.cpp
index 1a932da0c5..38ed6206a8 100644
--- a/esphome/components/bedjet/bedjet.cpp
+++ b/esphome/components/bedjet/bedjet.cpp
@@ -117,7 +117,7 @@ void Bedjet::control(const ClimateCall &call) {
         pkt = this->codec_->get_button_request(BTN_OFF);
         break;
       case climate::CLIMATE_MODE_HEAT:
-        pkt = this->codec_->get_button_request(BTN_EXTHT);
+        pkt = this->codec_->get_button_request(BTN_HEAT);
         break;
       case climate::CLIMATE_MODE_FAN_ONLY:
         pkt = this->codec_->get_button_request(BTN_COOL);
@@ -137,7 +137,7 @@ void Bedjet::control(const ClimateCall &call) {
     } else {
       this->force_refresh_ = true;
       this->mode = mode;
-      // We're using (custom) preset for Turbo & M1-3 presets, so changing climate mode will clear those
+      // We're using (custom) preset for Turbo, EXT HT, & M1-3 presets, so changing climate mode will clear those
       this->custom_preset.reset();
       this->preset.reset();
     }
@@ -186,6 +186,8 @@ void Bedjet::control(const ClimateCall &call) {
       pkt = this->codec_->get_button_request(BTN_M2);
     } else if (preset == "M3") {
       pkt = this->codec_->get_button_request(BTN_M3);
+    } else if (preset == "EXT HT") {
+      pkt = this->codec_->get_button_request(BTN_EXTHT);
     } else {
       ESP_LOGW(TAG, "Unsupported preset: %s", preset.c_str());
       return;
diff --git a/esphome/components/bedjet/bedjet.h b/esphome/components/bedjet/bedjet.h
index b061d2b5ec..0565be6045 100644
--- a/esphome/components/bedjet/bedjet.h
+++ b/esphome/components/bedjet/bedjet.h
@@ -67,6 +67,8 @@ class Bedjet : public climate::Climate, public esphome::ble_client::BLEClientNod
         // We could fetch biodata from bedjet and set these names that way.
         // But then we have to invert the lookup in order to send the right preset.
         // For now, we can leave them as M1-3 to match the remote buttons.
+        // EXT HT added to match remote button.
+        "EXT HT",
         "M1",
         "M2",
         "M3",

From bcb47c306c996340fd19a2e66cbca5985fe059e2 Mon Sep 17 00:00:00 2001
From: swifty99 <swifty1101@gmx.de>
Date: Thu, 12 May 2022 06:53:33 +0200
Subject: [PATCH 05/60] Tcs34725 automatic sampling settings for improved
 dynamics and accuracy (#3258)

Co-authored-by: Daniel Cousens <413395+dcousens@users.noreply.github.com>
Co-authored-by: Jesse Hills <3060199+jesserockz@users.noreply.github.com>
---
 esphome/components/tcs34725/sensor.py    |   3 +-
 esphome/components/tcs34725/tcs34725.cpp | 109 ++++++++++++++++++++---
 esphome/components/tcs34725/tcs34725.h   |   4 +-
 3 files changed, 103 insertions(+), 13 deletions(-)

diff --git a/esphome/components/tcs34725/sensor.py b/esphome/components/tcs34725/sensor.py
index fcc56e395f..d47e9a34c8 100644
--- a/esphome/components/tcs34725/sensor.py
+++ b/esphome/components/tcs34725/sensor.py
@@ -31,6 +31,7 @@ TCS34725Component = tcs34725_ns.class_(
 
 TCS34725IntegrationTime = tcs34725_ns.enum("TCS34725IntegrationTime")
 TCS34725_INTEGRATION_TIMES = {
+    "auto": TCS34725IntegrationTime.TCS34725_INTEGRATION_TIME_AUTO,
     "2.4ms": TCS34725IntegrationTime.TCS34725_INTEGRATION_TIME_2_4MS,
     "24ms": TCS34725IntegrationTime.TCS34725_INTEGRATION_TIME_24MS,
     "50ms": TCS34725IntegrationTime.TCS34725_INTEGRATION_TIME_50MS,
@@ -88,7 +89,7 @@ CONFIG_SCHEMA = (
             cv.Optional(CONF_CLEAR_CHANNEL): color_channel_schema,
             cv.Optional(CONF_ILLUMINANCE): illuminance_schema,
             cv.Optional(CONF_COLOR_TEMPERATURE): color_temperature_schema,
-            cv.Optional(CONF_INTEGRATION_TIME, default="2.4ms"): cv.enum(
+            cv.Optional(CONF_INTEGRATION_TIME, default="auto"): cv.enum(
                 TCS34725_INTEGRATION_TIMES, lower=True
             ),
             cv.Optional(CONF_GAIN, default="1X"): cv.enum(TCS34725_GAINS, upper=True),
diff --git a/esphome/components/tcs34725/tcs34725.cpp b/esphome/components/tcs34725/tcs34725.cpp
index 825f7da4cc..276bf65ebf 100644
--- a/esphome/components/tcs34725/tcs34725.cpp
+++ b/esphome/components/tcs34725/tcs34725.cpp
@@ -136,8 +136,14 @@ void TCS34725Component::calculate_temperature_and_lux_(uint16_t r, uint16_t g, u
   }
   /* Check for saturation and mark the sample as invalid if true */
   if (c >= sat) {
-    ESP_LOGW(TAG, "Saturation too high, discarding sample with saturation %.1f and clear %d", sat, c);
-    return;
+    if (this->integration_time_auto_) {
+      ESP_LOGI(TAG, "Saturation too high, sample discarded, autogain ongoing");
+    } else {
+      ESP_LOGW(
+          TAG,
+          "Saturation too high, sample with saturation %.1f and clear %d treat values carefully or use grey filter",
+          sat, c);
+    }
   }
 
   /* AMS RGB sensors have no IR channel, so the IR content must be */
@@ -149,8 +155,14 @@ void TCS34725Component::calculate_temperature_and_lux_(uint16_t r, uint16_t g, u
   g2 = g - ir;
   b2 = b - ir;
 
+  // discarding super low values? not recemmonded, and avoided by using auto gain.
   if (r2 == 0) {
-    return;
+    // legacy code
+    if (!this->integration_time_auto_) {
+      ESP_LOGW(TAG,
+               "No light detected on red channel, switch to auto gain or adjust timing, values will be unreliable");
+      return;
+    }
   }
 
   // Lux Calculation (DN40 3.2)
@@ -189,7 +201,7 @@ void TCS34725Component::update() {
     this->status_set_warning();
     return;
   }
-  ESP_LOGV(TAG, "Raw values clear=%x red=%x green=%x blue=%x", raw_c, raw_r, raw_g, raw_b);
+  ESP_LOGV(TAG, "Raw values clear=%d red=%d green=%d blue=%d", raw_c, raw_r, raw_g, raw_b);
 
   float channel_c;
   float channel_r;
@@ -220,20 +232,95 @@ void TCS34725Component::update() {
     calculate_temperature_and_lux_(raw_r, raw_g, raw_b, raw_c);
   }
 
-  if (this->illuminance_sensor_ != nullptr)
-    this->illuminance_sensor_->publish_state(this->illuminance_);
+  // do not publish values if auto gain finding ongoing, and oversaturated
+  // so: publish when:
+  // - not auto mode
+  // - clear not oversaturated
+  // - clear oversaturated but gain and timing cannot go lower
+  if (!this->integration_time_auto_ || raw_c < 65530 || (this->gain_reg_ == 0 && this->integration_time_ < 200)) {
+    if (this->illuminance_sensor_ != nullptr)
+      this->illuminance_sensor_->publish_state(this->illuminance_);
 
-  if (this->color_temperature_sensor_ != nullptr)
-    this->color_temperature_sensor_->publish_state(this->color_temperature_);
+    if (this->color_temperature_sensor_ != nullptr)
+      this->color_temperature_sensor_->publish_state(this->color_temperature_);
+  }
 
-  ESP_LOGD(TAG, "Got Red=%.1f%%,Green=%.1f%%,Blue=%.1f%%,Clear=%.1f%% Illuminance=%.1flx Color Temperature=%.1fK",
+  ESP_LOGD(TAG,
+           "Got Red=%.1f%%,Green=%.1f%%,Blue=%.1f%%,Clear=%.1f%% Illuminance=%.1flx Color "
+           "Temperature=%.1fK",
            channel_r, channel_g, channel_b, channel_c, this->illuminance_, this->color_temperature_);
 
+  if (this->integration_time_auto_) {
+    // change integration time an gain to achieve maximum resolution an dynamic range
+    // calculate optimal integration time to achieve 70% satuaration
+    float integration_time_ideal;
+    integration_time_ideal = 60 / ((float) raw_c / 655.35) * this->integration_time_;
+
+    uint8_t gain_reg_val_new = this->gain_reg_;
+    // increase gain if less than 20% of white channel used and high integration time
+    // increase only if not already maximum
+    // do not use max gain, as ist will not get better
+    if (this->gain_reg_ < 3) {
+      if (((float) raw_c / 655.35 < 20.f) && (this->integration_time_ > 600.f)) {
+        gain_reg_val_new = this->gain_reg_ + 1;
+        // update integration time to new situation
+        integration_time_ideal = integration_time_ideal / 4;
+      }
+    }
+
+    // decrease gain, if very high clear values and integration times alreadey low
+    if (this->gain_reg_ > 0) {
+      if (70 < ((float) raw_c / 655.35) && (this->integration_time_ < 200)) {
+        gain_reg_val_new = this->gain_reg_ - 1;
+        // update integration time to new situation
+        integration_time_ideal = integration_time_ideal * 4;
+      }
+    }
+
+    // saturate integration times
+    float integration_time_next = integration_time_ideal;
+    if (integration_time_ideal > 2.4f * 256) {
+      integration_time_next = 2.4f * 256;
+    }
+    if (integration_time_ideal < 154) {
+      integration_time_next = 154;
+    }
+
+    // calculate register value from timing
+    uint8_t regval_atime = (uint8_t)(256.f - integration_time_next / 2.4f);
+    ESP_LOGD(TAG, "Integration time: %.1fms, ideal: %.1fms regval_new %d Gain: %.f Clear channel raw: %d  gain reg: %d",
+             this->integration_time_, integration_time_next, regval_atime, this->gain_, raw_c, this->gain_reg_);
+
+    if (this->integration_reg_ != regval_atime || gain_reg_val_new != this->gain_reg_) {
+      this->integration_reg_ = regval_atime;
+      this->gain_reg_ = gain_reg_val_new;
+      set_gain((TCS34725Gain) gain_reg_val_new);
+      if (this->write_config_register_(TCS34725_REGISTER_ATIME, this->integration_reg_) != i2c::ERROR_OK ||
+          this->write_config_register_(TCS34725_REGISTER_CONTROL, this->gain_reg_) != i2c::ERROR_OK) {
+        this->mark_failed();
+        ESP_LOGW(TAG, "TCS34725I update timing failed!");
+      } else {
+        this->integration_time_ = integration_time_next;
+      }
+    }
+  }
   this->status_clear_warning();
 }
 void TCS34725Component::set_integration_time(TCS34725IntegrationTime integration_time) {
-  this->integration_reg_ = integration_time;
-  this->integration_time_ = (256.f - integration_time) * 2.4f;
+  // if an integration time is 0x100, this is auto start with 154ms as this gives best starting point
+  TCS34725IntegrationTime my_integration_time_regval;
+
+  if (integration_time == TCS34725_INTEGRATION_TIME_AUTO) {
+    this->integration_time_auto_ = true;
+    this->integration_reg_ = TCS34725_INTEGRATION_TIME_154MS;
+    my_integration_time_regval = TCS34725_INTEGRATION_TIME_154MS;
+  } else {
+    this->integration_reg_ = integration_time;
+    my_integration_time_regval = integration_time;
+    this->integration_time_auto_ = false;
+  }
+  this->integration_time_ = (256.f - my_integration_time_regval) * 2.4f;
+  ESP_LOGI(TAG, "TCS34725I Integration time set to: %.1fms", this->integration_time_);
 }
 void TCS34725Component::set_gain(TCS34725Gain gain) {
   this->gain_reg_ = gain;
diff --git a/esphome/components/tcs34725/tcs34725.h b/esphome/components/tcs34725/tcs34725.h
index 04565d948e..23985e8221 100644
--- a/esphome/components/tcs34725/tcs34725.h
+++ b/esphome/components/tcs34725/tcs34725.h
@@ -26,6 +26,7 @@ enum TCS34725IntegrationTime {
   TCS34725_INTEGRATION_TIME_540MS = 0x1F,
   TCS34725_INTEGRATION_TIME_600MS = 0x06,
   TCS34725_INTEGRATION_TIME_614MS = 0x00,
+  TCS34725_INTEGRATION_TIME_AUTO = 0x100,
 };
 
 enum TCS34725Gain {
@@ -77,10 +78,11 @@ class TCS34725Component : public PollingComponent, public i2c::I2CDevice {
   float glass_attenuation_{1.0};
   float illuminance_;
   float color_temperature_;
+  bool integration_time_auto_{true};
 
  private:
   void calculate_temperature_and_lux_(uint16_t r, uint16_t g, uint16_t b, uint16_t c);
-  uint8_t integration_reg_{TCS34725_INTEGRATION_TIME_2_4MS};
+  uint16_t integration_reg_;
   uint8_t gain_reg_{TCS34725_GAIN_1X};
 };
 

From 1c873e003431562737d45271ab2fc5fe3409f5b8 Mon Sep 17 00:00:00 2001
From: Michael Davidson <mrmdavidson@sadorangeproductions.com>
Date: Thu, 12 May 2022 14:54:45 +1000
Subject: [PATCH 06/60] Make custom_fan and custom_preset templatable as per
 documentation (#3330)

---
 esphome/components/climate/__init__.py | 14 ++++++++++----
 1 file changed, 10 insertions(+), 4 deletions(-)

diff --git a/esphome/components/climate/__init__.py b/esphome/components/climate/__init__.py
index 87b9a4b3e2..1de9aa3f3a 100644
--- a/esphome/components/climate/__init__.py
+++ b/esphome/components/climate/__init__.py
@@ -287,9 +287,11 @@ CLIMATE_CONTROL_ACTION_SCHEMA = cv.Schema(
         cv.Exclusive(CONF_FAN_MODE, "fan_mode"): cv.templatable(
             validate_climate_fan_mode
         ),
-        cv.Exclusive(CONF_CUSTOM_FAN_MODE, "fan_mode"): cv.string_strict,
+        cv.Exclusive(CONF_CUSTOM_FAN_MODE, "fan_mode"): cv.templatable(
+            cv.string_strict
+        ),
         cv.Exclusive(CONF_PRESET, "preset"): cv.templatable(validate_climate_preset),
-        cv.Exclusive(CONF_CUSTOM_PRESET, "preset"): cv.string_strict,
+        cv.Exclusive(CONF_CUSTOM_PRESET, "preset"): cv.templatable(cv.string_strict),
         cv.Optional(CONF_SWING_MODE): cv.templatable(validate_climate_swing_mode),
     }
 )
@@ -324,13 +326,17 @@ async def climate_control_to_code(config, action_id, template_arg, args):
         template_ = await cg.templatable(config[CONF_FAN_MODE], args, ClimateFanMode)
         cg.add(var.set_fan_mode(template_))
     if CONF_CUSTOM_FAN_MODE in config:
-        template_ = await cg.templatable(config[CONF_CUSTOM_FAN_MODE], args, str)
+        template_ = await cg.templatable(
+            config[CONF_CUSTOM_FAN_MODE], args, cg.std_string
+        )
         cg.add(var.set_custom_fan_mode(template_))
     if CONF_PRESET in config:
         template_ = await cg.templatable(config[CONF_PRESET], args, ClimatePreset)
         cg.add(var.set_preset(template_))
     if CONF_CUSTOM_PRESET in config:
-        template_ = await cg.templatable(config[CONF_CUSTOM_PRESET], args, str)
+        template_ = await cg.templatable(
+            config[CONF_CUSTOM_PRESET], args, cg.std_string
+        )
         cg.add(var.set_custom_preset(template_))
     if CONF_SWING_MODE in config:
         template_ = await cg.templatable(

From 03d5a0ec1d1d251db9ae8871a80e6960591827fc Mon Sep 17 00:00:00 2001
From: Brian Kaufman <bkaufx@gmail.com>
Date: Wed, 11 May 2022 21:57:50 -0700
Subject: [PATCH 07/60] Update captive portal canHandle function (#3360)

---
 esphome/components/captive_portal/captive_portal.h | 12 +-----------
 1 file changed, 1 insertion(+), 11 deletions(-)

diff --git a/esphome/components/captive_portal/captive_portal.h b/esphome/components/captive_portal/captive_portal.h
index 0e68bc9cef..c2aada171f 100644
--- a/esphome/components/captive_portal/captive_portal.h
+++ b/esphome/components/captive_portal/captive_portal.h
@@ -39,17 +39,7 @@ class CaptivePortal : public AsyncWebHandler, public Component {
     if (request->method() == HTTP_GET) {
       if (request->url() == "/")
         return true;
-      if (request->url() == "/stylesheet.css")
-        return true;
-      if (request->url() == "/wifi-strength-1.svg")
-        return true;
-      if (request->url() == "/wifi-strength-2.svg")
-        return true;
-      if (request->url() == "/wifi-strength-3.svg")
-        return true;
-      if (request->url() == "/wifi-strength-4.svg")
-        return true;
-      if (request->url() == "/lock.svg")
+      if (request->url() == "/config.json")
         return true;
       if (request->url() == "/wifisave")
         return true;

From 39c6c2417ac2b3b20f4dbc2457aa380b330a7fb9 Mon Sep 17 00:00:00 2001
From: Dave T <17680170+davet2001@users.noreply.github.com>
Date: Thu, 12 May 2022 11:18:51 +0100
Subject: [PATCH 08/60] Remove duplicate convert_to_8bit_color_ function.
 (#2469)

Co-authored-by: Oxan van Leeuwen <oxan@oxanvanleeuwen.nl>
---
 .../components/display/display_color_utils.h  |  4 ++-
 .../components/ili9341/ili9341_display.cpp    | 30 ++++---------------
 esphome/components/ili9341/ili9341_display.h  |  2 --
 3 files changed, 8 insertions(+), 28 deletions(-)

diff --git a/esphome/components/display/display_color_utils.h b/esphome/components/display/display_color_utils.h
index 202de912de..7f29586932 100644
--- a/esphome/components/display/display_color_utils.h
+++ b/esphome/components/display/display_color_utils.h
@@ -66,6 +66,9 @@ class ColorUtil {
     }
     return color_return;
   }
+  static inline Color rgb332_to_color(uint8_t rgb332_color) {
+    return to_color((uint32_t) rgb332_color, COLOR_ORDER_RGB, COLOR_BITNESS_332);
+  }
   static uint8_t color_to_332(Color color, ColorOrder color_order = ColorOrder::COLOR_ORDER_RGB) {
     uint16_t red_color, green_color, blue_color;
 
@@ -100,7 +103,6 @@ class ColorUtil {
     }
     return 0;
   }
-
   static uint32_t color_to_grayscale4(Color color) {
     uint32_t gs4 = esp_scale8(color.white, 15);
     return gs4;
diff --git a/esphome/components/ili9341/ili9341_display.cpp b/esphome/components/ili9341/ili9341_display.cpp
index a24f0bbb64..09524ba787 100644
--- a/esphome/components/ili9341/ili9341_display.cpp
+++ b/esphome/components/ili9341/ili9341_display.cpp
@@ -112,29 +112,9 @@ void ILI9341Display::display_() {
   this->y_high_ = 0;
 }
 
-uint16_t ILI9341Display::convert_to_16bit_color_(uint8_t color_8bit) {
-  int r = color_8bit >> 5;
-  int g = (color_8bit >> 2) & 0x07;
-  int b = color_8bit & 0x03;
-  uint16_t color = (r * 0x04) << 11;
-  color |= (g * 0x09) << 5;
-  color |= (b * 0x0A);
-
-  return color;
-}
-
-uint8_t ILI9341Display::convert_to_8bit_color_(uint16_t color_16bit) {
-  // convert 16bit color to 8 bit buffer
-  uint8_t r = color_16bit >> 11;
-  uint8_t g = (color_16bit >> 5) & 0x3F;
-  uint8_t b = color_16bit & 0x1F;
-
-  return ((b / 0x0A) | ((g / 0x09) << 2) | ((r / 0x04) << 5));
-}
-
 void ILI9341Display::fill(Color color) {
-  auto color565 = display::ColorUtil::color_to_565(color);
-  memset(this->buffer_, convert_to_8bit_color_(color565), this->get_buffer_length_());
+  uint8_t color332 = display::ColorUtil::color_to_332(color, display::ColorOrder::COLOR_ORDER_RGB);
+  memset(this->buffer_, color332, this->get_buffer_length_());
   this->x_low_ = 0;
   this->y_low_ = 0;
   this->x_high_ = this->get_width_internal() - 1;
@@ -181,8 +161,8 @@ void HOT ILI9341Display::draw_absolute_pixel_internal(int x, int y, Color color)
   this->y_high_ = (y > this->y_high_) ? y : this->y_high_;
 
   uint32_t pos = (y * width_) + x;
-  auto color565 = display::ColorUtil::color_to_565(color);
-  buffer_[pos] = convert_to_8bit_color_(color565);
+  uint8_t color332 = display::ColorUtil::color_to_332(color, display::ColorOrder::COLOR_ORDER_RGB);
+  buffer_[pos] = color332;
 }
 
 // should return the total size: return this->get_width_internal() * this->get_height_internal() * 2 // 16bit color
@@ -247,7 +227,7 @@ uint32_t ILI9341Display::buffer_to_transfer_(uint32_t pos, uint32_t sz) {
   }
 
   for (uint32_t i = 0; i < sz; ++i) {
-    uint16_t color = convert_to_16bit_color_(*src++);
+    uint16_t color = display::ColorUtil::color_to_565(display::ColorUtil::rgb332_to_color(*src++));
     *dst++ = (uint8_t)(color >> 8);
     *dst++ = (uint8_t) color;
   }
diff --git a/esphome/components/ili9341/ili9341_display.h b/esphome/components/ili9341/ili9341_display.h
index d8c90c9d33..eeff688f4f 100644
--- a/esphome/components/ili9341/ili9341_display.h
+++ b/esphome/components/ili9341/ili9341_display.h
@@ -51,8 +51,6 @@ class ILI9341Display : public PollingComponent,
   void reset_();
   void fill_internal_(Color color);
   void display_();
-  uint16_t convert_to_16bit_color_(uint8_t color_8bit);
-  uint8_t convert_to_8bit_color_(uint16_t color_16bit);
 
   ILI9341Model model_;
   int16_t width_{320};   ///< Display width as modified by current rotation

From 2dc2aec954b6c5dbc65d5898bc65dcce2efd0e1a Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 13 May 2022 13:44:24 +1200
Subject: [PATCH 09/60] Bump esptool from 3.3 to 3.3.1 (#3468)

Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 requirements.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/requirements.txt b/requirements.txt
index e62ef86765..dfe69cd33a 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -7,7 +7,7 @@ tzlocal==4.2    # from time
 tzdata>=2021.1  # from time
 pyserial==3.5
 platformio==5.2.5  # When updating platformio, also update Dockerfile
-esptool==3.3
+esptool==3.3.1
 click==8.1.3
 esphome-dashboard==20220508.0
 aioesphomeapi==10.8.2

From 7a03c7d56fd0b4075c6d3494e404fb4201452872 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Sun, 15 May 2022 19:46:36 +1200
Subject: [PATCH 10/60] Bump pylint from 2.13.8 to 2.13.9 (#3470)

Bumps [pylint](https://github.com/PyCQA/pylint) from 2.13.8 to 2.13.9.
- [Release notes](https://github.com/PyCQA/pylint/releases)
- [Changelog](https://github.com/PyCQA/pylint/blob/main/ChangeLog)
- [Commits](https://github.com/PyCQA/pylint/compare/v2.13.8...v2.13.9)

---
updated-dependencies:
- dependency-name: pylint
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>

Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 requirements_test.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/requirements_test.txt b/requirements_test.txt
index 4b5db8ce87..7c21979647 100644
--- a/requirements_test.txt
+++ b/requirements_test.txt
@@ -1,4 +1,4 @@
-pylint==2.13.8
+pylint==2.13.9
 flake8==4.0.1
 black==22.3.0
 pyupgrade==2.32.1

From fea05e9d33f13a5435f035bcf10d0ea0ef23abc8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=5Bp=CA=B2=C9=B5s=5D?= <pyos100500@gmail.com>
Date: Sun, 15 May 2022 09:53:43 +0200
Subject: [PATCH 11/60] Increase JSON buffer size on overflow (#3475)

---
 esphome/components/json/json_util.cpp | 40 +++++++++++++++++----------
 1 file changed, 26 insertions(+), 14 deletions(-)

diff --git a/esphome/components/json/json_util.cpp b/esphome/components/json/json_util.cpp
index 2bd8112255..7e701af48b 100644
--- a/esphome/components/json/json_util.cpp
+++ b/esphome/components/json/json_util.cpp
@@ -26,21 +26,33 @@ std::string build_json(const json_build_t &f) {
   const size_t free_heap = heap_caps_get_largest_free_block(MALLOC_CAP_8BIT);
 #endif
 
-  const size_t request_size = std::min(free_heap, (size_t) 512);
-
-  DynamicJsonDocument json_document(request_size);
-  if (json_document.capacity() == 0) {
-    ESP_LOGE(TAG, "Could not allocate memory for JSON document! Requested %u bytes, largest free heap block: %u bytes",
-             request_size, free_heap);
-    return "{}";
+  size_t request_size = std::min(free_heap, (size_t) 512);
+  while (true) {
+    ESP_LOGV(TAG, "Attempting to allocate %u bytes for JSON serialization", request_size);
+    DynamicJsonDocument json_document(request_size);
+    if (json_document.capacity() == 0) {
+      ESP_LOGE(TAG,
+               "Could not allocate memory for JSON document! Requested %u bytes, largest free heap block: %u bytes",
+               request_size, free_heap);
+      return "{}";
+    }
+    JsonObject root = json_document.to<JsonObject>();
+    f(root);
+    if (json_document.overflowed()) {
+      if (request_size == free_heap) {
+        ESP_LOGE(TAG, "Could not allocate memory for JSON document! Overflowed largest free heap block: %u bytes",
+                 free_heap);
+        return "{}";
+      }
+      request_size = std::min(request_size * 2, free_heap);
+      continue;
+    }
+    json_document.shrinkToFit();
+    ESP_LOGV(TAG, "Size after shrink %u bytes", json_document.capacity());
+    std::string output;
+    serializeJson(json_document, output);
+    return output;
   }
-  JsonObject root = json_document.to<JsonObject>();
-  f(root);
-  json_document.shrinkToFit();
-  ESP_LOGV(TAG, "Size after shrink %u bytes", json_document.capacity());
-  std::string output;
-  serializeJson(json_document, output);
-  return output;
 }
 
 void parse_json(const std::string &data, const json_parse_t &f) {

From 0665acd1901f8ea1b644d89ab9933d032b288ba7 Mon Sep 17 00:00:00 2001
From: Maxim Ocheretianko <bearpawmaxim@users.noreply.github.com>
Date: Sun, 15 May 2022 22:44:14 +0300
Subject: [PATCH 12/60] Tuya status gpio support (#3466)

---
 esphome/components/tuya/__init__.py |  6 +++++
 esphome/components/tuya/tuya.cpp    | 41 ++++++++++++++++++++++-------
 esphome/components/tuya/tuya.h      |  7 +++--
 tests/test4.yaml                    |  3 +++
 4 files changed, 45 insertions(+), 12 deletions(-)

diff --git a/esphome/components/tuya/__init__.py b/esphome/components/tuya/__init__.py
index 965893e012..2eaaa2a625 100644
--- a/esphome/components/tuya/__init__.py
+++ b/esphome/components/tuya/__init__.py
@@ -1,5 +1,6 @@
 from esphome.components import time
 from esphome import automation
+from esphome import pins
 import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.components import uart
@@ -11,6 +12,7 @@ CONF_IGNORE_MCU_UPDATE_ON_DATAPOINTS = "ignore_mcu_update_on_datapoints"
 
 CONF_ON_DATAPOINT_UPDATE = "on_datapoint_update"
 CONF_DATAPOINT_TYPE = "datapoint_type"
+CONF_STATUS_PIN = "status_pin"
 
 tuya_ns = cg.esphome_ns.namespace("tuya")
 Tuya = tuya_ns.class_("Tuya", cg.Component, uart.UARTDevice)
@@ -88,6 +90,7 @@ CONFIG_SCHEMA = (
             cv.Optional(CONF_IGNORE_MCU_UPDATE_ON_DATAPOINTS): cv.ensure_list(
                 cv.uint8_t
             ),
+            cv.Optional(CONF_STATUS_PIN): pins.gpio_output_pin_schema,
             cv.Optional(CONF_ON_DATAPOINT_UPDATE): automation.validate_automation(
                 {
                     cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
@@ -114,6 +117,9 @@ async def to_code(config):
     if CONF_TIME_ID in config:
         time_ = await cg.get_variable(config[CONF_TIME_ID])
         cg.add(var.set_time_id(time_))
+    if CONF_STATUS_PIN in config:
+        status_pin_ = await cg.gpio_pin_expression(config[CONF_STATUS_PIN])
+        cg.add(var.set_status_pin(status_pin_))
     if CONF_IGNORE_MCU_UPDATE_ON_DATAPOINTS in config:
         for dp in config[CONF_IGNORE_MCU_UPDATE_ON_DATAPOINTS]:
             cg.add(var.add_ignore_mcu_update_on_datapoints(dp))
diff --git a/esphome/components/tuya/tuya.cpp b/esphome/components/tuya/tuya.cpp
index 1fbca7796d..1b35121c57 100644
--- a/esphome/components/tuya/tuya.cpp
+++ b/esphome/components/tuya/tuya.cpp
@@ -3,6 +3,7 @@
 #include "esphome/components/network/util.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/util.h"
+#include "esphome/core/gpio.h"
 
 namespace esphome {
 namespace tuya {
@@ -13,6 +14,9 @@ static const int RECEIVE_TIMEOUT = 300;
 
 void Tuya::setup() {
   this->set_interval("heartbeat", 15000, [this] { this->send_empty_command_(TuyaCommandType::HEARTBEAT); });
+  if (this->status_pin_.has_value()) {
+    this->status_pin_.value()->digital_write(false);
+  }
 }
 
 void Tuya::loop() {
@@ -49,9 +53,12 @@ void Tuya::dump_config() {
       ESP_LOGCONFIG(TAG, "  Datapoint %u: unknown", info.id);
     }
   }
-  if ((this->gpio_status_ != -1) || (this->gpio_reset_ != -1)) {
-    ESP_LOGCONFIG(TAG, "  GPIO Configuration: status: pin %d, reset: pin %d (not supported)", this->gpio_status_,
-                  this->gpio_reset_);
+  if ((this->status_pin_reported_ != -1) || (this->reset_pin_reported_ != -1)) {
+    ESP_LOGCONFIG(TAG, "  GPIO Configuration: status: pin %d, reset: pin %d (not supported)",
+                  this->status_pin_reported_, this->reset_pin_reported_);
+  }
+  if (this->status_pin_.has_value()) {
+    LOG_PIN("  Status Pin: ", this->status_pin_.value());
   }
   ESP_LOGCONFIG(TAG, "  Product: '%s'", this->product_.c_str());
   this->check_uart_settings(9600);
@@ -164,16 +171,27 @@ void Tuya::handle_command_(uint8_t command, uint8_t version, const uint8_t *buff
     }
     case TuyaCommandType::CONF_QUERY: {
       if (len >= 2) {
-        this->gpio_status_ = buffer[0];
-        this->gpio_reset_ = buffer[1];
+        this->status_pin_reported_ = buffer[0];
+        this->reset_pin_reported_ = buffer[1];
       }
       if (this->init_state_ == TuyaInitState::INIT_CONF) {
         // If mcu returned status gpio, then we can omit sending wifi state
-        if (this->gpio_status_ != -1) {
+        if (this->status_pin_reported_ != -1) {
           this->init_state_ = TuyaInitState::INIT_DATAPOINT;
           this->send_empty_command_(TuyaCommandType::DATAPOINT_QUERY);
+          bool is_pin_equals =
+              this->status_pin_.has_value() && this->status_pin_.value()->get_pin() == this->status_pin_reported_;
+          // Configure status pin toggling (if reported and configured) or WIFI_STATE periodic send
+          if (is_pin_equals) {
+            ESP_LOGV(TAG, "Configured status pin %i", this->status_pin_reported_);
+            this->set_interval("wifi", 1000, [this] { this->set_status_pin_(); });
+          } else {
+            ESP_LOGW(TAG, "Supplied status_pin does not equals the reported pin %i. TuyaMcu will work in limited mode.",
+                     this->status_pin_reported_);
+          }
         } else {
           this->init_state_ = TuyaInitState::INIT_WIFI;
+          ESP_LOGV(TAG, "Configured WIFI_STATE periodic send");
           this->set_interval("wifi", 1000, [this] { this->send_wifi_status_(); });
         }
       }
@@ -397,16 +415,19 @@ void Tuya::send_empty_command_(TuyaCommandType command) {
   send_command_(TuyaCommand{.cmd = command, .payload = std::vector<uint8_t>{}});
 }
 
+void Tuya::set_status_pin_() {
+  bool is_network_ready = network::is_connected() && remote_is_connected();
+  this->status_pin_.value()->digital_write(is_network_ready);
+}
+
 void Tuya::send_wifi_status_() {
   uint8_t status = 0x02;
   if (network::is_connected()) {
     status = 0x03;
 
     // Protocol version 3 also supports specifying when connected to "the cloud"
-    if (this->protocol_version_ >= 0x03) {
-      if (remote_is_connected()) {
-        status = 0x04;
-      }
+    if (this->protocol_version_ >= 0x03 && remote_is_connected()) {
+      status = 0x04;
     }
   }
 
diff --git a/esphome/components/tuya/tuya.h b/esphome/components/tuya/tuya.h
index 3828c49b48..3a267d75a7 100644
--- a/esphome/components/tuya/tuya.h
+++ b/esphome/components/tuya/tuya.h
@@ -79,6 +79,7 @@ class Tuya : public Component, public uart::UARTDevice {
   void set_raw_datapoint_value(uint8_t datapoint_id, const std::vector<uint8_t> &value);
   void set_boolean_datapoint_value(uint8_t datapoint_id, bool value);
   void set_integer_datapoint_value(uint8_t datapoint_id, uint32_t value);
+  void set_status_pin(InternalGPIOPin *status_pin) { this->status_pin_ = status_pin; }
   void set_string_datapoint_value(uint8_t datapoint_id, const std::string &value);
   void set_enum_datapoint_value(uint8_t datapoint_id, uint8_t value);
   void set_bitmask_datapoint_value(uint8_t datapoint_id, uint32_t value, uint8_t length);
@@ -115,6 +116,7 @@ class Tuya : public Component, public uart::UARTDevice {
   void set_string_datapoint_value_(uint8_t datapoint_id, const std::string &value, bool forced);
   void set_raw_datapoint_value_(uint8_t datapoint_id, const std::vector<uint8_t> &value, bool forced);
   void send_datapoint_command_(uint8_t datapoint_id, TuyaDatapointType datapoint_type, std::vector<uint8_t> data);
+  void set_status_pin_();
   void send_wifi_status_();
 
 #ifdef USE_TIME
@@ -123,8 +125,9 @@ class Tuya : public Component, public uart::UARTDevice {
 #endif
   TuyaInitState init_state_ = TuyaInitState::INIT_HEARTBEAT;
   uint8_t protocol_version_ = -1;
-  int gpio_status_ = -1;
-  int gpio_reset_ = -1;
+  optional<InternalGPIOPin *> status_pin_{};
+  int status_pin_reported_ = -1;
+  int reset_pin_reported_ = -1;
   uint32_t last_command_timestamp_ = 0;
   uint32_t last_rx_char_timestamp_ = 0;
   std::string product_ = "";
diff --git a/tests/test4.yaml b/tests/test4.yaml
index 54412222b5..82bb9e2f85 100644
--- a/tests/test4.yaml
+++ b/tests/test4.yaml
@@ -57,6 +57,9 @@ time:
 
 tuya:
   time_id: sntp_time
+  status_pin:
+    number: 14
+    inverted: true
 
 pipsolar:
     id: inverter0

From f62d5d3b9d150891a4f80ed9ea24b3a65e6c2981 Mon Sep 17 00:00:00 2001
From: Maxim Ocheretianko <bearpawmaxim@users.noreply.github.com>
Date: Sun, 15 May 2022 22:49:40 +0300
Subject: [PATCH 13/60] Add Tuya select (#3469)

---
 CODEOWNERS                                    |  1 +
 esphome/components/tuya/select/__init__.py    | 47 +++++++++++++++++
 .../components/tuya/select/tuya_select.cpp    | 52 +++++++++++++++++++
 esphome/components/tuya/select/tuya_select.h  | 30 +++++++++++
 esphome/const.py                              |  1 +
 tests/test4.yaml                              |  9 ++++
 6 files changed, 140 insertions(+)
 create mode 100644 esphome/components/tuya/select/__init__.py
 create mode 100644 esphome/components/tuya/select/tuya_select.cpp
 create mode 100644 esphome/components/tuya/select/tuya_select.h

diff --git a/CODEOWNERS b/CODEOWNERS
index e2b29547cb..be6e8be3f7 100644
--- a/CODEOWNERS
+++ b/CODEOWNERS
@@ -222,6 +222,7 @@ esphome/components/tsl2591/* @wjcarpenter
 esphome/components/tuya/binary_sensor/* @jesserockz
 esphome/components/tuya/climate/* @jesserockz
 esphome/components/tuya/number/* @frankiboy1
+esphome/components/tuya/select/* @bearpawmaxim
 esphome/components/tuya/sensor/* @jesserockz
 esphome/components/tuya/switch/* @jesserockz
 esphome/components/tuya/text_sensor/* @dentra
diff --git a/esphome/components/tuya/select/__init__.py b/esphome/components/tuya/select/__init__.py
new file mode 100644
index 0000000000..3d65eda301
--- /dev/null
+++ b/esphome/components/tuya/select/__init__.py
@@ -0,0 +1,47 @@
+from esphome.components import select
+import esphome.config_validation as cv
+import esphome.codegen as cg
+from esphome.const import CONF_OPTIONS, CONF_OPTIMISTIC, CONF_ENUM_DATAPOINT
+from .. import tuya_ns, CONF_TUYA_ID, Tuya
+
+DEPENDENCIES = ["tuya"]
+CODEOWNERS = ["@bearpawmaxim"]
+
+TuyaSelect = tuya_ns.class_("TuyaSelect", select.Select, cg.Component)
+
+
+def ensure_option_map(value):
+    cv.check_not_templatable(value)
+    option = cv.All(cv.int_range(0, 2**8 - 1))
+    mapping = cv.All(cv.string_strict)
+    options_map_schema = cv.Schema({option: mapping})
+    value = options_map_schema(value)
+
+    all_values = list(value.keys())
+    unique_values = set(value.keys())
+    if len(all_values) != len(unique_values):
+        raise cv.Invalid("Mapping values must be unique.")
+
+    return value
+
+
+CONFIG_SCHEMA = select.SELECT_SCHEMA.extend(
+    {
+        cv.GenerateID(): cv.declare_id(TuyaSelect),
+        cv.GenerateID(CONF_TUYA_ID): cv.use_id(Tuya),
+        cv.Required(CONF_ENUM_DATAPOINT): cv.uint8_t,
+        cv.Required(CONF_OPTIONS): ensure_option_map,
+        cv.Optional(CONF_OPTIMISTIC, default=False): cv.boolean,
+    }
+).extend(cv.COMPONENT_SCHEMA)
+
+
+async def to_code(config):
+    options_map = config[CONF_OPTIONS]
+    var = await select.new_select(config, options=list(options_map.values()))
+    await cg.register_component(var, config)
+    cg.add(var.set_select_mappings(list(options_map.keys())))
+    parent = await cg.get_variable(config[CONF_TUYA_ID])
+    cg.add(var.set_tuya_parent(parent))
+    cg.add(var.set_select_id(config[CONF_ENUM_DATAPOINT]))
+    cg.add(var.set_optimistic(config[CONF_OPTIMISTIC]))
diff --git a/esphome/components/tuya/select/tuya_select.cpp b/esphome/components/tuya/select/tuya_select.cpp
new file mode 100644
index 0000000000..a4df0873b0
--- /dev/null
+++ b/esphome/components/tuya/select/tuya_select.cpp
@@ -0,0 +1,52 @@
+#include "esphome/core/log.h"
+#include "tuya_select.h"
+
+namespace esphome {
+namespace tuya {
+
+static const char *const TAG = "tuya.select";
+
+void TuyaSelect::setup() {
+  this->parent_->register_listener(this->select_id_, [this](const TuyaDatapoint &datapoint) {
+    uint8_t enum_value = datapoint.value_enum;
+    ESP_LOGV(TAG, "MCU reported select %u value %u", this->select_id_, enum_value);
+    auto options = this->traits.get_options();
+    auto mappings = this->mappings_;
+    auto it = std::find(mappings.cbegin(), mappings.cend(), enum_value);
+    if (it == mappings.end()) {
+      ESP_LOGW(TAG, "Invalid value %u", enum_value);
+      return;
+    }
+    size_t mapping_idx = std::distance(mappings.cbegin(), it);
+    auto value = this->at(mapping_idx);
+    this->publish_state(value.value());
+  });
+}
+
+void TuyaSelect::control(const std::string &value) {
+  if (this->optimistic_)
+    this->publish_state(value);
+
+  auto idx = this->index_of(value);
+  if (idx.has_value()) {
+    uint8_t mapping = this->mappings_.at(idx.value());
+    ESP_LOGV(TAG, "Setting %u datapoint value to %u:%s", this->select_id_, mapping, value.c_str());
+    this->parent_->set_enum_datapoint_value(this->select_id_, mapping);
+    return;
+  }
+
+  ESP_LOGW(TAG, "Invalid value %s", value.c_str());
+}
+
+void TuyaSelect::dump_config() {
+  LOG_SELECT("", "Tuya Select", this);
+  ESP_LOGCONFIG(TAG, "  Select has datapoint ID %u", this->select_id_);
+  ESP_LOGCONFIG(TAG, "  Options are:");
+  auto options = this->traits.get_options();
+  for (auto i = 0; i < this->mappings_.size(); i++) {
+    ESP_LOGCONFIG(TAG, "    %i: %s", this->mappings_.at(i), options.at(i).c_str());
+  }
+}
+
+}  // namespace tuya
+}  // namespace esphome
diff --git a/esphome/components/tuya/select/tuya_select.h b/esphome/components/tuya/select/tuya_select.h
new file mode 100644
index 0000000000..ab233dc501
--- /dev/null
+++ b/esphome/components/tuya/select/tuya_select.h
@@ -0,0 +1,30 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/components/tuya/tuya.h"
+#include "esphome/components/select/select.h"
+
+namespace esphome {
+namespace tuya {
+
+class TuyaSelect : public select::Select, public Component {
+ public:
+  void setup() override;
+  void dump_config() override;
+
+  void set_tuya_parent(Tuya *parent) { this->parent_ = parent; }
+  void set_optimistic(bool optimistic) { this->optimistic_ = optimistic; }
+  void set_select_id(uint8_t select_id) { this->select_id_ = select_id; }
+  void set_select_mappings(std::vector<uint8_t> mappings) { this->mappings_ = std::move(mappings); }
+
+ protected:
+  void control(const std::string &value) override;
+
+  Tuya *parent_;
+  bool optimistic_ = false;
+  uint8_t select_id_;
+  std::vector<uint8_t> mappings_;
+};
+
+}  // namespace tuya
+}  // namespace esphome
diff --git a/esphome/const.py b/esphome/const.py
index 9a2e41d69f..c2aa53be70 100644
--- a/esphome/const.py
+++ b/esphome/const.py
@@ -198,6 +198,7 @@ CONF_ENABLE_TIME = "enable_time"
 CONF_ENERGY = "energy"
 CONF_ENTITY_CATEGORY = "entity_category"
 CONF_ENTITY_ID = "entity_id"
+CONF_ENUM_DATAPOINT = "enum_datapoint"
 CONF_ESP8266_DISABLE_SSL_SUPPORT = "esp8266_disable_ssl_support"
 CONF_ESPHOME = "esphome"
 CONF_ETHERNET = "ethernet"
diff --git a/tests/test4.yaml b/tests/test4.yaml
index 82bb9e2f85..0e9f14e0d6 100644
--- a/tests/test4.yaml
+++ b/tests/test4.yaml
@@ -61,6 +61,15 @@ tuya:
     number: 14
     inverted: true
 
+select:
+  - platform: tuya
+    id: tuya_select
+    enum_datapoint: 42
+    options:
+      0: Internal
+      1: Floor
+      2: Both
+
 pipsolar:
     id: inverter0
 

From 93e2506279239a3d09511bcfc0db44ee00fa3489 Mon Sep 17 00:00:00 2001
From: Jesse Hills <3060199+jesserockz@users.noreply.github.com>
Date: Mon, 16 May 2022 13:05:20 +1200
Subject: [PATCH 14/60] Mark improv_serial and ESP-IDF usb based serial on
 c3/s2/s3 unsupported (#3477)

---
 esphome/components/improv_serial/__init__.py | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)

diff --git a/esphome/components/improv_serial/__init__.py b/esphome/components/improv_serial/__init__.py
index 21073a8ab3..67a0f7f4ed 100644
--- a/esphome/components/improv_serial/__init__.py
+++ b/esphome/components/improv_serial/__init__.py
@@ -1,6 +1,8 @@
-from esphome.const import CONF_BAUD_RATE, CONF_ID, CONF_LOGGER
+from esphome.components.logger import USB_CDC, USB_SERIAL_JTAG
+from esphome.const import CONF_BAUD_RATE, CONF_HARDWARE_UART, CONF_ID, CONF_LOGGER
 import esphome.codegen as cg
 import esphome.config_validation as cv
+from esphome.core import CORE
 import esphome.final_validate as fv
 
 CODEOWNERS = ["@esphome/core"]
@@ -17,14 +19,19 @@ CONFIG_SCHEMA = cv.Schema(
 ).extend(cv.COMPONENT_SCHEMA)
 
 
-def validate_logger_baud_rate(config):
+def validate_logger(config):
     logger_conf = fv.full_config.get()[CONF_LOGGER]
     if logger_conf[CONF_BAUD_RATE] == 0:
         raise cv.Invalid("improv_serial requires the logger baud_rate to be not 0")
+    if CORE.using_esp_idf:
+        if logger_conf[CONF_HARDWARE_UART] in [USB_SERIAL_JTAG, USB_CDC]:
+            raise cv.Invalid(
+                "improv_serial does not support the selected logger hardware_uart"
+            )
     return config
 
 
-FINAL_VALIDATE_SCHEMA = validate_logger_baud_rate
+FINAL_VALIDATE_SCHEMA = validate_logger
 
 
 async def to_code(config):

From 6dabf24bf35681e98fe01950dd9c77bd28fe4c81 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=5Bp=CA=B2=C9=B5s=5D?= <pyos100500@gmail.com>
Date: Mon, 16 May 2022 05:35:27 +0200
Subject: [PATCH 15/60] MQTT cover: send state even if position is available
 (#3473)

---
 esphome/components/mqtt/mqtt_cover.cpp | 28 +++++++++++---------------
 1 file changed, 12 insertions(+), 16 deletions(-)

diff --git a/esphome/components/mqtt/mqtt_cover.cpp b/esphome/components/mqtt/mqtt_cover.cpp
index e5525bc0f7..0718a24828 100644
--- a/esphome/components/mqtt/mqtt_cover.cpp
+++ b/esphome/components/mqtt/mqtt_cover.cpp
@@ -51,10 +51,9 @@ void MQTTCoverComponent::setup() {
 void MQTTCoverComponent::dump_config() {
   ESP_LOGCONFIG(TAG, "MQTT cover '%s':", this->cover_->get_name().c_str());
   auto traits = this->cover_->get_traits();
-  // no state topic for position
-  bool state_topic = !traits.get_supports_position();
-  LOG_MQTT_COMPONENT(state_topic, true)
-  if (!state_topic) {
+  bool has_command_topic = traits.get_supports_position() || !traits.get_supports_tilt();
+  LOG_MQTT_COMPONENT(true, has_command_topic)
+  if (traits.get_supports_position()) {
     ESP_LOGCONFIG(TAG, "  Position State Topic: '%s'", this->get_position_state_topic().c_str());
     ESP_LOGCONFIG(TAG, "  Position Command Topic: '%s'", this->get_position_command_topic().c_str());
   }
@@ -72,7 +71,6 @@ void MQTTCoverComponent::send_discovery(JsonObject root, mqtt::SendDiscoveryConf
     root[MQTT_OPTIMISTIC] = true;
   }
   if (traits.get_supports_position()) {
-    config.state_topic = false;
     root[MQTT_POSITION_TOPIC] = this->get_position_state_topic();
     root[MQTT_SET_POSITION_TOPIC] = this->get_position_command_topic();
   }
@@ -92,17 +90,7 @@ bool MQTTCoverComponent::send_initial_state() { return this->publish_state(); }
 bool MQTTCoverComponent::publish_state() {
   auto traits = this->cover_->get_traits();
   bool success = true;
-  if (!traits.get_supports_position()) {
-    const char *state_s = "unknown";
-    if (this->cover_->position == COVER_OPEN) {
-      state_s = "open";
-    } else if (this->cover_->position == COVER_CLOSED) {
-      state_s = "closed";
-    }
-
-    if (!this->publish(this->get_state_topic_(), state_s))
-      success = false;
-  } else {
+  if (traits.get_supports_position()) {
     std::string pos = value_accuracy_to_string(roundf(this->cover_->position * 100), 0);
     if (!this->publish(this->get_position_state_topic(), pos))
       success = false;
@@ -112,6 +100,14 @@ bool MQTTCoverComponent::publish_state() {
     if (!this->publish(this->get_tilt_state_topic(), pos))
       success = false;
   }
+  const char *state_s = this->cover_->current_operation == COVER_OPERATION_OPENING   ? "opening"
+                        : this->cover_->current_operation == COVER_OPERATION_CLOSING ? "closing"
+                        : this->cover_->position == COVER_CLOSED                     ? "closed"
+                        : this->cover_->position == COVER_OPEN                       ? "open"
+                        : traits.get_supports_position()                             ? "open"
+                                                                                     : "unknown";
+  if (!this->publish(this->get_state_topic_(), state_s))
+    success = false;
   return success;
 }
 

From 609a2ca5926b1213f242cac02a324821530612c6 Mon Sep 17 00:00:00 2001
From: Martin <25747549+martgras@users.noreply.github.com>
Date: Tue, 17 May 2022 00:59:36 +0200
Subject: [PATCH 16/60] ESP32: Only save to NVS if data was changed (#3479)

---
 esphome/components/esp32/preferences.cpp | 33 +++++++++++++++++++-----
 1 file changed, 27 insertions(+), 6 deletions(-)

diff --git a/esphome/components/esp32/preferences.cpp b/esphome/components/esp32/preferences.cpp
index 8c2b67a942..a78159825e 100644
--- a/esphome/components/esp32/preferences.cpp
+++ b/esphome/components/esp32/preferences.cpp
@@ -118,12 +118,17 @@ class ESP32Preferences : public ESPPreferences {
     // go through vector from back to front (makes erase easier/more efficient)
     for (ssize_t i = s_pending_save.size() - 1; i >= 0; i--) {
       const auto &save = s_pending_save[i];
-      esp_err_t err = nvs_set_blob(nvs_handle, save.key.c_str(), save.data.data(), save.data.size());
-      if (err != 0) {
-        ESP_LOGV(TAG, "nvs_set_blob('%s', len=%u) failed: %s", save.key.c_str(), save.data.size(),
-                 esp_err_to_name(err));
-        any_failed = true;
-        continue;
+      ESP_LOGVV(TAG, "Checking if NVS data %s has changed", save.key.c_str());
+      if (is_changed(nvs_handle, save)) {
+        esp_err_t err = nvs_set_blob(nvs_handle, save.key.c_str(), save.data.data(), save.data.size());
+        if (err != 0) {
+          ESP_LOGV(TAG, "nvs_set_blob('%s', len=%u) failed: %s", save.key.c_str(), save.data.size(),
+                   esp_err_to_name(err));
+          any_failed = true;
+          continue;
+        }
+      } else {
+        ESP_LOGD(TAG, "NVS data not changed skipping %s  len=%u", save.key.c_str(), save.data.size());
       }
       s_pending_save.erase(s_pending_save.begin() + i);
     }
@@ -137,6 +142,22 @@ class ESP32Preferences : public ESPPreferences {
 
     return !any_failed;
   }
+  bool is_changed(const uint32_t nvs_handle, const NVSData &to_save) {
+    NVSData stored_data{};
+    size_t actual_len;
+    esp_err_t err = nvs_get_blob(nvs_handle, to_save.key.c_str(), nullptr, &actual_len);
+    if (err != 0) {
+      ESP_LOGV(TAG, "nvs_get_blob('%s'): %s - the key might not be set yet", to_save.key.c_str(), esp_err_to_name(err));
+      return true;
+    }
+    stored_data.data.reserve(actual_len);
+    err = nvs_get_blob(nvs_handle, to_save.key.c_str(), stored_data.data.data(), &actual_len);
+    if (err != 0) {
+      ESP_LOGV(TAG, "nvs_get_blob('%s') failed: %s", to_save.key.c_str(), esp_err_to_name(err));
+      return true;
+    }
+    return to_save.data == stored_data.data;
+  }
 };
 
 void setup_preferences() {

From 9b6b9c1fa24b272c87232611126dbbbbcbac6a33 Mon Sep 17 00:00:00 2001
From: Samuel Sieb <samuel-github@sieb.net>
Date: Tue, 17 May 2022 01:15:02 -0700
Subject: [PATCH 17/60] Retry Tuya init commands (#3482)

Co-authored-by: Samuel Sieb <samuel@sieb.net>
---
 esphome/components/tuya/tuya.cpp | 28 +++++++++++++++++++++++-----
 esphome/components/tuya/tuya.h   |  2 ++
 2 files changed, 25 insertions(+), 5 deletions(-)

diff --git a/esphome/components/tuya/tuya.cpp b/esphome/components/tuya/tuya.cpp
index 1b35121c57..f4744064e3 100644
--- a/esphome/components/tuya/tuya.cpp
+++ b/esphome/components/tuya/tuya.cpp
@@ -11,6 +11,7 @@ namespace tuya {
 static const char *const TAG = "tuya";
 static const int COMMAND_DELAY = 10;
 static const int RECEIVE_TIMEOUT = 300;
+static const int MAX_RETRIES = 5;
 
 void Tuya::setup() {
   this->set_interval("heartbeat", 15000, [this] { this->send_empty_command_(TuyaCommandType::HEARTBEAT); });
@@ -31,8 +32,12 @@ void Tuya::loop() {
 void Tuya::dump_config() {
   ESP_LOGCONFIG(TAG, "Tuya:");
   if (this->init_state_ != TuyaInitState::INIT_DONE) {
-    ESP_LOGCONFIG(TAG, "  Configuration will be reported when setup is complete. Current init_state: %u",
-                  static_cast<uint8_t>(this->init_state_));
+    if (this->init_failed_) {
+      ESP_LOGCONFIG(TAG, "  Initialization failed. Current init_state: %u", static_cast<uint8_t>(this->init_state_));
+    } else {
+      ESP_LOGCONFIG(TAG, "  Configuration will be reported when setup is complete. Current init_state: %u",
+                    static_cast<uint8_t>(this->init_state_));
+    }
     ESP_LOGCONFIG(TAG, "  If no further output is received, confirm that this is a supported Tuya device.");
     return;
   }
@@ -54,8 +59,8 @@ void Tuya::dump_config() {
     }
   }
   if ((this->status_pin_reported_ != -1) || (this->reset_pin_reported_ != -1)) {
-    ESP_LOGCONFIG(TAG, "  GPIO Configuration: status: pin %d, reset: pin %d (not supported)",
-                  this->status_pin_reported_, this->reset_pin_reported_);
+    ESP_LOGCONFIG(TAG, "  GPIO Configuration: status: pin %d, reset: pin %d", this->status_pin_reported_,
+                  this->reset_pin_reported_);
   }
   if (this->status_pin_.has_value()) {
     LOG_PIN("  Status Pin: ", this->status_pin_.value());
@@ -134,6 +139,8 @@ void Tuya::handle_command_(uint8_t command, uint8_t version, const uint8_t *buff
 
   if (this->expected_response_.has_value() && this->expected_response_ == command_type) {
     this->expected_response_.reset();
+    this->command_queue_.erase(command_queue_.begin());
+    this->init_retries_ = 0;
   }
 
   switch (command_type) {
@@ -396,13 +403,24 @@ void Tuya::process_command_queue_() {
 
   if (this->expected_response_.has_value() && delay > RECEIVE_TIMEOUT) {
     this->expected_response_.reset();
+    if (init_state_ != TuyaInitState::INIT_DONE) {
+      if (++this->init_retries_ >= MAX_RETRIES) {
+        this->init_failed_ = true;
+        ESP_LOGE(TAG, "Initialization failed at init_state %u", static_cast<uint8_t>(this->init_state_));
+        this->command_queue_.erase(command_queue_.begin());
+        this->init_retries_ = 0;
+      }
+    } else {
+      this->command_queue_.erase(command_queue_.begin());
+    }
   }
 
   // Left check of delay since last command in case there's ever a command sent by calling send_raw_command_ directly
   if (delay > COMMAND_DELAY && !this->command_queue_.empty() && this->rx_message_.empty() &&
       !this->expected_response_.has_value()) {
     this->send_raw_command_(command_queue_.front());
-    this->command_queue_.erase(command_queue_.begin());
+    if (!this->expected_response_.has_value())
+      this->command_queue_.erase(command_queue_.begin());
   }
 }
 
diff --git a/esphome/components/tuya/tuya.h b/esphome/components/tuya/tuya.h
index 3a267d75a7..1f21b09c0c 100644
--- a/esphome/components/tuya/tuya.h
+++ b/esphome/components/tuya/tuya.h
@@ -124,6 +124,8 @@ class Tuya : public Component, public uart::UARTDevice {
   optional<time::RealTimeClock *> time_id_{};
 #endif
   TuyaInitState init_state_ = TuyaInitState::INIT_HEARTBEAT;
+  bool init_failed_{false};
+  int init_retries_{0};
   uint8_t protocol_version_ = -1;
   optional<InternalGPIOPin *> status_pin_{};
   int status_pin_reported_ = -1;

From c000e1d6dda3f0b07b2df46b7440a2ba79d33c19 Mon Sep 17 00:00:00 2001
From: Dave T <17680170+davet2001@users.noreply.github.com>
Date: Wed, 18 May 2022 23:23:00 +0100
Subject: [PATCH 18/60] Ili9341 8bit indexed mode pt1 (#2490)

---
 .../components/display/display_color_utils.h  | 47 +++++++++++++++++++
 esphome/components/ili9341/display.py         | 18 +++++++
 .../components/ili9341/ili9341_display.cpp    | 17 +++++--
 esphome/components/ili9341/ili9341_display.h  | 10 ++++
 esphome/const.py                              |  1 +
 5 files changed, 90 insertions(+), 3 deletions(-)

diff --git a/esphome/components/display/display_color_utils.h b/esphome/components/display/display_color_utils.h
index 7f29586932..bf6d5445f1 100644
--- a/esphome/components/display/display_color_utils.h
+++ b/esphome/components/display/display_color_utils.h
@@ -107,6 +107,53 @@ class ColorUtil {
     uint32_t gs4 = esp_scale8(color.white, 15);
     return gs4;
   }
+  /***
+   * Converts a Color value to an 8bit index using a 24bit 888 palette.
+   * Uses euclidiean distance to calculate the linear distance between
+   * two points in an RGB cube, then iterates through the full palette
+   * returning the closest match.
+   * @param[in] color The target color.
+   * @param[in] palette The 256*3 byte RGB palette.
+   * @return The 8 bit index of the closest color (e.g. for display buffer).
+   */
+  // static uint8_t color_to_index8_palette888(Color color, uint8_t *palette) {
+  static uint8_t color_to_index8_palette888(Color color, const uint8_t *palette) {
+    uint8_t closest_index = 0;
+    uint32_t minimum_dist2 = UINT32_MAX;  // Smallest distance^2 to the target
+                                          // so far
+    // int8_t(*plt)[][3] = palette;
+    int16_t tgt_r = color.r;
+    int16_t tgt_g = color.g;
+    int16_t tgt_b = color.b;
+    uint16_t x, y, z;
+    // Loop through each row of the palette
+    for (uint16_t i = 0; i < 256; i++) {
+      // Get the pallet rgb color
+      int16_t plt_r = (int16_t) palette[i * 3 + 0];
+      int16_t plt_g = (int16_t) palette[i * 3 + 1];
+      int16_t plt_b = (int16_t) palette[i * 3 + 2];
+      // Calculate euclidian distance (linear distance in rgb cube).
+      x = (uint32_t) std::abs(tgt_r - plt_r);
+      y = (uint32_t) std::abs(tgt_g - plt_g);
+      z = (uint32_t) std::abs(tgt_b - plt_b);
+      uint32_t dist2 = x * x + y * y + z * z;
+      if (dist2 < minimum_dist2) {
+        minimum_dist2 = dist2;
+        closest_index = (uint8_t) i;
+      }
+    }
+    return closest_index;
+  }
+  /***
+   * Converts an 8bit palette index (e.g. from a display buffer) to a color.
+   * @param[in] index The index to look up.
+   * @param[in] palette The 256*3 byte RGB palette.
+   * @return The RGBW Color object looked up by the palette.
+   */
+  static Color index8_to_color_palette888(uint8_t index, const uint8_t *palette) {
+    Color color = Color(palette[index * 3 + 0], palette[index * 3 + 1], palette[index * 3 + 2], 0);
+    return color;
+  }
 };
 }  // namespace display
 }  // namespace esphome
diff --git a/esphome/components/ili9341/display.py b/esphome/components/ili9341/display.py
index 157e8212bd..6b18196ef1 100644
--- a/esphome/components/ili9341/display.py
+++ b/esphome/components/ili9341/display.py
@@ -3,13 +3,16 @@ import esphome.config_validation as cv
 from esphome import pins
 from esphome.components import display, spi
 from esphome.const import (
+    CONF_COLOR_PALETTE,
     CONF_DC_PIN,
     CONF_ID,
     CONF_LAMBDA,
     CONF_MODEL,
     CONF_PAGES,
+    CONF_RAW_DATA_ID,
     CONF_RESET_PIN,
 )
+from esphome.core import HexInt
 
 DEPENDENCIES = ["spi"]
 
@@ -23,6 +26,7 @@ ILI9341M5Stack = ili9341_ns.class_("ILI9341M5Stack", ili9341)
 ILI9341TFT24 = ili9341_ns.class_("ILI9341TFT24", ili9341)
 
 ILI9341Model = ili9341_ns.enum("ILI9341Model")
+ILI9341ColorMode = ili9341_ns.enum("ILI9341ColorMode")
 
 MODELS = {
     "M5STACK": ILI9341Model.M5STACK,
@@ -31,6 +35,8 @@ MODELS = {
 
 ILI9341_MODEL = cv.enum(MODELS, upper=True, space="_")
 
+COLOR_PALETTE = cv.one_of("NONE", "GRAYSCALE")
+
 CONFIG_SCHEMA = cv.All(
     display.FULL_DISPLAY_SCHEMA.extend(
         {
@@ -39,6 +45,8 @@ CONFIG_SCHEMA = cv.All(
             cv.Required(CONF_DC_PIN): pins.gpio_output_pin_schema,
             cv.Optional(CONF_RESET_PIN): pins.gpio_output_pin_schema,
             cv.Optional(CONF_LED_PIN): pins.gpio_output_pin_schema,
+            cv.Optional(CONF_COLOR_PALETTE, default="NONE"): COLOR_PALETTE,
+            cv.GenerateID(CONF_RAW_DATA_ID): cv.declare_id(cg.uint8),
         }
     )
     .extend(cv.polling_component_schema("1s"))
@@ -73,3 +81,13 @@ async def to_code(config):
     if CONF_LED_PIN in config:
         led_pin = await cg.gpio_pin_expression(config[CONF_LED_PIN])
         cg.add(var.set_led_pin(led_pin))
+
+    if config[CONF_COLOR_PALETTE] == "GRAYSCALE":
+        cg.add(var.set_buffer_color_mode(ILI9341ColorMode.BITS_8_INDEXED))
+        rhs = []
+        for x in range(256):
+            rhs.extend([HexInt(x), HexInt(x), HexInt(x)])
+        prog_arr = cg.progmem_array(config[CONF_RAW_DATA_ID], rhs)
+        cg.add(var.set_palette(prog_arr))
+    else:
+        pass
diff --git a/esphome/components/ili9341/ili9341_display.cpp b/esphome/components/ili9341/ili9341_display.cpp
index 09524ba787..0ad5446d9a 100644
--- a/esphome/components/ili9341/ili9341_display.cpp
+++ b/esphome/components/ili9341/ili9341_display.cpp
@@ -161,8 +161,13 @@ void HOT ILI9341Display::draw_absolute_pixel_internal(int x, int y, Color color)
   this->y_high_ = (y > this->y_high_) ? y : this->y_high_;
 
   uint32_t pos = (y * width_) + x;
-  uint8_t color332 = display::ColorUtil::color_to_332(color, display::ColorOrder::COLOR_ORDER_RGB);
-  buffer_[pos] = color332;
+  if (this->buffer_color_mode_ == BITS_8) {
+    uint8_t color332 = display::ColorUtil::color_to_332(color, display::ColorOrder::COLOR_ORDER_RGB);
+    buffer_[pos] = color332;
+  } else {  // if (this->buffer_color_mode_ == BITS_8_INDEXED) {
+    uint8_t index = display::ColorUtil::color_to_index8_palette888(color, this->palette_);
+    buffer_[pos] = index;
+  }
 }
 
 // should return the total size: return this->get_width_internal() * this->get_height_internal() * 2 // 16bit color
@@ -227,7 +232,13 @@ uint32_t ILI9341Display::buffer_to_transfer_(uint32_t pos, uint32_t sz) {
   }
 
   for (uint32_t i = 0; i < sz; ++i) {
-    uint16_t color = display::ColorUtil::color_to_565(display::ColorUtil::rgb332_to_color(*src++));
+    uint16_t color;
+    if (this->buffer_color_mode_ == BITS_8) {
+      color = display::ColorUtil::color_to_565(display::ColorUtil::rgb332_to_color(*src++));
+    } else {  //  if (this->buffer_color_mode == BITS_8_INDEXED) {
+      Color col = display::ColorUtil::index8_to_color_palette888(*src++, this->palette_);
+      color = display::ColorUtil::color_to_565(col);
+    }
     *dst++ = (uint8_t)(color >> 8);
     *dst++ = (uint8_t) color;
   }
diff --git a/esphome/components/ili9341/ili9341_display.h b/esphome/components/ili9341/ili9341_display.h
index eeff688f4f..6014dbf9a6 100644
--- a/esphome/components/ili9341/ili9341_display.h
+++ b/esphome/components/ili9341/ili9341_display.h
@@ -14,6 +14,11 @@ enum ILI9341Model {
   TFT_24,
 };
 
+enum ILI9341ColorMode {
+  BITS_8,
+  BITS_8_INDEXED,
+};
+
 class ILI9341Display : public PollingComponent,
                        public display::DisplayBuffer,
                        public spi::SPIDevice<spi::BIT_ORDER_MSB_FIRST, spi::CLOCK_POLARITY_LOW,
@@ -24,6 +29,8 @@ class ILI9341Display : public PollingComponent,
   void set_reset_pin(GPIOPin *reset) { this->reset_pin_ = reset; }
   void set_led_pin(GPIOPin *led) { this->led_pin_ = led; }
   void set_model(ILI9341Model model) { this->model_ = model; }
+  void set_palette(const uint8_t *palette) { this->palette_ = palette; }
+  void set_buffer_color_mode(ILI9341ColorMode color_mode) { this->buffer_color_mode_ = color_mode; }
 
   void command(uint8_t value);
   void data(uint8_t value);
@@ -59,6 +66,9 @@ class ILI9341Display : public PollingComponent,
   uint16_t y_low_{0};
   uint16_t x_high_{0};
   uint16_t y_high_{0};
+  const uint8_t *palette_;
+
+  ILI9341ColorMode buffer_color_mode_{BITS_8};
 
   uint32_t get_buffer_length_();
   int get_width_internal() override;
diff --git a/esphome/const.py b/esphome/const.py
index c2aa53be70..b73d7e33bd 100644
--- a/esphome/const.py
+++ b/esphome/const.py
@@ -105,6 +105,7 @@ CONF_COLOR_BRIGHTNESS = "color_brightness"
 CONF_COLOR_CORRECT = "color_correct"
 CONF_COLOR_INTERLOCK = "color_interlock"
 CONF_COLOR_MODE = "color_mode"
+CONF_COLOR_PALETTE = "color_palette"
 CONF_COLOR_TEMPERATURE = "color_temperature"
 CONF_COLORS = "colors"
 CONF_COMMAND = "command"

From 78821056617a9acb35755b2f7a3bdf22965f5c2c Mon Sep 17 00:00:00 2001
From: user897943 <user897943@users.noreply.github.com>
Date: Wed, 18 May 2022 23:25:42 +0100
Subject: [PATCH 19/60] Update bedjet_const.h to remove blank spaces before
 speed steps, fixes Unknown Error when using climate.set_fan_mode in HA
 (#3476)

---
 esphome/components/bedjet/bedjet_const.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/esphome/components/bedjet/bedjet_const.h b/esphome/components/bedjet/bedjet_const.h
index e6bfa45d3a..ae10ca1885 100644
--- a/esphome/components/bedjet/bedjet_const.h
+++ b/esphome/components/bedjet/bedjet_const.h
@@ -66,8 +66,8 @@ enum BedjetCommand : uint8_t {
 
 #define BEDJET_FAN_STEP_NAMES_ \
   { \
-    "  5%", " 10%", " 15%", " 20%", " 25%", " 30%", " 35%", " 40%", " 45%", " 50%", " 55%", " 60%", " 65%", " 70%", \
-        " 75%", " 80%", " 85%", " 90%", " 95%", "100%" \
+    "5%", "10%", "15%", "20%", "25%", "30%", "35%", "40%", "45%", "50%", "55%", "60%", "65%", "70%", "75%", "80%", \
+        "85%", "90%", "95%", "100%" \
   }
 
 static const char *const BEDJET_FAN_STEP_NAMES[20] = BEDJET_FAN_STEP_NAMES_;

From 9c78049359711006cabf94bf02b2c1a46549777f Mon Sep 17 00:00:00 2001
From: myml <wurongjie1@gmail.com>
Date: Thu, 19 May 2022 08:23:50 +0800
Subject: [PATCH 20/60] feat: esp32-camera add stream event (#3285)

---
 esphome/components/esp32_camera/__init__.py   | 37 ++++++++++++++++++-
 .../components/esp32_camera/esp32_camera.cpp  | 16 +++++++-
 .../components/esp32_camera/esp32_camera.h    | 23 ++++++++++++
 3 files changed, 73 insertions(+), 3 deletions(-)

diff --git a/esphome/components/esp32_camera/__init__.py b/esphome/components/esp32_camera/__init__.py
index 912e705766..753b6ed9da 100644
--- a/esphome/components/esp32_camera/__init__.py
+++ b/esphome/components/esp32_camera/__init__.py
@@ -1,5 +1,6 @@
 import esphome.codegen as cg
 import esphome.config_validation as cv
+from esphome import automation
 from esphome import pins
 from esphome.const import (
     CONF_FREQUENCY,
@@ -12,6 +13,7 @@ from esphome.const import (
     CONF_RESOLUTION,
     CONF_BRIGHTNESS,
     CONF_CONTRAST,
+    CONF_TRIGGER_ID,
 )
 from esphome.core import CORE
 from esphome.components.esp32 import add_idf_sdkconfig_option
@@ -23,7 +25,14 @@ AUTO_LOAD = ["psram"]
 
 esp32_camera_ns = cg.esphome_ns.namespace("esp32_camera")
 ESP32Camera = esp32_camera_ns.class_("ESP32Camera", cg.PollingComponent, cg.EntityBase)
-
+ESP32CameraStreamStartTrigger = esp32_camera_ns.class_(
+    "ESP32CameraStreamStartTrigger",
+    automation.Trigger.template(),
+)
+ESP32CameraStreamStopTrigger = esp32_camera_ns.class_(
+    "ESP32CameraStreamStopTrigger",
+    automation.Trigger.template(),
+)
 ESP32CameraFrameSize = esp32_camera_ns.enum("ESP32CameraFrameSize")
 FRAME_SIZES = {
     "160X120": ESP32CameraFrameSize.ESP32_CAMERA_SIZE_160X120,
@@ -111,6 +120,10 @@ CONF_TEST_PATTERN = "test_pattern"
 CONF_MAX_FRAMERATE = "max_framerate"
 CONF_IDLE_FRAMERATE = "idle_framerate"
 
+# stream trigger
+CONF_ON_STREAM_START = "on_stream_start"
+CONF_ON_STREAM_STOP = "on_stream_stop"
+
 camera_range_param = cv.int_range(min=-2, max=2)
 
 CONFIG_SCHEMA = cv.ENTITY_BASE_SCHEMA.extend(
@@ -178,6 +191,20 @@ CONFIG_SCHEMA = cv.ENTITY_BASE_SCHEMA.extend(
         cv.Optional(CONF_IDLE_FRAMERATE, default="0.1 fps"): cv.All(
             cv.framerate, cv.Range(min=0, max=1)
         ),
+        cv.Optional(CONF_ON_STREAM_START): automation.validate_automation(
+            {
+                cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
+                    ESP32CameraStreamStartTrigger
+                ),
+            }
+        ),
+        cv.Optional(CONF_ON_STREAM_STOP): automation.validate_automation(
+            {
+                cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
+                    ESP32CameraStreamStopTrigger
+                ),
+            }
+        ),
     }
 ).extend(cv.COMPONENT_SCHEMA)
 
@@ -238,3 +265,11 @@ async def to_code(config):
     if CORE.using_esp_idf:
         cg.add_library("espressif/esp32-camera", "1.0.0")
         add_idf_sdkconfig_option("CONFIG_RTCIO_SUPPORT_RTC_GPIO_DESC", True)
+
+    for conf in config.get(CONF_ON_STREAM_START, []):
+        trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
+        await automation.build_automation(trigger, [], conf)
+
+    for conf in config.get(CONF_ON_STREAM_STOP, []):
+        trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
+        await automation.build_automation(trigger, [], conf)
diff --git a/esphome/components/esp32_camera/esp32_camera.cpp b/esphome/components/esp32_camera/esp32_camera.cpp
index 851926b083..65b316dc8d 100644
--- a/esphome/components/esp32_camera/esp32_camera.cpp
+++ b/esphome/components/esp32_camera/esp32_camera.cpp
@@ -282,8 +282,20 @@ void ESP32Camera::set_idle_update_interval(uint32_t idle_update_interval) {
 void ESP32Camera::add_image_callback(std::function<void(std::shared_ptr<CameraImage>)> &&f) {
   this->new_image_callback_.add(std::move(f));
 }
-void ESP32Camera::start_stream(CameraRequester requester) { this->stream_requesters_ |= (1U << requester); }
-void ESP32Camera::stop_stream(CameraRequester requester) { this->stream_requesters_ &= ~(1U << requester); }
+void ESP32Camera::add_stream_start_callback(std::function<void()> &&callback) {
+  this->stream_start_callback_.add(std::move(callback));
+}
+void ESP32Camera::add_stream_stop_callback(std::function<void()> &&callback) {
+  this->stream_stop_callback_.add(std::move(callback));
+}
+void ESP32Camera::start_stream(CameraRequester requester) {
+  this->stream_start_callback_.call();
+  this->stream_requesters_ |= (1U << requester);
+}
+void ESP32Camera::stop_stream(CameraRequester requester) {
+  this->stream_stop_callback_.call();
+  this->stream_requesters_ &= ~(1U << requester);
+}
 void ESP32Camera::request_image(CameraRequester requester) { this->single_requesters_ |= (1U << requester); }
 void ESP32Camera::update_camera_parameters() {
   sensor_t *s = esp_camera_sensor_get();
diff --git a/esphome/components/esp32_camera/esp32_camera.h b/esphome/components/esp32_camera/esp32_camera.h
index 743b5bde5f..8bf73a0fa6 100644
--- a/esphome/components/esp32_camera/esp32_camera.h
+++ b/esphome/components/esp32_camera/esp32_camera.h
@@ -2,6 +2,7 @@
 
 #ifdef USE_ESP32
 
+#include "esphome/core/automation.h"
 #include "esphome/core/component.h"
 #include "esphome/core/entity_base.h"
 #include "esphome/core/helpers.h"
@@ -145,6 +146,9 @@ class ESP32Camera : public Component, public EntityBase {
   void request_image(CameraRequester requester);
   void update_camera_parameters();
 
+  void add_stream_start_callback(std::function<void()> &&callback);
+  void add_stream_stop_callback(std::function<void()> &&callback);
+
  protected:
   /* internal methods */
   uint32_t hash_base() override;
@@ -187,6 +191,8 @@ class ESP32Camera : public Component, public EntityBase {
   QueueHandle_t framebuffer_get_queue_;
   QueueHandle_t framebuffer_return_queue_;
   CallbackManager<void(std::shared_ptr<CameraImage>)> new_image_callback_;
+  CallbackManager<void()> stream_start_callback_{};
+  CallbackManager<void()> stream_stop_callback_{};
 
   uint32_t last_idle_request_{0};
   uint32_t last_update_{0};
@@ -195,6 +201,23 @@ class ESP32Camera : public Component, public EntityBase {
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 extern ESP32Camera *global_esp32_camera;
 
+class ESP32CameraStreamStartTrigger : public Trigger<> {
+ public:
+  explicit ESP32CameraStreamStartTrigger(ESP32Camera *parent) {
+    parent->add_stream_start_callback([this]() { this->trigger(); });
+  }
+
+ protected:
+};
+class ESP32CameraStreamStopTrigger : public Trigger<> {
+ public:
+  explicit ESP32CameraStreamStopTrigger(ESP32Camera *parent) {
+    parent->add_stream_stop_callback([this]() { this->trigger(); });
+  }
+
+ protected:
+};
+
 }  // namespace esp32_camera
 }  // namespace esphome
 

From 0ed7db979be7057cd844033b37fe6f7079d16ed7 Mon Sep 17 00:00:00 2001
From: Martin <25747549+martgras@users.noreply.github.com>
Date: Thu, 19 May 2022 02:47:33 +0200
Subject: [PATCH 21/60] Add support for SGP41 (#3382)

Co-authored-by: Jesse Hills <3060199+jesserockz@users.noreply.github.com>
---
 CODEOWNERS                                    |   1 +
 .../sgp40/sensirion_voc_algorithm.cpp         | 628 ------------------
 .../sgp40/sensirion_voc_algorithm.h           | 147 ----
 esphome/components/sgp40/sensor.py            |  68 +-
 esphome/components/sgp40/sgp40.cpp            | 274 --------
 esphome/components/sgp40/sgp40.h              |  93 ---
 esphome/components/sgp4x/__init__.py          |   0
 esphome/components/sgp4x/sensor.py            | 144 ++++
 esphome/components/sgp4x/sgp4x.cpp            | 343 ++++++++++
 esphome/components/sgp4x/sgp4x.h              | 142 ++++
 platformio.ini                                |   2 +
 tests/test2.yaml                              |  23 +-
 12 files changed, 655 insertions(+), 1210 deletions(-)
 delete mode 100644 esphome/components/sgp40/sensirion_voc_algorithm.cpp
 delete mode 100644 esphome/components/sgp40/sensirion_voc_algorithm.h
 delete mode 100644 esphome/components/sgp40/sgp40.cpp
 delete mode 100644 esphome/components/sgp40/sgp40.h
 create mode 100644 esphome/components/sgp4x/__init__.py
 create mode 100644 esphome/components/sgp4x/sensor.py
 create mode 100644 esphome/components/sgp4x/sgp4x.cpp
 create mode 100644 esphome/components/sgp4x/sgp4x.h

diff --git a/CODEOWNERS b/CODEOWNERS
index be6e8be3f7..3e82a372ce 100644
--- a/CODEOWNERS
+++ b/CODEOWNERS
@@ -178,6 +178,7 @@ esphome/components/sen5x/* @martgras
 esphome/components/sensirion_common/* @martgras
 esphome/components/sensor/* @esphome/core
 esphome/components/sgp40/* @SenexCrenshaw
+esphome/components/sgp4x/* @SenexCrenshaw @martgras
 esphome/components/shelly_dimmer/* @edge90 @rnauber
 esphome/components/sht4x/* @sjtrny
 esphome/components/shutdown/* @esphome/core @jsuanet
diff --git a/esphome/components/sgp40/sensirion_voc_algorithm.cpp b/esphome/components/sgp40/sensirion_voc_algorithm.cpp
deleted file mode 100644
index d76b776641..0000000000
--- a/esphome/components/sgp40/sensirion_voc_algorithm.cpp
+++ /dev/null
@@ -1,628 +0,0 @@
-
-#include "sensirion_voc_algorithm.h"
-
-namespace esphome {
-namespace sgp40 {
-
-/* The VOC code were originally created by
- *  https://github.com/Sensirion/embedded-sgp
- * The fixed point arithmetic parts of this code were originally created by
- * https://github.com/PetteriAimonen/libfixmath
- */
-
-/*!< the maximum value of fix16_t */
-#define FIX16_MAXIMUM 0x7FFFFFFF
-/*!< the minimum value of fix16_t */
-static const uint32_t FIX16_MINIMUM = 0x80000000;
-/*!< the value used to indicate overflows when FIXMATH_NO_OVERFLOW is not
- * specified */
-static const uint32_t FIX16_OVERFLOW = 0x80000000;
-/*!< fix16_t value of 1 */
-const uint32_t FIX16_ONE = 0x00010000;
-
-inline fix16_t fix16_from_int(int32_t a) { return a * FIX16_ONE; }
-
-inline int32_t fix16_cast_to_int(fix16_t a) { return (a >> 16); }
-
-/*! Multiplies the two given fix16_t's and returns the result. */
-static fix16_t fix16_mul(fix16_t in_arg0, fix16_t in_arg1);
-
-/*! Divides the first given fix16_t by the second and returns the result. */
-static fix16_t fix16_div(fix16_t a, fix16_t b);
-
-/*! Returns the square root of the given fix16_t. */
-static fix16_t fix16_sqrt(fix16_t in_value);
-
-/*! Returns the exponent (e^) of the given fix16_t. */
-static fix16_t fix16_exp(fix16_t in_value);
-
-static fix16_t fix16_mul(fix16_t in_arg0, fix16_t in_arg1) {
-  // Each argument is divided to 16-bit parts.
-  //                    AB
-  //            *     CD
-  // -----------
-  //                    BD    16 * 16 -> 32 bit products
-  //                 CB
-  //                 AD
-  //                AC
-  //             |----| 64 bit product
-  int32_t a = (in_arg0 >> 16), c = (in_arg1 >> 16);
-  uint32_t b = (in_arg0 & 0xFFFF), d = (in_arg1 & 0xFFFF);
-
-  int32_t ac = a * c;
-  int32_t ad_cb = a * d + c * b;
-  uint32_t bd = b * d;
-
-  int32_t product_hi = ac + (ad_cb >> 16);  // NOLINT
-
-  // Handle carry from lower 32 bits to upper part of result.
-  uint32_t ad_cb_temp = ad_cb << 16;  // NOLINT
-  uint32_t product_lo = bd + ad_cb_temp;
-  if (product_lo < bd)
-    product_hi++;
-
-#ifndef FIXMATH_NO_OVERFLOW
-  // The upper 17 bits should all be the same (the sign).
-  if (product_hi >> 31 != product_hi >> 15)
-    return FIX16_OVERFLOW;
-#endif
-
-#ifdef FIXMATH_NO_ROUNDING
-  return (product_hi << 16) | (product_lo >> 16);
-#else
-  // Subtracting 0x8000 (= 0.5) and then using signed right shift
-  // achieves proper rounding to result-1, except in the corner
-  // case of negative numbers and lowest word = 0x8000.
-  // To handle that, we also have to subtract 1 for negative numbers.
-  uint32_t product_lo_tmp = product_lo;
-  product_lo -= 0x8000;
-  product_lo -= (uint32_t) product_hi >> 31;
-  if (product_lo > product_lo_tmp)
-    product_hi--;
-
-  // Discard the lowest 16 bits. Note that this is not exactly the same
-  // as dividing by 0x10000. For example if product = -1, result will
-  // also be -1 and not 0. This is compensated by adding +1 to the result
-  // and compensating this in turn in the rounding above.
-  fix16_t result = (product_hi << 16) | (product_lo >> 16);  // NOLINT
-  result += 1;
-  return result;
-#endif
-}
-
-static fix16_t fix16_div(fix16_t a, fix16_t b) {
-  // This uses the basic binary restoring division algorithm.
-  // It appears to be faster to do the whole division manually than
-  // trying to compose a 64-bit divide out of 32-bit divisions on
-  // platforms without hardware divide.
-
-  if (b == 0)
-    return FIX16_MINIMUM;
-
-  uint32_t remainder = (a >= 0) ? a : (-a);
-  uint32_t divider = (b >= 0) ? b : (-b);
-
-  uint32_t quotient = 0;
-  uint32_t bit = 0x10000;
-
-  /* The algorithm requires D >= R */
-  while (divider < remainder) {
-    divider <<= 1;
-    bit <<= 1;
-  }
-
-#ifndef FIXMATH_NO_OVERFLOW
-  if (!bit)
-    return FIX16_OVERFLOW;
-#endif
-
-  if (divider & 0x80000000) {
-    // Perform one step manually to avoid overflows later.
-    // We know that divider's bottom bit is 0 here.
-    if (remainder >= divider) {
-      quotient |= bit;
-      remainder -= divider;
-    }
-    divider >>= 1;
-    bit >>= 1;
-  }
-
-  /* Main division loop */
-  while (bit && remainder) {
-    if (remainder >= divider) {
-      quotient |= bit;
-      remainder -= divider;
-    }
-
-    remainder <<= 1;
-    bit >>= 1;
-  }
-
-#ifndef FIXMATH_NO_ROUNDING
-  if (remainder >= divider) {
-    quotient++;
-  }
-#endif
-
-  fix16_t result = quotient;
-
-  /* Figure out the sign of result */
-  if ((a ^ b) & 0x80000000) {
-#ifndef FIXMATH_NO_OVERFLOW
-    if (result == FIX16_MINIMUM)  // NOLINT(clang-diagnostic-sign-compare)
-      return FIX16_OVERFLOW;
-#endif
-
-    result = -result;
-  }
-
-  return result;
-}
-
-static fix16_t fix16_sqrt(fix16_t in_value) {
-  // It is assumed that x is not negative
-
-  uint32_t num = in_value;
-  uint32_t result = 0;
-  uint32_t bit;
-  uint8_t n;
-
-  bit = (uint32_t) 1 << 30;
-  while (bit > num)
-    bit >>= 2;
-
-  // The main part is executed twice, in order to avoid
-  // using 64 bit values in computations.
-  for (n = 0; n < 2; n++) {
-    // First we get the top 24 bits of the answer.
-    while (bit) {
-      if (num >= result + bit) {
-        num -= result + bit;
-        result = (result >> 1) + bit;
-      } else {
-        result = (result >> 1);
-      }
-      bit >>= 2;
-    }
-
-    if (n == 0) {
-      // Then process it again to get the lowest 8 bits.
-      if (num > 65535) {
-        // The remainder 'num' is too large to be shifted left
-        // by 16, so we have to add 1 to result manually and
-        // adjust 'num' accordingly.
-        // num = a - (result + 0.5)^2
-        //     = num + result^2 - (result + 0.5)^2
-        //     = num - result - 0.5
-        num -= result;
-        num = (num << 16) - 0x8000;
-        result = (result << 16) + 0x8000;
-      } else {
-        num <<= 16;
-        result <<= 16;
-      }
-
-      bit = 1 << 14;
-    }
-  }
-
-#ifndef FIXMATH_NO_ROUNDING
-  // Finally, if next bit would have been 1, round the result upwards.
-  if (num > result) {
-    result++;
-  }
-#endif
-
-  return (fix16_t) result;
-}
-
-static fix16_t fix16_exp(fix16_t in_value) {
-  // Function to approximate exp(); optimized more for code size than speed
-
-  // exp(x) for x = +/- {1, 1/8, 1/64, 1/512}
-  fix16_t x = in_value;
-  static const uint8_t NUM_EXP_VALUES = 4;
-  static const fix16_t EXP_POS_VALUES[4] = {F16(2.7182818), F16(1.1331485), F16(1.0157477), F16(1.0019550)};
-  static const fix16_t EXP_NEG_VALUES[4] = {F16(0.3678794), F16(0.8824969), F16(0.9844964), F16(0.9980488)};
-  const fix16_t *exp_values;
-
-  fix16_t res, arg;
-  uint16_t i;
-
-  if (x >= F16(10.3972))
-    return FIX16_MAXIMUM;
-  if (x <= F16(-11.7835))
-    return 0;
-
-  if (x < 0) {
-    x = -x;
-    exp_values = EXP_NEG_VALUES;
-  } else {
-    exp_values = EXP_POS_VALUES;
-  }
-
-  res = FIX16_ONE;
-  arg = FIX16_ONE;
-  for (i = 0; i < NUM_EXP_VALUES; i++) {
-    while (x >= arg) {
-      res = fix16_mul(res, exp_values[i]);
-      x -= arg;
-    }
-    arg >>= 3;
-  }
-  return res;
-}
-
-static void voc_algorithm_init_instances(VocAlgorithmParams *params);
-static void voc_algorithm_mean_variance_estimator_init(VocAlgorithmParams *params);
-static void voc_algorithm_mean_variance_estimator_init_instances(VocAlgorithmParams *params);
-static void voc_algorithm_mean_variance_estimator_set_parameters(VocAlgorithmParams *params, fix16_t std_initial,
-                                                                 fix16_t tau_mean_variance_hours,
-                                                                 fix16_t gating_max_duration_minutes);
-static void voc_algorithm_mean_variance_estimator_set_states(VocAlgorithmParams *params, fix16_t mean, fix16_t std,
-                                                             fix16_t uptime_gamma);
-static fix16_t voc_algorithm_mean_variance_estimator_get_std(VocAlgorithmParams *params);
-static fix16_t voc_algorithm_mean_variance_estimator_get_mean(VocAlgorithmParams *params);
-static void voc_algorithm_mean_variance_estimator_calculate_gamma(VocAlgorithmParams *params,
-                                                                  fix16_t voc_index_from_prior);
-static void voc_algorithm_mean_variance_estimator_process(VocAlgorithmParams *params, fix16_t sraw,
-                                                          fix16_t voc_index_from_prior);
-static void voc_algorithm_mean_variance_estimator_sigmoid_init(VocAlgorithmParams *params);
-static void voc_algorithm_mean_variance_estimator_sigmoid_set_parameters(VocAlgorithmParams *params, fix16_t l,
-                                                                         fix16_t x0, fix16_t k);
-static fix16_t voc_algorithm_mean_variance_estimator_sigmoid_process(VocAlgorithmParams *params, fix16_t sample);
-static void voc_algorithm_mox_model_init(VocAlgorithmParams *params);
-static void voc_algorithm_mox_model_set_parameters(VocAlgorithmParams *params, fix16_t sraw_std, fix16_t sraw_mean);
-static fix16_t voc_algorithm_mox_model_process(VocAlgorithmParams *params, fix16_t sraw);
-static void voc_algorithm_sigmoid_scaled_init(VocAlgorithmParams *params);
-static void voc_algorithm_sigmoid_scaled_set_parameters(VocAlgorithmParams *params, fix16_t offset);
-static fix16_t voc_algorithm_sigmoid_scaled_process(VocAlgorithmParams *params, fix16_t sample);
-static void voc_algorithm_adaptive_lowpass_init(VocAlgorithmParams *params);
-static void voc_algorithm_adaptive_lowpass_set_parameters(VocAlgorithmParams *params);
-static fix16_t voc_algorithm_adaptive_lowpass_process(VocAlgorithmParams *params, fix16_t sample);
-
-void voc_algorithm_init(VocAlgorithmParams *params) {
-  params->mVoc_Index_Offset = F16(VOC_ALGORITHM_VOC_INDEX_OFFSET_DEFAULT);
-  params->mTau_Mean_Variance_Hours = F16(VOC_ALGORITHM_TAU_MEAN_VARIANCE_HOURS);
-  params->mGating_Max_Duration_Minutes = F16(VOC_ALGORITHM_GATING_MAX_DURATION_MINUTES);
-  params->mSraw_Std_Initial = F16(VOC_ALGORITHM_SRAW_STD_INITIAL);
-  params->mUptime = F16(0.);
-  params->mSraw = F16(0.);
-  params->mVoc_Index = 0;
-  voc_algorithm_init_instances(params);
-}
-
-static void voc_algorithm_init_instances(VocAlgorithmParams *params) {
-  voc_algorithm_mean_variance_estimator_init(params);
-  voc_algorithm_mean_variance_estimator_set_parameters(
-      params, params->mSraw_Std_Initial, params->mTau_Mean_Variance_Hours, params->mGating_Max_Duration_Minutes);
-  voc_algorithm_mox_model_init(params);
-  voc_algorithm_mox_model_set_parameters(params, voc_algorithm_mean_variance_estimator_get_std(params),
-                                         voc_algorithm_mean_variance_estimator_get_mean(params));
-  voc_algorithm_sigmoid_scaled_init(params);
-  voc_algorithm_sigmoid_scaled_set_parameters(params, params->mVoc_Index_Offset);
-  voc_algorithm_adaptive_lowpass_init(params);
-  voc_algorithm_adaptive_lowpass_set_parameters(params);
-}
-
-void voc_algorithm_get_states(VocAlgorithmParams *params, int32_t *state0, int32_t *state1) {
-  *state0 = voc_algorithm_mean_variance_estimator_get_mean(params);
-  *state1 = voc_algorithm_mean_variance_estimator_get_std(params);
-}
-
-void voc_algorithm_set_states(VocAlgorithmParams *params, int32_t state0, int32_t state1) {
-  voc_algorithm_mean_variance_estimator_set_states(params, state0, state1, F16(VOC_ALGORITHM_PERSISTENCE_UPTIME_GAMMA));
-  params->mSraw = state0;
-}
-
-void voc_algorithm_set_tuning_parameters(VocAlgorithmParams *params, int32_t voc_index_offset,
-                                         int32_t learning_time_hours, int32_t gating_max_duration_minutes,
-                                         int32_t std_initial) {
-  params->mVoc_Index_Offset = (fix16_from_int(voc_index_offset));
-  params->mTau_Mean_Variance_Hours = (fix16_from_int(learning_time_hours));
-  params->mGating_Max_Duration_Minutes = (fix16_from_int(gating_max_duration_minutes));
-  params->mSraw_Std_Initial = (fix16_from_int(std_initial));
-  voc_algorithm_init_instances(params);
-}
-
-void voc_algorithm_process(VocAlgorithmParams *params, int32_t sraw, int32_t *voc_index) {
-  if ((params->mUptime <= F16(VOC_ALGORITHM_INITIAL_BLACKOUT))) {
-    params->mUptime = (params->mUptime + F16(VOC_ALGORITHM_SAMPLING_INTERVAL));
-  } else {
-    if (((sraw > 0) && (sraw < 65000))) {
-      if ((sraw < 20001)) {
-        sraw = 20001;
-      } else if ((sraw > 52767)) {
-        sraw = 52767;
-      }
-      params->mSraw = (fix16_from_int((sraw - 20000)));
-    }
-    params->mVoc_Index = voc_algorithm_mox_model_process(params, params->mSraw);
-    params->mVoc_Index = voc_algorithm_sigmoid_scaled_process(params, params->mVoc_Index);
-    params->mVoc_Index = voc_algorithm_adaptive_lowpass_process(params, params->mVoc_Index);
-    if ((params->mVoc_Index < F16(0.5))) {
-      params->mVoc_Index = F16(0.5);
-    }
-    if ((params->mSraw > F16(0.))) {
-      voc_algorithm_mean_variance_estimator_process(params, params->mSraw, params->mVoc_Index);
-      voc_algorithm_mox_model_set_parameters(params, voc_algorithm_mean_variance_estimator_get_std(params),
-                                             voc_algorithm_mean_variance_estimator_get_mean(params));
-    }
-  }
-  *voc_index = (fix16_cast_to_int((params->mVoc_Index + F16(0.5))));
-}
-
-static void voc_algorithm_mean_variance_estimator_init(VocAlgorithmParams *params) {
-  voc_algorithm_mean_variance_estimator_set_parameters(params, F16(0.), F16(0.), F16(0.));
-  voc_algorithm_mean_variance_estimator_init_instances(params);
-}
-
-static void voc_algorithm_mean_variance_estimator_init_instances(VocAlgorithmParams *params) {
-  voc_algorithm_mean_variance_estimator_sigmoid_init(params);
-}
-
-static void voc_algorithm_mean_variance_estimator_set_parameters(VocAlgorithmParams *params, fix16_t std_initial,
-                                                                 fix16_t tau_mean_variance_hours,
-                                                                 fix16_t gating_max_duration_minutes) {
-  params->m_Mean_Variance_Estimator_Gating_Max_Duration_Minutes = gating_max_duration_minutes;
-  params->m_Mean_Variance_Estimator_Initialized = false;
-  params->m_Mean_Variance_Estimator_Mean = F16(0.);
-  params->m_Mean_Variance_Estimator_Sraw_Offset = F16(0.);
-  params->m_Mean_Variance_Estimator_Std = std_initial;
-  params->m_Mean_Variance_Estimator_Gamma =
-      (fix16_div(F16((VOC_ALGORITHM_MEAN_VARIANCE_ESTIMATOR_GAMMA_SCALING * (VOC_ALGORITHM_SAMPLING_INTERVAL / 3600.))),
-                 (tau_mean_variance_hours + F16((VOC_ALGORITHM_SAMPLING_INTERVAL / 3600.)))));
-  params->m_Mean_Variance_Estimator_Gamma_Initial_Mean =
-      F16(((VOC_ALGORITHM_MEAN_VARIANCE_ESTIMATOR_GAMMA_SCALING * VOC_ALGORITHM_SAMPLING_INTERVAL) /
-           (VOC_ALGORITHM_TAU_INITIAL_MEAN + VOC_ALGORITHM_SAMPLING_INTERVAL)));
-  params->m_Mean_Variance_Estimator_Gamma_Initial_Variance =
-      F16(((VOC_ALGORITHM_MEAN_VARIANCE_ESTIMATOR_GAMMA_SCALING * VOC_ALGORITHM_SAMPLING_INTERVAL) /
-           (VOC_ALGORITHM_TAU_INITIAL_VARIANCE + VOC_ALGORITHM_SAMPLING_INTERVAL)));
-  params->m_Mean_Variance_Estimator_Gamma_Mean = F16(0.);
-  params->m_Mean_Variance_Estimator_Gamma_Variance = F16(0.);
-  params->m_Mean_Variance_Estimator_Uptime_Gamma = F16(0.);
-  params->m_Mean_Variance_Estimator_Uptime_Gating = F16(0.);
-  params->m_Mean_Variance_Estimator_Gating_Duration_Minutes = F16(0.);
-}
-
-static void voc_algorithm_mean_variance_estimator_set_states(VocAlgorithmParams *params, fix16_t mean, fix16_t std,
-                                                             fix16_t uptime_gamma) {
-  params->m_Mean_Variance_Estimator_Mean = mean;
-  params->m_Mean_Variance_Estimator_Std = std;
-  params->m_Mean_Variance_Estimator_Uptime_Gamma = uptime_gamma;
-  params->m_Mean_Variance_Estimator_Initialized = true;
-}
-
-static fix16_t voc_algorithm_mean_variance_estimator_get_std(VocAlgorithmParams *params) {
-  return params->m_Mean_Variance_Estimator_Std;
-}
-
-static fix16_t voc_algorithm_mean_variance_estimator_get_mean(VocAlgorithmParams *params) {
-  return (params->m_Mean_Variance_Estimator_Mean + params->m_Mean_Variance_Estimator_Sraw_Offset);
-}
-
-static void voc_algorithm_mean_variance_estimator_calculate_gamma(VocAlgorithmParams *params,
-                                                                  fix16_t voc_index_from_prior) {
-  fix16_t uptime_limit;
-  fix16_t sigmoid_gamma_mean;
-  fix16_t gamma_mean;
-  fix16_t gating_threshold_mean;
-  fix16_t sigmoid_gating_mean;
-  fix16_t sigmoid_gamma_variance;
-  fix16_t gamma_variance;
-  fix16_t gating_threshold_variance;
-  fix16_t sigmoid_gating_variance;
-
-  uptime_limit = F16((VOC_ALGORITHM_MEAN_VARIANCE_ESTIMATOR_FI_X16_MAX - VOC_ALGORITHM_SAMPLING_INTERVAL));
-  if ((params->m_Mean_Variance_Estimator_Uptime_Gamma < uptime_limit)) {
-    params->m_Mean_Variance_Estimator_Uptime_Gamma =
-        (params->m_Mean_Variance_Estimator_Uptime_Gamma + F16(VOC_ALGORITHM_SAMPLING_INTERVAL));
-  }
-  if ((params->m_Mean_Variance_Estimator_Uptime_Gating < uptime_limit)) {
-    params->m_Mean_Variance_Estimator_Uptime_Gating =
-        (params->m_Mean_Variance_Estimator_Uptime_Gating + F16(VOC_ALGORITHM_SAMPLING_INTERVAL));
-  }
-  voc_algorithm_mean_variance_estimator_sigmoid_set_parameters(params, F16(1.), F16(VOC_ALGORITHM_INIT_DURATION_MEAN),
-                                                               F16(VOC_ALGORITHM_INIT_TRANSITION_MEAN));
-  sigmoid_gamma_mean =
-      voc_algorithm_mean_variance_estimator_sigmoid_process(params, params->m_Mean_Variance_Estimator_Uptime_Gamma);
-  gamma_mean =
-      (params->m_Mean_Variance_Estimator_Gamma +
-       (fix16_mul((params->m_Mean_Variance_Estimator_Gamma_Initial_Mean - params->m_Mean_Variance_Estimator_Gamma),
-                  sigmoid_gamma_mean)));
-  gating_threshold_mean = (F16(VOC_ALGORITHM_GATING_THRESHOLD) +
-                           (fix16_mul(F16((VOC_ALGORITHM_GATING_THRESHOLD_INITIAL - VOC_ALGORITHM_GATING_THRESHOLD)),
-                                      voc_algorithm_mean_variance_estimator_sigmoid_process(
-                                          params, params->m_Mean_Variance_Estimator_Uptime_Gating))));
-  voc_algorithm_mean_variance_estimator_sigmoid_set_parameters(params, F16(1.), gating_threshold_mean,
-                                                               F16(VOC_ALGORITHM_GATING_THRESHOLD_TRANSITION));
-  sigmoid_gating_mean = voc_algorithm_mean_variance_estimator_sigmoid_process(params, voc_index_from_prior);
-  params->m_Mean_Variance_Estimator_Gamma_Mean = (fix16_mul(sigmoid_gating_mean, gamma_mean));
-  voc_algorithm_mean_variance_estimator_sigmoid_set_parameters(
-      params, F16(1.), F16(VOC_ALGORITHM_INIT_DURATION_VARIANCE), F16(VOC_ALGORITHM_INIT_TRANSITION_VARIANCE));
-  sigmoid_gamma_variance =
-      voc_algorithm_mean_variance_estimator_sigmoid_process(params, params->m_Mean_Variance_Estimator_Uptime_Gamma);
-  gamma_variance =
-      (params->m_Mean_Variance_Estimator_Gamma +
-       (fix16_mul((params->m_Mean_Variance_Estimator_Gamma_Initial_Variance - params->m_Mean_Variance_Estimator_Gamma),
-                  (sigmoid_gamma_variance - sigmoid_gamma_mean))));
-  gating_threshold_variance =
-      (F16(VOC_ALGORITHM_GATING_THRESHOLD) +
-       (fix16_mul(F16((VOC_ALGORITHM_GATING_THRESHOLD_INITIAL - VOC_ALGORITHM_GATING_THRESHOLD)),
-                  voc_algorithm_mean_variance_estimator_sigmoid_process(
-                      params, params->m_Mean_Variance_Estimator_Uptime_Gating))));
-  voc_algorithm_mean_variance_estimator_sigmoid_set_parameters(params, F16(1.), gating_threshold_variance,
-                                                               F16(VOC_ALGORITHM_GATING_THRESHOLD_TRANSITION));
-  sigmoid_gating_variance = voc_algorithm_mean_variance_estimator_sigmoid_process(params, voc_index_from_prior);
-  params->m_Mean_Variance_Estimator_Gamma_Variance = (fix16_mul(sigmoid_gating_variance, gamma_variance));
-  params->m_Mean_Variance_Estimator_Gating_Duration_Minutes =
-      (params->m_Mean_Variance_Estimator_Gating_Duration_Minutes +
-       (fix16_mul(F16((VOC_ALGORITHM_SAMPLING_INTERVAL / 60.)),
-                  ((fix16_mul((F16(1.) - sigmoid_gating_mean), F16((1. + VOC_ALGORITHM_GATING_MAX_RATIO)))) -
-                   F16(VOC_ALGORITHM_GATING_MAX_RATIO)))));
-  if ((params->m_Mean_Variance_Estimator_Gating_Duration_Minutes < F16(0.))) {
-    params->m_Mean_Variance_Estimator_Gating_Duration_Minutes = F16(0.);
-  }
-  if ((params->m_Mean_Variance_Estimator_Gating_Duration_Minutes >
-       params->m_Mean_Variance_Estimator_Gating_Max_Duration_Minutes)) {
-    params->m_Mean_Variance_Estimator_Uptime_Gating = F16(0.);
-  }
-}
-
-static void voc_algorithm_mean_variance_estimator_process(VocAlgorithmParams *params, fix16_t sraw,
-                                                          fix16_t voc_index_from_prior) {
-  fix16_t delta_sgp;
-  fix16_t c;
-  fix16_t additional_scaling;
-
-  if ((!params->m_Mean_Variance_Estimator_Initialized)) {
-    params->m_Mean_Variance_Estimator_Initialized = true;
-    params->m_Mean_Variance_Estimator_Sraw_Offset = sraw;
-    params->m_Mean_Variance_Estimator_Mean = F16(0.);
-  } else {
-    if (((params->m_Mean_Variance_Estimator_Mean >= F16(100.)) ||
-         (params->m_Mean_Variance_Estimator_Mean <= F16(-100.)))) {
-      params->m_Mean_Variance_Estimator_Sraw_Offset =
-          (params->m_Mean_Variance_Estimator_Sraw_Offset + params->m_Mean_Variance_Estimator_Mean);
-      params->m_Mean_Variance_Estimator_Mean = F16(0.);
-    }
-    sraw = (sraw - params->m_Mean_Variance_Estimator_Sraw_Offset);
-    voc_algorithm_mean_variance_estimator_calculate_gamma(params, voc_index_from_prior);
-    delta_sgp = (fix16_div((sraw - params->m_Mean_Variance_Estimator_Mean),
-                           F16(VOC_ALGORITHM_MEAN_VARIANCE_ESTIMATOR_GAMMA_SCALING)));
-    if ((delta_sgp < F16(0.))) {
-      c = (params->m_Mean_Variance_Estimator_Std - delta_sgp);
-    } else {
-      c = (params->m_Mean_Variance_Estimator_Std + delta_sgp);
-    }
-    additional_scaling = F16(1.);
-    if ((c > F16(1440.))) {
-      additional_scaling = F16(4.);
-    }
-    params->m_Mean_Variance_Estimator_Std = (fix16_mul(
-        fix16_sqrt((fix16_mul(additional_scaling, (F16(VOC_ALGORITHM_MEAN_VARIANCE_ESTIMATOR_GAMMA_SCALING) -
-                                                   params->m_Mean_Variance_Estimator_Gamma_Variance)))),
-        fix16_sqrt(((fix16_mul(params->m_Mean_Variance_Estimator_Std,
-                               (fix16_div(params->m_Mean_Variance_Estimator_Std,
-                                          (fix16_mul(F16(VOC_ALGORITHM_MEAN_VARIANCE_ESTIMATOR_GAMMA_SCALING),
-                                                     additional_scaling)))))) +
-                    (fix16_mul((fix16_div((fix16_mul(params->m_Mean_Variance_Estimator_Gamma_Variance, delta_sgp)),
-                                          additional_scaling)),
-                               delta_sgp))))));
-    params->m_Mean_Variance_Estimator_Mean =
-        (params->m_Mean_Variance_Estimator_Mean + (fix16_mul(params->m_Mean_Variance_Estimator_Gamma_Mean, delta_sgp)));
-  }
-}
-
-static void voc_algorithm_mean_variance_estimator_sigmoid_init(VocAlgorithmParams *params) {
-  voc_algorithm_mean_variance_estimator_sigmoid_set_parameters(params, F16(0.), F16(0.), F16(0.));
-}
-
-static void voc_algorithm_mean_variance_estimator_sigmoid_set_parameters(VocAlgorithmParams *params, fix16_t l,
-                                                                         fix16_t x0, fix16_t k) {
-  params->m_Mean_Variance_Estimator_Sigmoid_L = l;
-  params->m_Mean_Variance_Estimator_Sigmoid_K = k;
-  params->m_Mean_Variance_Estimator_Sigmoid_X0 = x0;
-}
-
-static fix16_t voc_algorithm_mean_variance_estimator_sigmoid_process(VocAlgorithmParams *params, fix16_t sample) {
-  fix16_t x;
-
-  x = (fix16_mul(params->m_Mean_Variance_Estimator_Sigmoid_K, (sample - params->m_Mean_Variance_Estimator_Sigmoid_X0)));
-  if ((x < F16(-50.))) {
-    return params->m_Mean_Variance_Estimator_Sigmoid_L;
-  } else if ((x > F16(50.))) {
-    return F16(0.);
-  } else {
-    return (fix16_div(params->m_Mean_Variance_Estimator_Sigmoid_L, (F16(1.) + fix16_exp(x))));
-  }
-}
-
-static void voc_algorithm_mox_model_init(VocAlgorithmParams *params) {
-  voc_algorithm_mox_model_set_parameters(params, F16(1.), F16(0.));
-}
-
-static void voc_algorithm_mox_model_set_parameters(VocAlgorithmParams *params, fix16_t sraw_std, fix16_t sraw_mean) {
-  params->m_Mox_Model_Sraw_Std = sraw_std;
-  params->m_Mox_Model_Sraw_Mean = sraw_mean;
-}
-
-static fix16_t voc_algorithm_mox_model_process(VocAlgorithmParams *params, fix16_t sraw) {
-  return (fix16_mul((fix16_div((sraw - params->m_Mox_Model_Sraw_Mean),
-                               (-(params->m_Mox_Model_Sraw_Std + F16(VOC_ALGORITHM_SRAW_STD_BONUS))))),
-                    F16(VOC_ALGORITHM_VOC_INDEX_GAIN)));
-}
-
-static void voc_algorithm_sigmoid_scaled_init(VocAlgorithmParams *params) {
-  voc_algorithm_sigmoid_scaled_set_parameters(params, F16(0.));
-}
-
-static void voc_algorithm_sigmoid_scaled_set_parameters(VocAlgorithmParams *params, fix16_t offset) {
-  params->m_Sigmoid_Scaled_Offset = offset;
-}
-
-static fix16_t voc_algorithm_sigmoid_scaled_process(VocAlgorithmParams *params, fix16_t sample) {
-  fix16_t x;
-  fix16_t shift;
-
-  x = (fix16_mul(F16(VOC_ALGORITHM_SIGMOID_K), (sample - F16(VOC_ALGORITHM_SIGMOID_X0))));
-  if ((x < F16(-50.))) {
-    return F16(VOC_ALGORITHM_SIGMOID_L);
-  } else if ((x > F16(50.))) {
-    return F16(0.);
-  } else {
-    if ((sample >= F16(0.))) {
-      shift =
-          (fix16_div((F16(VOC_ALGORITHM_SIGMOID_L) - (fix16_mul(F16(5.), params->m_Sigmoid_Scaled_Offset))), F16(4.)));
-      return ((fix16_div((F16(VOC_ALGORITHM_SIGMOID_L) + shift), (F16(1.) + fix16_exp(x)))) - shift);
-    } else {
-      return (fix16_mul((fix16_div(params->m_Sigmoid_Scaled_Offset, F16(VOC_ALGORITHM_VOC_INDEX_OFFSET_DEFAULT))),
-                        (fix16_div(F16(VOC_ALGORITHM_SIGMOID_L), (F16(1.) + fix16_exp(x))))));
-    }
-  }
-}
-
-static void voc_algorithm_adaptive_lowpass_init(VocAlgorithmParams *params) {
-  voc_algorithm_adaptive_lowpass_set_parameters(params);
-}
-
-static void voc_algorithm_adaptive_lowpass_set_parameters(VocAlgorithmParams *params) {
-  params->m_Adaptive_Lowpass_A1 =
-      F16((VOC_ALGORITHM_SAMPLING_INTERVAL / (VOC_ALGORITHM_LP_TAU_FAST + VOC_ALGORITHM_SAMPLING_INTERVAL)));
-  params->m_Adaptive_Lowpass_A2 =
-      F16((VOC_ALGORITHM_SAMPLING_INTERVAL / (VOC_ALGORITHM_LP_TAU_SLOW + VOC_ALGORITHM_SAMPLING_INTERVAL)));
-  params->m_Adaptive_Lowpass_Initialized = false;
-}
-
-static fix16_t voc_algorithm_adaptive_lowpass_process(VocAlgorithmParams *params, fix16_t sample) {
-  fix16_t abs_delta;
-  fix16_t f1;
-  fix16_t tau_a;
-  fix16_t a3;
-
-  if ((!params->m_Adaptive_Lowpass_Initialized)) {
-    params->m_Adaptive_Lowpass_X1 = sample;
-    params->m_Adaptive_Lowpass_X2 = sample;
-    params->m_Adaptive_Lowpass_X3 = sample;
-    params->m_Adaptive_Lowpass_Initialized = true;
-  }
-  params->m_Adaptive_Lowpass_X1 =
-      ((fix16_mul((F16(1.) - params->m_Adaptive_Lowpass_A1), params->m_Adaptive_Lowpass_X1)) +
-       (fix16_mul(params->m_Adaptive_Lowpass_A1, sample)));
-  params->m_Adaptive_Lowpass_X2 =
-      ((fix16_mul((F16(1.) - params->m_Adaptive_Lowpass_A2), params->m_Adaptive_Lowpass_X2)) +
-       (fix16_mul(params->m_Adaptive_Lowpass_A2, sample)));
-  abs_delta = (params->m_Adaptive_Lowpass_X1 - params->m_Adaptive_Lowpass_X2);
-  if ((abs_delta < F16(0.))) {
-    abs_delta = (-abs_delta);
-  }
-  f1 = fix16_exp((fix16_mul(F16(VOC_ALGORITHM_LP_ALPHA), abs_delta)));
-  tau_a =
-      ((fix16_mul(F16((VOC_ALGORITHM_LP_TAU_SLOW - VOC_ALGORITHM_LP_TAU_FAST)), f1)) + F16(VOC_ALGORITHM_LP_TAU_FAST));
-  a3 = (fix16_div(F16(VOC_ALGORITHM_SAMPLING_INTERVAL), (F16(VOC_ALGORITHM_SAMPLING_INTERVAL) + tau_a)));
-  params->m_Adaptive_Lowpass_X3 =
-      ((fix16_mul((F16(1.) - a3), params->m_Adaptive_Lowpass_X3)) + (fix16_mul(a3, sample)));
-  return params->m_Adaptive_Lowpass_X3;
-}
-}  // namespace sgp40
-}  // namespace esphome
diff --git a/esphome/components/sgp40/sensirion_voc_algorithm.h b/esphome/components/sgp40/sensirion_voc_algorithm.h
deleted file mode 100644
index adef6b29e8..0000000000
--- a/esphome/components/sgp40/sensirion_voc_algorithm.h
+++ /dev/null
@@ -1,147 +0,0 @@
-#pragma once
-#include <cstdint>
-namespace esphome {
-namespace sgp40 {
-
-/* The VOC code were originally created by
- *  https://github.com/Sensirion/embedded-sgp
- * The fixed point arithmetic parts of this code were originally created by
- * https://github.com/PetteriAimonen/libfixmath
- */
-
-using fix16_t = int32_t;
-
-#define F16(x) ((fix16_t)(((x) >= 0) ? ((x) *65536.0 + 0.5) : ((x) *65536.0 - 0.5)))
-
-static const float VOC_ALGORITHM_SAMPLING_INTERVAL(1.);
-static const float VOC_ALGORITHM_INITIAL_BLACKOUT(45.);
-static const float VOC_ALGORITHM_VOC_INDEX_GAIN(230.);
-static const float VOC_ALGORITHM_SRAW_STD_INITIAL(50.);
-static const float VOC_ALGORITHM_SRAW_STD_BONUS(220.);
-static const float VOC_ALGORITHM_TAU_MEAN_VARIANCE_HOURS(12.);
-static const float VOC_ALGORITHM_TAU_INITIAL_MEAN(20.);
-static const float VOC_ALGORITHM_INIT_DURATION_MEAN((3600. * 0.75));
-static const float VOC_ALGORITHM_INIT_TRANSITION_MEAN(0.01);
-static const float VOC_ALGORITHM_TAU_INITIAL_VARIANCE(2500.);
-static const float VOC_ALGORITHM_INIT_DURATION_VARIANCE((3600. * 1.45));
-static const float VOC_ALGORITHM_INIT_TRANSITION_VARIANCE(0.01);
-static const float VOC_ALGORITHM_GATING_THRESHOLD(340.);
-static const float VOC_ALGORITHM_GATING_THRESHOLD_INITIAL(510.);
-static const float VOC_ALGORITHM_GATING_THRESHOLD_TRANSITION(0.09);
-static const float VOC_ALGORITHM_GATING_MAX_DURATION_MINUTES((60. * 3.));
-static const float VOC_ALGORITHM_GATING_MAX_RATIO(0.3);
-static const float VOC_ALGORITHM_SIGMOID_L(500.);
-static const float VOC_ALGORITHM_SIGMOID_K(-0.0065);
-static const float VOC_ALGORITHM_SIGMOID_X0(213.);
-static const float VOC_ALGORITHM_VOC_INDEX_OFFSET_DEFAULT(100.);
-static const float VOC_ALGORITHM_LP_TAU_FAST(20.0);
-static const float VOC_ALGORITHM_LP_TAU_SLOW(500.0);
-static const float VOC_ALGORITHM_LP_ALPHA(-0.2);
-static const float VOC_ALGORITHM_PERSISTENCE_UPTIME_GAMMA((3. * 3600.));
-static const float VOC_ALGORITHM_MEAN_VARIANCE_ESTIMATOR_GAMMA_SCALING(64.);
-static const float VOC_ALGORITHM_MEAN_VARIANCE_ESTIMATOR_FI_X16_MAX(32767.);
-
-/**
- * Struct to hold all the states of the VOC algorithm.
- */
-struct VocAlgorithmParams {
-  fix16_t mVoc_Index_Offset;
-  fix16_t mTau_Mean_Variance_Hours;
-  fix16_t mGating_Max_Duration_Minutes;
-  fix16_t mSraw_Std_Initial;
-  fix16_t mUptime;
-  fix16_t mSraw;
-  fix16_t mVoc_Index;
-  fix16_t m_Mean_Variance_Estimator_Gating_Max_Duration_Minutes;
-  bool m_Mean_Variance_Estimator_Initialized;
-  fix16_t m_Mean_Variance_Estimator_Mean;
-  fix16_t m_Mean_Variance_Estimator_Sraw_Offset;
-  fix16_t m_Mean_Variance_Estimator_Std;
-  fix16_t m_Mean_Variance_Estimator_Gamma;
-  fix16_t m_Mean_Variance_Estimator_Gamma_Initial_Mean;
-  fix16_t m_Mean_Variance_Estimator_Gamma_Initial_Variance;
-  fix16_t m_Mean_Variance_Estimator_Gamma_Mean;
-  fix16_t m_Mean_Variance_Estimator_Gamma_Variance;
-  fix16_t m_Mean_Variance_Estimator_Uptime_Gamma;
-  fix16_t m_Mean_Variance_Estimator_Uptime_Gating;
-  fix16_t m_Mean_Variance_Estimator_Gating_Duration_Minutes;
-  fix16_t m_Mean_Variance_Estimator_Sigmoid_L;
-  fix16_t m_Mean_Variance_Estimator_Sigmoid_K;
-  fix16_t m_Mean_Variance_Estimator_Sigmoid_X0;
-  fix16_t m_Mox_Model_Sraw_Std;
-  fix16_t m_Mox_Model_Sraw_Mean;
-  fix16_t m_Sigmoid_Scaled_Offset;
-  fix16_t m_Adaptive_Lowpass_A1;
-  fix16_t m_Adaptive_Lowpass_A2;
-  bool m_Adaptive_Lowpass_Initialized;
-  fix16_t m_Adaptive_Lowpass_X1;
-  fix16_t m_Adaptive_Lowpass_X2;
-  fix16_t m_Adaptive_Lowpass_X3;
-};
-
-/**
- * Initialize the VOC algorithm parameters. Call this once at the beginning or
- * whenever the sensor stopped measurements.
- * @param params    Pointer to the VocAlgorithmParams struct
- */
-void voc_algorithm_init(VocAlgorithmParams *params);
-
-/**
- * Get current algorithm states. Retrieved values can be used in
- * voc_algorithm_set_states() to resume operation after a short interruption,
- * skipping initial learning phase. This feature can only be used after at least
- * 3 hours of continuous operation.
- * @param params    Pointer to the VocAlgorithmParams struct
- * @param state0    State0 to be stored
- * @param state1    State1 to be stored
- */
-void voc_algorithm_get_states(VocAlgorithmParams *params, int32_t *state0, int32_t *state1);
-
-/**
- * Set previously retrieved algorithm states to resume operation after a short
- * interruption, skipping initial learning phase. This feature should not be
- * used after inerruptions of more than 10 minutes. Call this once after
- * voc_algorithm_init() and the optional voc_algorithm_set_tuning_parameters(), if
- * desired. Otherwise, the algorithm will start with initial learning phase.
- * @param params    Pointer to the VocAlgorithmParams struct
- * @param state0    State0 to be restored
- * @param state1    State1 to be restored
- */
-void voc_algorithm_set_states(VocAlgorithmParams *params, int32_t state0, int32_t state1);
-
-/**
- * Set parameters to customize the VOC algorithm. Call this once after
- * voc_algorithm_init(), if desired. Otherwise, the default values will be used.
- *
- * @param params                      Pointer to the VocAlgorithmParams struct
- * @param voc_index_offset            VOC index representing typical (average)
- *                                    conditions. Range 1..250, default 100
- * @param learning_time_hours         Time constant of long-term estimator.
- *                                    Past events will be forgotten after about
- *                                    twice the learning time.
- *                                    Range 1..72 [hours], default 12 [hours]
- * @param gating_max_duration_minutes Maximum duration of gating (freeze of
- *                                    estimator during high VOC index signal).
- *                                    0 (no gating) or range 1..720 [minutes],
- *                                    default 180 [minutes]
- * @param std_initial                 Initial estimate for standard deviation.
- *                                    Lower value boosts events during initial
- *                                    learning period, but may result in larger
- *                                    device-to-device variations.
- *                                    Range 10..500, default 50
- */
-void voc_algorithm_set_tuning_parameters(VocAlgorithmParams *params, int32_t voc_index_offset,
-                                         int32_t learning_time_hours, int32_t gating_max_duration_minutes,
-                                         int32_t std_initial);
-
-/**
- * Calculate the VOC index value from the raw sensor value.
- *
- * @param params    Pointer to the VocAlgorithmParams struct
- * @param sraw      Raw value from the SGP40 sensor
- * @param voc_index Calculated VOC index value from the raw sensor value. Zero
- *                  during initial blackout period and 1..500 afterwards
- */
-void voc_algorithm_process(VocAlgorithmParams *params, int32_t sraw, int32_t *voc_index);
-}  // namespace sgp40
-}  // namespace esphome
diff --git a/esphome/components/sgp40/sensor.py b/esphome/components/sgp40/sensor.py
index ee267d6062..cb4231c168 100644
--- a/esphome/components/sgp40/sensor.py
+++ b/esphome/components/sgp40/sensor.py
@@ -1,70 +1,8 @@
-import esphome.codegen as cg
 import esphome.config_validation as cv
-from esphome.components import i2c, sensor, sensirion_common
-
-from esphome.const import (
-    CONF_STORE_BASELINE,
-    CONF_TEMPERATURE_SOURCE,
-    ICON_RADIATOR,
-    DEVICE_CLASS_VOLATILE_ORGANIC_COMPOUNDS,
-    STATE_CLASS_MEASUREMENT,
-)
-
-DEPENDENCIES = ["i2c"]
-AUTO_LOAD = ["sensirion_common"]
 
 CODEOWNERS = ["@SenexCrenshaw"]
 
-sgp40_ns = cg.esphome_ns.namespace("sgp40")
-SGP40Component = sgp40_ns.class_(
-    "SGP40Component",
-    sensor.Sensor,
-    cg.PollingComponent,
-    sensirion_common.SensirionI2CDevice,
+CONFIG_SCHEMA = CONFIG_SCHEMA = cv.invalid(
+    "SGP40 is deprecated.\nPlease use the SGP4x platform instead.\nSGP4x supports both SPG40 and SGP41.\n"
+    " See https://esphome.io/components/sensor/sgp4x.html"
 )
-
-CONF_COMPENSATION = "compensation"
-CONF_HUMIDITY_SOURCE = "humidity_source"
-CONF_VOC_BASELINE = "voc_baseline"
-
-CONFIG_SCHEMA = (
-    sensor.sensor_schema(
-        SGP40Component,
-        icon=ICON_RADIATOR,
-        accuracy_decimals=0,
-        device_class=DEVICE_CLASS_VOLATILE_ORGANIC_COMPOUNDS,
-        state_class=STATE_CLASS_MEASUREMENT,
-    )
-    .extend(
-        {
-            cv.Optional(CONF_STORE_BASELINE, default=True): cv.boolean,
-            cv.Optional(CONF_VOC_BASELINE): cv.hex_uint16_t,
-            cv.Optional(CONF_COMPENSATION): cv.Schema(
-                {
-                    cv.Required(CONF_HUMIDITY_SOURCE): cv.use_id(sensor.Sensor),
-                    cv.Required(CONF_TEMPERATURE_SOURCE): cv.use_id(sensor.Sensor),
-                },
-            ),
-        }
-    )
-    .extend(cv.polling_component_schema("60s"))
-    .extend(i2c.i2c_device_schema(0x59))
-)
-
-
-async def to_code(config):
-    var = await sensor.new_sensor(config)
-    await cg.register_component(var, config)
-    await i2c.register_i2c_device(var, config)
-
-    if CONF_COMPENSATION in config:
-        compensation_config = config[CONF_COMPENSATION]
-        sens = await cg.get_variable(compensation_config[CONF_HUMIDITY_SOURCE])
-        cg.add(var.set_humidity_sensor(sens))
-        sens = await cg.get_variable(compensation_config[CONF_TEMPERATURE_SOURCE])
-        cg.add(var.set_temperature_sensor(sens))
-
-    cg.add(var.set_store_baseline(config[CONF_STORE_BASELINE]))
-
-    if CONF_VOC_BASELINE in config:
-        cg.add(var.set_voc_baseline(CONF_VOC_BASELINE))
diff --git a/esphome/components/sgp40/sgp40.cpp b/esphome/components/sgp40/sgp40.cpp
deleted file mode 100644
index 9d78572b50..0000000000
--- a/esphome/components/sgp40/sgp40.cpp
+++ /dev/null
@@ -1,274 +0,0 @@
-#include "sgp40.h"
-#include "esphome/core/log.h"
-#include "esphome/core/hal.h"
-#include <cinttypes>
-
-namespace esphome {
-namespace sgp40 {
-
-static const char *const TAG = "sgp40";
-
-void SGP40Component::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up SGP40...");
-
-  // Serial Number identification
-  if (!this->write_command(SGP40_CMD_GET_SERIAL_ID)) {
-    this->error_code_ = COMMUNICATION_FAILED;
-    this->mark_failed();
-    return;
-  }
-  uint16_t raw_serial_number[3];
-
-  if (!this->read_data(raw_serial_number, 3)) {
-    this->mark_failed();
-    return;
-  }
-  this->serial_number_ = (uint64_t(raw_serial_number[0]) << 24) | (uint64_t(raw_serial_number[1]) << 16) |
-                         (uint64_t(raw_serial_number[2]));
-  ESP_LOGD(TAG, "Serial Number: %" PRIu64, this->serial_number_);
-
-  // Featureset identification for future use
-  if (!this->write_command(SGP40_CMD_GET_FEATURESET)) {
-    ESP_LOGD(TAG, "raw_featureset write_command_ failed");
-    this->mark_failed();
-    return;
-  }
-  uint16_t raw_featureset;
-  if (!this->read_data(raw_featureset)) {
-    ESP_LOGD(TAG, "raw_featureset read_data_ failed");
-    this->mark_failed();
-    return;
-  }
-
-  this->featureset_ = raw_featureset;
-  if ((this->featureset_ & 0x1FF) != SGP40_FEATURESET) {
-    ESP_LOGD(TAG, "Product feature set failed 0x%0X , expecting 0x%0X", uint16_t(this->featureset_ & 0x1FF),
-             SGP40_FEATURESET);
-    this->mark_failed();
-    return;
-  }
-
-  ESP_LOGD(TAG, "Product version: 0x%0X", uint16_t(this->featureset_ & 0x1FF));
-
-  voc_algorithm_init(&this->voc_algorithm_params_);
-
-  if (this->store_baseline_) {
-    // Hash with compilation time
-    // This ensures the baseline storage is cleared after OTA
-    uint32_t hash = fnv1_hash(App.get_compilation_time());
-    this->pref_ = global_preferences->make_preference<SGP40Baselines>(hash, true);
-
-    if (this->pref_.load(&this->baselines_storage_)) {
-      this->state0_ = this->baselines_storage_.state0;
-      this->state1_ = this->baselines_storage_.state1;
-      ESP_LOGI(TAG, "Loaded VOC baseline state0: 0x%04X, state1: 0x%04X", this->baselines_storage_.state0,
-               baselines_storage_.state1);
-    }
-
-    // Initialize storage timestamp
-    this->seconds_since_last_store_ = 0;
-
-    if (this->baselines_storage_.state0 > 0 && this->baselines_storage_.state1 > 0) {
-      ESP_LOGI(TAG, "Setting VOC baseline from save state0: 0x%04X, state1: 0x%04X", this->baselines_storage_.state0,
-               baselines_storage_.state1);
-      voc_algorithm_set_states(&this->voc_algorithm_params_, this->baselines_storage_.state0,
-                               this->baselines_storage_.state1);
-    }
-  }
-
-  this->self_test_();
-
-  /* The official spec for this sensor at https://docs.rs-online.com/1956/A700000007055193.pdf
-  indicates this sensor should be driven at 1Hz. Comments from the developers at:
-  https://github.com/Sensirion/embedded-sgp/issues/136 indicate the algorithm should be a bit
-  resilient to slight timing variations so the software timer should be accurate enough for
-  this.
-
-  This block starts sampling from the sensor at 1Hz, and is done seperately from the call
-  to the update method. This seperation is to support getting accurate measurements but
-  limit the amount of communication done over wifi for power consumption or to keep the
-  number of records reported from being overwhelming.
-  */
-  ESP_LOGD(TAG, "Component requires sampling of 1Hz, setting up background sampler");
-  this->set_interval(1000, [this]() { this->update_voc_index(); });
-}
-
-void SGP40Component::self_test_() {
-  ESP_LOGD(TAG, "Self-test started");
-  if (!this->write_command(SGP40_CMD_SELF_TEST)) {
-    this->error_code_ = COMMUNICATION_FAILED;
-    ESP_LOGD(TAG, "Self-test communication failed");
-    this->mark_failed();
-  }
-
-  this->set_timeout(250, [this]() {
-    uint16_t reply;
-    if (!this->read_data(reply)) {
-      ESP_LOGD(TAG, "Self-test read_data_ failed");
-      this->mark_failed();
-      return;
-    }
-
-    if (reply == 0xD400) {
-      this->self_test_complete_ = true;
-      ESP_LOGD(TAG, "Self-test completed");
-      return;
-    }
-
-    ESP_LOGD(TAG, "Self-test failed");
-    this->mark_failed();
-  });
-}
-
-/**
- * @brief Combined the measured gasses, temperature, and humidity
- * to calculate the VOC Index
- *
- * @param temperature The measured temperature in degrees C
- * @param humidity The measured relative humidity in % rH
- * @return int32_t The VOC Index
- */
-int32_t SGP40Component::measure_voc_index_() {
-  int32_t voc_index;
-
-  uint16_t sraw = measure_raw_();
-
-  if (sraw == UINT16_MAX)
-    return UINT16_MAX;
-
-  this->status_clear_warning();
-
-  voc_algorithm_process(&voc_algorithm_params_, sraw, &voc_index);
-
-  // Store baselines after defined interval or if the difference between current and stored baseline becomes too
-  // much
-  if (this->store_baseline_ && this->seconds_since_last_store_ > SHORTEST_BASELINE_STORE_INTERVAL) {
-    voc_algorithm_get_states(&voc_algorithm_params_, &this->state0_, &this->state1_);
-    if ((uint32_t) abs(this->baselines_storage_.state0 - this->state0_) > MAXIMUM_STORAGE_DIFF ||
-        (uint32_t) abs(this->baselines_storage_.state1 - this->state1_) > MAXIMUM_STORAGE_DIFF) {
-      this->seconds_since_last_store_ = 0;
-      this->baselines_storage_.state0 = this->state0_;
-      this->baselines_storage_.state1 = this->state1_;
-
-      if (this->pref_.save(&this->baselines_storage_)) {
-        ESP_LOGI(TAG, "Stored VOC baseline state0: 0x%04X ,state1: 0x%04X", this->baselines_storage_.state0,
-                 baselines_storage_.state1);
-      } else {
-        ESP_LOGW(TAG, "Could not store VOC baselines");
-      }
-    }
-  }
-
-  return voc_index;
-}
-
-/**
- * @brief Return the raw gas measurement
- *
- * @param temperature The measured temperature in degrees C
- * @param humidity The measured relative humidity in % rH
- * @return uint16_t The current raw gas measurement
- */
-uint16_t SGP40Component::measure_raw_() {
-  float humidity = NAN;
-
-  if (!this->self_test_complete_) {
-    ESP_LOGD(TAG, "Self-test not yet complete");
-    return UINT16_MAX;
-  }
-
-  if (this->humidity_sensor_ != nullptr) {
-    humidity = this->humidity_sensor_->state;
-  }
-  if (std::isnan(humidity) || humidity < 0.0f || humidity > 100.0f) {
-    humidity = 50;
-  }
-
-  float temperature = NAN;
-  if (this->temperature_sensor_ != nullptr) {
-    temperature = float(this->temperature_sensor_->state);
-  }
-  if (std::isnan(temperature) || temperature < -40.0f || temperature > 85.0f) {
-    temperature = 25;
-  }
-
-  uint16_t data[2];
-  uint16_t rhticks = llround((uint16_t)((humidity * 65535) / 100));
-  uint16_t tempticks = (uint16_t)(((temperature + 45) * 65535) / 175);
-  // first paramater is the relative humidity ticks
-  data[0] = rhticks;
-  // second paramater is the temperature ticks
-  data[1] = tempticks;
-
-  if (!this->write_command(SGP40_CMD_MEASURE_RAW, data, 2)) {
-    this->status_set_warning();
-    ESP_LOGD(TAG, "write error (%d)", this->last_error_);
-    return false;
-  }
-  delay(30);
-
-  uint16_t raw_data;
-  if (!this->read_data(raw_data)) {
-    this->status_set_warning();
-    ESP_LOGD(TAG, "read_data_ error");
-    return UINT16_MAX;
-  }
-  return raw_data;
-}
-
-void SGP40Component::update_voc_index() {
-  this->seconds_since_last_store_ += 1;
-
-  this->voc_index_ = this->measure_voc_index_();
-  if (this->samples_read_ < this->samples_to_stabalize_) {
-    this->samples_read_++;
-    ESP_LOGD(TAG, "Sensor has not collected enough samples yet. (%d/%d) VOC index is: %u", this->samples_read_,
-             this->samples_to_stabalize_, this->voc_index_);
-    return;
-  }
-}
-
-void SGP40Component::update() {
-  if (this->samples_read_ < this->samples_to_stabalize_) {
-    return;
-  }
-
-  if (this->voc_index_ != UINT16_MAX) {
-    this->status_clear_warning();
-    this->publish_state(this->voc_index_);
-  } else {
-    this->status_set_warning();
-  }
-}
-
-void SGP40Component::dump_config() {
-  ESP_LOGCONFIG(TAG, "SGP40:");
-  LOG_I2C_DEVICE(this);
-  ESP_LOGCONFIG(TAG, "  store_baseline: %d", this->store_baseline_);
-
-  if (this->is_failed()) {
-    switch (this->error_code_) {
-      case COMMUNICATION_FAILED:
-        ESP_LOGW(TAG, "Communication failed! Is the sensor connected?");
-        break;
-      default:
-        ESP_LOGW(TAG, "Unknown setup error!");
-        break;
-    }
-  } else {
-    ESP_LOGCONFIG(TAG, "  Serial number: %" PRIu64, this->serial_number_);
-    ESP_LOGCONFIG(TAG, "  Minimum Samples: %f", VOC_ALGORITHM_INITIAL_BLACKOUT);
-  }
-  LOG_UPDATE_INTERVAL(this);
-
-  if (this->humidity_sensor_ != nullptr && this->temperature_sensor_ != nullptr) {
-    ESP_LOGCONFIG(TAG, "  Compensation:");
-    LOG_SENSOR("    ", "Temperature Source:", this->temperature_sensor_);
-    LOG_SENSOR("    ", "Humidity Source:", this->humidity_sensor_);
-  } else {
-    ESP_LOGCONFIG(TAG, "  Compensation: No source configured");
-  }
-}
-
-}  // namespace sgp40
-}  // namespace esphome
diff --git a/esphome/components/sgp40/sgp40.h b/esphome/components/sgp40/sgp40.h
deleted file mode 100644
index c5b7d2dfa0..0000000000
--- a/esphome/components/sgp40/sgp40.h
+++ /dev/null
@@ -1,93 +0,0 @@
-#pragma once
-
-#include "esphome/core/component.h"
-#include "esphome/components/sensor/sensor.h"
-#include "esphome/components/sensirion_common/i2c_sensirion.h"
-#include "esphome/core/application.h"
-#include "esphome/core/preferences.h"
-#include "sensirion_voc_algorithm.h"
-
-#include <cmath>
-
-namespace esphome {
-namespace sgp40 {
-
-struct SGP40Baselines {
-  int32_t state0;
-  int32_t state1;
-} PACKED;  // NOLINT
-
-// commands and constants
-static const uint8_t SGP40_FEATURESET = 0x0020;     ///< The required set for this library
-static const uint8_t SGP40_CRC8_POLYNOMIAL = 0x31;  ///< Seed for SGP40's CRC polynomial
-static const uint8_t SGP40_CRC8_INIT = 0xFF;        ///< Init value for CRC
-static const uint8_t SGP40_WORD_LEN = 2;            ///< 2 bytes per word
-
-// Commands
-
-static const uint16_t SGP40_CMD_GET_SERIAL_ID = 0x3682;
-static const uint16_t SGP40_CMD_GET_FEATURESET = 0x202f;
-static const uint16_t SGP40_CMD_SELF_TEST = 0x280e;
-static const uint16_t SGP40_CMD_MEASURE_RAW = 0x260F;
-
-// Shortest time interval of 3H for storing baseline values.
-// Prevents wear of the flash because of too many write operations
-const uint32_t SHORTEST_BASELINE_STORE_INTERVAL = 10800;
-
-// Store anyway if the baseline difference exceeds the max storage diff value
-const uint32_t MAXIMUM_STORAGE_DIFF = 50;
-
-class SGP40Component;
-
-/// This class implements support for the Sensirion sgp40 i2c GAS (VOC) sensors.
-class SGP40Component : public PollingComponent, public sensor::Sensor, public sensirion_common::SensirionI2CDevice {
- public:
-  void set_humidity_sensor(sensor::Sensor *humidity) { humidity_sensor_ = humidity; }
-  void set_temperature_sensor(sensor::Sensor *temperature) { temperature_sensor_ = temperature; }
-
-  void setup() override;
-  void update() override;
-  void update_voc_index();
-  void dump_config() override;
-  float get_setup_priority() const override { return setup_priority::DATA; }
-  void set_store_baseline(bool store_baseline) { store_baseline_ = store_baseline; }
-
- protected:
-  /// Input sensor for humidity and temperature compensation.
-  sensor::Sensor *humidity_sensor_{nullptr};
-  sensor::Sensor *temperature_sensor_{nullptr};
-  int16_t sensirion_init_sensors_();
-  int16_t sgp40_probe_();
-  uint64_t serial_number_;
-  uint16_t featureset_;
-  int32_t measure_voc_index_();
-  uint8_t generate_crc_(const uint8_t *data, uint8_t datalen);
-  uint16_t measure_raw_();
-  ESPPreferenceObject pref_;
-  uint32_t seconds_since_last_store_;
-  SGP40Baselines baselines_storage_;
-  VocAlgorithmParams voc_algorithm_params_;
-  bool self_test_complete_;
-  bool store_baseline_;
-  int32_t state0_;
-  int32_t state1_;
-  int32_t voc_index_ = 0;
-  uint8_t samples_read_ = 0;
-  uint8_t samples_to_stabalize_ = static_cast<int8_t>(VOC_ALGORITHM_INITIAL_BLACKOUT) * 2;
-
-  /**
-   * @brief Request the sensor to perform a self-test, returning the result
-   *
-   * @return true: success false:failure
-   */
-  void self_test_();
-  enum ErrorCode {
-    COMMUNICATION_FAILED,
-    MEASUREMENT_INIT_FAILED,
-    INVALID_ID,
-    UNSUPPORTED_ID,
-    UNKNOWN
-  } error_code_{UNKNOWN};
-};
-}  // namespace sgp40
-}  // namespace esphome
diff --git a/esphome/components/sgp4x/__init__.py b/esphome/components/sgp4x/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/esphome/components/sgp4x/sensor.py b/esphome/components/sgp4x/sensor.py
new file mode 100644
index 0000000000..4855d7f066
--- /dev/null
+++ b/esphome/components/sgp4x/sensor.py
@@ -0,0 +1,144 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import i2c, sensor, sensirion_common
+from esphome.const import (
+    CONF_ID,
+    CONF_STORE_BASELINE,
+    CONF_TEMPERATURE_SOURCE,
+    ICON_RADIATOR,
+    DEVICE_CLASS_NITROUS_OXIDE,
+    DEVICE_CLASS_VOLATILE_ORGANIC_COMPOUNDS,
+    STATE_CLASS_MEASUREMENT,
+)
+
+DEPENDENCIES = ["i2c"]
+AUTO_LOAD = ["sensirion_common"]
+CODEOWNERS = ["@SenexCrenshaw", "@martgras"]
+
+sgp4x_ns = cg.esphome_ns.namespace("sgp4x")
+SGP4xComponent = sgp4x_ns.class_(
+    "SGP4xComponent",
+    sensor.Sensor,
+    cg.PollingComponent,
+    sensirion_common.SensirionI2CDevice,
+)
+
+CONF_ALGORITHM_TUNING = "algorithm_tuning"
+CONF_COMPENSATION = "compensation"
+CONF_GAIN_FACTOR = "gain_factor"
+CONF_GATING_MAX_DURATION_MINUTES = "gating_max_duration_minutes"
+CONF_HUMIDITY_SOURCE = "humidity_source"
+CONF_INDEX_OFFSET = "index_offset"
+CONF_LEARNING_TIME_GAIN_HOURS = "learning_time_gain_hours"
+CONF_LEARNING_TIME_OFFSET_HOURS = "learning_time_offset_hours"
+CONF_NOX = "nox"
+CONF_STD_INITIAL = "std_initial"
+CONF_VOC = "voc"
+CONF_VOC_BASELINE = "voc_baseline"
+
+
+def validate_sensors(config):
+    if CONF_VOC not in config and CONF_NOX not in config:
+        raise cv.Invalid(
+            f"At least one sensor is required. Define {CONF_VOC} and/or {CONF_NOX}"
+        )
+    return config
+
+
+GAS_SENSOR = cv.Schema(
+    {
+        cv.Optional(CONF_ALGORITHM_TUNING): cv.Schema(
+            {
+                cv.Optional(CONF_INDEX_OFFSET, default=100): cv.int_,
+                cv.Optional(CONF_LEARNING_TIME_OFFSET_HOURS, default=12): cv.int_,
+                cv.Optional(CONF_LEARNING_TIME_GAIN_HOURS, default=12): cv.int_,
+                cv.Optional(CONF_GATING_MAX_DURATION_MINUTES, default=720): cv.int_,
+                cv.Optional(CONF_STD_INITIAL, default=50): cv.int_,
+                cv.Optional(CONF_GAIN_FACTOR, default=230): cv.int_,
+            }
+        )
+    }
+)
+
+CONFIG_SCHEMA = cv.All(
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(SGP4xComponent),
+            cv.Optional(CONF_VOC): sensor.sensor_schema(
+                icon=ICON_RADIATOR,
+                accuracy_decimals=0,
+                device_class=DEVICE_CLASS_VOLATILE_ORGANIC_COMPOUNDS,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ).extend(GAS_SENSOR),
+            cv.Optional(CONF_NOX): sensor.sensor_schema(
+                icon=ICON_RADIATOR,
+                accuracy_decimals=0,
+                device_class=DEVICE_CLASS_NITROUS_OXIDE,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ).extend(GAS_SENSOR),
+            cv.Optional(CONF_STORE_BASELINE, default=True): cv.boolean,
+            cv.Optional(CONF_VOC_BASELINE): cv.hex_uint16_t,
+            cv.Optional(CONF_COMPENSATION): cv.Schema(
+                {
+                    cv.Required(CONF_HUMIDITY_SOURCE): cv.use_id(sensor.Sensor),
+                    cv.Required(CONF_TEMPERATURE_SOURCE): cv.use_id(sensor.Sensor),
+                },
+            ),
+        }
+    )
+    .extend(cv.polling_component_schema("60s"))
+    .extend(i2c.i2c_device_schema(0x59)),
+    validate_sensors,
+)
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+    await i2c.register_i2c_device(var, config)
+
+    if CONF_COMPENSATION in config:
+        compensation_config = config[CONF_COMPENSATION]
+        sens = await cg.get_variable(compensation_config[CONF_HUMIDITY_SOURCE])
+        cg.add(var.set_humidity_sensor(sens))
+        sens = await cg.get_variable(compensation_config[CONF_TEMPERATURE_SOURCE])
+        cg.add(var.set_temperature_sensor(sens))
+
+    cg.add(var.set_store_baseline(config[CONF_STORE_BASELINE]))
+
+    if CONF_VOC_BASELINE in config:
+        cg.add(var.set_voc_baseline(CONF_VOC_BASELINE))
+
+    if CONF_VOC in config:
+        sens = await sensor.new_sensor(config[CONF_VOC])
+        cg.add(var.set_voc_sensor(sens))
+        if CONF_ALGORITHM_TUNING in config[CONF_VOC]:
+            cfg = config[CONF_VOC][CONF_ALGORITHM_TUNING]
+            cg.add(
+                var.set_voc_algorithm_tuning(
+                    cfg[CONF_INDEX_OFFSET],
+                    cfg[CONF_LEARNING_TIME_OFFSET_HOURS],
+                    cfg[CONF_LEARNING_TIME_GAIN_HOURS],
+                    cfg[CONF_GATING_MAX_DURATION_MINUTES],
+                    cfg[CONF_STD_INITIAL],
+                    cfg[CONF_GAIN_FACTOR],
+                )
+            )
+
+    if CONF_NOX in config:
+        sens = await sensor.new_sensor(config[CONF_NOX])
+        cg.add(var.set_nox_sensor(sens))
+        if CONF_ALGORITHM_TUNING in config[CONF_NOX]:
+            cfg = config[CONF_NOX][CONF_ALGORITHM_TUNING]
+            cg.add(
+                var.set_nox_algorithm_tuning(
+                    cfg[CONF_INDEX_OFFSET],
+                    cfg[CONF_LEARNING_TIME_OFFSET_HOURS],
+                    cfg[CONF_LEARNING_TIME_GAIN_HOURS],
+                    cfg[CONF_GATING_MAX_DURATION_MINUTES],
+                    cfg[CONF_GAIN_FACTOR],
+                )
+            )
+    cg.add_library(
+        None, None, "https://github.com/Sensirion/arduino-gas-index-algorithm.git"
+    )
diff --git a/esphome/components/sgp4x/sgp4x.cpp b/esphome/components/sgp4x/sgp4x.cpp
new file mode 100644
index 0000000000..a6f57e0342
--- /dev/null
+++ b/esphome/components/sgp4x/sgp4x.cpp
@@ -0,0 +1,343 @@
+#include "sgp4x.h"
+#include "esphome/core/log.h"
+#include "esphome/core/hal.h"
+#include <cinttypes>
+
+namespace esphome {
+namespace sgp4x {
+
+static const char *const TAG = "sgp4x";
+
+void SGP4xComponent::setup() {
+  ESP_LOGCONFIG(TAG, "Setting up SGP4x...");
+
+  // Serial Number identification
+  uint16_t raw_serial_number[3];
+  if (!this->get_register(SGP4X_CMD_GET_SERIAL_ID, raw_serial_number, 3, 1)) {
+    ESP_LOGE(TAG, "Failed to read serial number");
+    this->error_code_ = SERIAL_NUMBER_IDENTIFICATION_FAILED;
+    this->mark_failed();
+    return;
+  }
+  this->serial_number_ = (uint64_t(raw_serial_number[0]) << 24) | (uint64_t(raw_serial_number[1]) << 16) |
+                         (uint64_t(raw_serial_number[2]));
+  ESP_LOGD(TAG, "Serial Number: %" PRIu64, this->serial_number_);
+
+  // Featureset identification for future use
+  uint16_t raw_featureset;
+  if (!this->get_register(SGP4X_CMD_GET_FEATURESET, raw_featureset, 1)) {
+    ESP_LOGD(TAG, "raw_featureset write_command_ failed");
+    this->mark_failed();
+    return;
+  }
+  this->featureset_ = raw_featureset;
+  if ((this->featureset_ & 0x1FF) == SGP40_FEATURESET) {
+    sgp_type_ = SGP40;
+    self_test_time_ = SPG40_SELFTEST_TIME;
+    measure_time_ = SGP40_MEASURE_TIME;
+    if (this->nox_sensor_) {
+      ESP_LOGE(TAG, "Measuring NOx requires a SGP41 sensor but a SGP40 sensor is detected");
+      // disable the sensor
+      this->nox_sensor_->set_disabled_by_default(true);
+      // make sure it's not visiable in HA
+      this->nox_sensor_->set_internal(true);
+      this->nox_sensor_->state = NAN;
+      // remove pointer to sensor
+      this->nox_sensor_ = nullptr;
+    }
+  } else {
+    if ((this->featureset_ & 0x1FF) == SGP41_FEATURESET) {
+      sgp_type_ = SGP41;
+      self_test_time_ = SPG41_SELFTEST_TIME;
+      measure_time_ = SGP41_MEASURE_TIME;
+    } else {
+      ESP_LOGD(TAG, "Product feature set failed 0x%0X , expecting 0x%0X", uint16_t(this->featureset_ & 0x1FF),
+               SGP40_FEATURESET);
+      this->mark_failed();
+      return;
+    }
+  }
+
+  ESP_LOGD(TAG, "Product version: 0x%0X", uint16_t(this->featureset_ & 0x1FF));
+
+  if (this->store_baseline_) {
+    // Hash with compilation time
+    // This ensures the baseline storage is cleared after OTA
+    uint32_t hash = fnv1_hash(App.get_compilation_time());
+    this->pref_ = global_preferences->make_preference<SGP4xBaselines>(hash, true);
+
+    if (this->pref_.load(&this->voc_baselines_storage_)) {
+      this->voc_state0_ = this->voc_baselines_storage_.state0;
+      this->voc_state1_ = this->voc_baselines_storage_.state1;
+      ESP_LOGI(TAG, "Loaded VOC baseline state0: 0x%04X, state1: 0x%04X", this->voc_baselines_storage_.state0,
+               voc_baselines_storage_.state1);
+    }
+
+    // Initialize storage timestamp
+    this->seconds_since_last_store_ = 0;
+
+    if (this->voc_baselines_storage_.state0 > 0 && this->voc_baselines_storage_.state1 > 0) {
+      ESP_LOGI(TAG, "Setting VOC baseline from save state0: 0x%04X, state1: 0x%04X",
+               this->voc_baselines_storage_.state0, voc_baselines_storage_.state1);
+      voc_algorithm_.set_states(this->voc_baselines_storage_.state0, this->voc_baselines_storage_.state1);
+    }
+  }
+  if (this->voc_sensor_ && this->voc_tuning_params_.has_value()) {
+    voc_algorithm_.set_tuning_parameters(
+        voc_tuning_params_.value().index_offset, voc_tuning_params_.value().learning_time_offset_hours,
+        voc_tuning_params_.value().learning_time_gain_hours, voc_tuning_params_.value().gating_max_duration_minutes,
+        voc_tuning_params_.value().std_initial, voc_tuning_params_.value().gain_factor);
+  }
+
+  if (this->nox_sensor_ && this->nox_tuning_params_.has_value()) {
+    nox_algorithm_.set_tuning_parameters(
+        nox_tuning_params_.value().index_offset, nox_tuning_params_.value().learning_time_offset_hours,
+        nox_tuning_params_.value().learning_time_gain_hours, nox_tuning_params_.value().gating_max_duration_minutes,
+        nox_tuning_params_.value().std_initial, nox_tuning_params_.value().gain_factor);
+  }
+
+  this->self_test_();
+
+  /* The official spec for this sensor at
+  https://sensirion.com/media/documents/296373BB/6203C5DF/Sensirion_Gas_Sensors_Datasheet_SGP40.pdf indicates this
+  sensor should be driven at 1Hz. Comments from the developers at:
+  https://github.com/Sensirion/embedded-sgp/issues/136 indicate the algorithm should be a bit resilient to slight
+  timing variations so the software timer should be accurate enough for this.
+
+  This block starts sampling from the sensor at 1Hz, and is done seperately from the call
+  to the update method. This seperation is to support getting accurate measurements but
+  limit the amount of communication done over wifi for power consumption or to keep the
+  number of records reported from being overwhelming.
+  */
+  ESP_LOGD(TAG, "Component requires sampling of 1Hz, setting up background sampler");
+  this->set_interval(1000, [this]() { this->update_gas_indices(); });
+}
+
+void SGP4xComponent::self_test_() {
+  ESP_LOGD(TAG, "Self-test started");
+  if (!this->write_command(SGP4X_CMD_SELF_TEST)) {
+    this->error_code_ = COMMUNICATION_FAILED;
+    ESP_LOGD(TAG, "Self-test communication failed");
+    this->mark_failed();
+  }
+
+  this->set_timeout(self_test_time_, [this]() {
+    uint16_t reply;
+    if (!this->read_data(reply)) {
+      this->error_code_ = SELF_TEST_FAILED;
+      ESP_LOGD(TAG, "Self-test read_data_ failed");
+      this->mark_failed();
+      return;
+    }
+
+    if (reply == 0xD400) {
+      this->self_test_complete_ = true;
+      ESP_LOGD(TAG, "Self-test completed");
+      return;
+    } else {
+      this->error_code_ = SELF_TEST_FAILED;
+      ESP_LOGD(TAG, "Self-test failed 0x%X", reply);
+      return;
+    }
+
+    ESP_LOGD(TAG, "Self-test failed 0x%X", reply);
+    this->mark_failed();
+  });
+}
+
+/**
+ * @brief Combined the measured gasses, temperature, and humidity
+ * to calculate the VOC Index
+ *
+ * @param temperature The measured temperature in degrees C
+ * @param humidity The measured relative humidity in % rH
+ * @return int32_t The VOC Index
+ */
+bool SGP4xComponent::measure_gas_indices_(int32_t &voc, int32_t &nox) {
+  uint16_t voc_sraw;
+  uint16_t nox_sraw;
+  if (!measure_raw_(voc_sraw, nox_sraw))
+    return false;
+
+  this->status_clear_warning();
+
+  voc = voc_algorithm_.process(voc_sraw);
+  if (nox_sensor_) {
+    nox = nox_algorithm_.process(nox_sraw);
+  }
+  ESP_LOGV(TAG, "VOC = %d, NOx = %d", voc, nox);
+  // Store baselines after defined interval or if the difference between current and stored baseline becomes too
+  // much
+  if (this->store_baseline_ && this->seconds_since_last_store_ > SHORTEST_BASELINE_STORE_INTERVAL) {
+    voc_algorithm_.get_states(this->voc_state0_, this->voc_state1_);
+    if ((uint32_t) abs(this->voc_baselines_storage_.state0 - this->voc_state0_) > MAXIMUM_STORAGE_DIFF ||
+        (uint32_t) abs(this->voc_baselines_storage_.state1 - this->voc_state1_) > MAXIMUM_STORAGE_DIFF) {
+      this->seconds_since_last_store_ = 0;
+      this->voc_baselines_storage_.state0 = this->voc_state0_;
+      this->voc_baselines_storage_.state1 = this->voc_state1_;
+
+      if (this->pref_.save(&this->voc_baselines_storage_)) {
+        ESP_LOGI(TAG, "Stored VOC baseline state0: 0x%04X ,state1: 0x%04X", this->voc_baselines_storage_.state0,
+                 voc_baselines_storage_.state1);
+      } else {
+        ESP_LOGW(TAG, "Could not store VOC baselines");
+      }
+    }
+  }
+
+  return true;
+}
+/**
+ * @brief Return the raw gas measurement
+ *
+ * @param temperature The measured temperature in degrees C
+ * @param humidity The measured relative humidity in % rH
+ * @return uint16_t The current raw gas measurement
+ */
+bool SGP4xComponent::measure_raw_(uint16_t &voc_raw, uint16_t &nox_raw) {
+  float humidity = NAN;
+  static uint32_t nox_conditioning_start = millis();
+
+  if (!this->self_test_complete_) {
+    ESP_LOGD(TAG, "Self-test not yet complete");
+    return false;
+  }
+  if (this->humidity_sensor_ != nullptr) {
+    humidity = this->humidity_sensor_->state;
+  }
+  if (std::isnan(humidity) || humidity < 0.0f || humidity > 100.0f) {
+    humidity = 50;
+  }
+
+  float temperature = NAN;
+  if (this->temperature_sensor_ != nullptr) {
+    temperature = float(this->temperature_sensor_->state);
+  }
+  if (std::isnan(temperature) || temperature < -40.0f || temperature > 85.0f) {
+    temperature = 25;
+  }
+
+  uint16_t command;
+  uint16_t data[2];
+  size_t response_words;
+  // Use SGP40 measure command if we don't care about NOx
+  if (nox_sensor_ == nullptr) {
+    command = SGP40_CMD_MEASURE_RAW;
+    response_words = 1;
+  } else {
+    // SGP41 sensor must use NOx conditioning command for the first 10 seconds
+    if (millis() - nox_conditioning_start < 10000) {
+      command = SGP41_CMD_NOX_CONDITIONING;
+      response_words = 1;
+    } else {
+      command = SGP41_CMD_MEASURE_RAW;
+      response_words = 2;
+    }
+  }
+  uint16_t rhticks = llround((uint16_t)((humidity * 65535) / 100));
+  uint16_t tempticks = (uint16_t)(((temperature + 45) * 65535) / 175);
+  // first paramater are the relative humidity ticks
+  data[0] = rhticks;
+  // secomd paramater are the temperature ticks
+  data[1] = tempticks;
+
+  if (!this->write_command(command, data, 2)) {
+    this->status_set_warning();
+    ESP_LOGD(TAG, "write error (%d)", this->last_error_);
+    return false;
+  }
+  delay(measure_time_);
+  uint16_t raw_data[2];
+  raw_data[1] = 0;
+  if (!this->read_data(raw_data, response_words)) {
+    this->status_set_warning();
+    ESP_LOGD(TAG, "read error (%d)", this->last_error_);
+    return false;
+  }
+  voc_raw = raw_data[0];
+  nox_raw = raw_data[1];  // either 0 or the measured NOx ticks
+  return true;
+}
+
+void SGP4xComponent::update_gas_indices() {
+  if (!this->self_test_complete_)
+    return;
+
+  this->seconds_since_last_store_ += 1;
+  if (!this->measure_gas_indices_(this->voc_index_, this->nox_index_)) {
+    // Set values to UINT16_MAX to indicate failure
+    this->voc_index_ = this->nox_index_ = UINT16_MAX;
+    ESP_LOGE(TAG, "measure gas indices failed");
+    return;
+  }
+  if (this->samples_read_ < this->samples_to_stabilize_) {
+    this->samples_read_++;
+    ESP_LOGD(TAG, "Sensor has not collected enough samples yet. (%d/%d) VOC index is: %u", this->samples_read_,
+             this->samples_to_stabilize_, this->voc_index_);
+    return;
+  }
+}
+
+void SGP4xComponent::update() {
+  if (this->samples_read_ < this->samples_to_stabilize_) {
+    return;
+  }
+  if (this->voc_sensor_) {
+    if (this->voc_index_ != UINT16_MAX) {
+      this->status_clear_warning();
+      this->voc_sensor_->publish_state(this->voc_index_);
+    } else {
+      this->status_set_warning();
+    }
+  }
+  if (this->nox_sensor_) {
+    if (this->nox_index_ != UINT16_MAX) {
+      this->status_clear_warning();
+      this->nox_sensor_->publish_state(this->nox_index_);
+    } else {
+      this->status_set_warning();
+    }
+  }
+}
+
+void SGP4xComponent::dump_config() {
+  ESP_LOGCONFIG(TAG, "SGP4x:");
+  LOG_I2C_DEVICE(this);
+  ESP_LOGCONFIG(TAG, "  store_baseline: %d", this->store_baseline_);
+
+  if (this->is_failed()) {
+    switch (this->error_code_) {
+      case COMMUNICATION_FAILED:
+        ESP_LOGW(TAG, "Communication failed! Is the sensor connected?");
+        break;
+      case SERIAL_NUMBER_IDENTIFICATION_FAILED:
+        ESP_LOGW(TAG, "Get Serial number failed.");
+        break;
+      case SELF_TEST_FAILED:
+        ESP_LOGW(TAG, "Self test failed.");
+        break;
+
+      default:
+        ESP_LOGW(TAG, "Unknown setup error!");
+        break;
+    }
+  } else {
+    ESP_LOGCONFIG(TAG, "  Type: %s", sgp_type_ == SGP41 ? "SGP41" : "SPG40");
+    ESP_LOGCONFIG(TAG, "  Serial number: %" PRIu64, this->serial_number_);
+    ESP_LOGCONFIG(TAG, "  Minimum Samples: %f", GasIndexAlgorithm_INITIAL_BLACKOUT);
+  }
+  LOG_UPDATE_INTERVAL(this);
+
+  if (this->humidity_sensor_ != nullptr && this->temperature_sensor_ != nullptr) {
+    ESP_LOGCONFIG(TAG, "  Compensation:");
+    LOG_SENSOR("    ", "Temperature Source:", this->temperature_sensor_);
+    LOG_SENSOR("    ", "Humidity Source:", this->humidity_sensor_);
+  } else {
+    ESP_LOGCONFIG(TAG, "  Compensation: No source configured");
+  }
+  LOG_SENSOR("  ", "VOC", this->voc_sensor_);
+  LOG_SENSOR("  ", "NOx", this->nox_sensor_);
+}
+
+}  // namespace sgp4x
+}  // namespace esphome
diff --git a/esphome/components/sgp4x/sgp4x.h b/esphome/components/sgp4x/sgp4x.h
new file mode 100644
index 0000000000..3060972fc3
--- /dev/null
+++ b/esphome/components/sgp4x/sgp4x.h
@@ -0,0 +1,142 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/components/sensor/sensor.h"
+#include "esphome/components/sensirion_common/i2c_sensirion.h"
+#include "esphome/core/application.h"
+#include "esphome/core/preferences.h"
+#include <VOCGasIndexAlgorithm.h>
+#include <NOxGasIndexAlgorithm.h>
+
+#include <cmath>
+
+namespace esphome {
+namespace sgp4x {
+
+struct SGP4xBaselines {
+  int32_t state0;
+  int32_t state1;
+} PACKED;  // NOLINT
+
+enum SgpType { SGP40, SGP41 };
+
+struct GasTuning {
+  uint16_t index_offset;
+  uint16_t learning_time_offset_hours;
+  uint16_t learning_time_gain_hours;
+  uint16_t gating_max_duration_minutes;
+  uint16_t std_initial;
+  uint16_t gain_factor;
+};
+
+// commands and constants
+static const uint8_t SGP40_FEATURESET = 0x0020;  // can measure VOC
+static const uint8_t SGP41_FEATURESET = 0x0040;  // can measure VOC and NOX
+// Commands
+static const uint16_t SGP4X_CMD_GET_SERIAL_ID = 0x3682;
+static const uint16_t SGP4X_CMD_GET_FEATURESET = 0x202f;
+static const uint16_t SGP4X_CMD_SELF_TEST = 0x280e;
+static const uint16_t SGP40_CMD_MEASURE_RAW = 0x260F;
+static const uint16_t SGP41_CMD_MEASURE_RAW = 0x2619;
+static const uint16_t SGP41_CMD_NOX_CONDITIONING = 0x2612;
+static const uint8_t SGP41_SUBCMD_NOX_CONDITIONING = 0x12;
+
+// Shortest time interval of 3H for storing baseline values.
+// Prevents wear of the flash because of too many write operations
+const uint32_t SHORTEST_BASELINE_STORE_INTERVAL = 10800;
+static const uint16_t SPG40_SELFTEST_TIME = 250;  // 250 ms for self test
+static const uint16_t SPG41_SELFTEST_TIME = 320;  // 320 ms for self test
+static const uint16_t SGP40_MEASURE_TIME = 30;
+static const uint16_t SGP41_MEASURE_TIME = 55;
+// Store anyway if the baseline difference exceeds the max storage diff value
+const uint32_t MAXIMUM_STORAGE_DIFF = 50;
+
+class SGP4xComponent;
+
+/// This class implements support for the Sensirion sgp4x i2c GAS (VOC) sensors.
+class SGP4xComponent : public PollingComponent, public sensor::Sensor, public sensirion_common::SensirionI2CDevice {
+  enum ErrorCode {
+    COMMUNICATION_FAILED,
+    MEASUREMENT_INIT_FAILED,
+    INVALID_ID,
+    UNSUPPORTED_ID,
+    SERIAL_NUMBER_IDENTIFICATION_FAILED,
+    SELF_TEST_FAILED,
+    UNKNOWN
+  } error_code_{UNKNOWN};
+
+ public:
+  // SGP4xComponent()  {};
+  void set_humidity_sensor(sensor::Sensor *humidity) { humidity_sensor_ = humidity; }
+  void set_temperature_sensor(sensor::Sensor *temperature) { temperature_sensor_ = temperature; }
+
+  void setup() override;
+  void update() override;
+  void update_gas_indices();
+  void dump_config() override;
+  float get_setup_priority() const override { return setup_priority::DATA; }
+  void set_store_baseline(bool store_baseline) { store_baseline_ = store_baseline; }
+  void set_voc_sensor(sensor::Sensor *voc_sensor) { voc_sensor_ = voc_sensor; }
+  void set_nox_sensor(sensor::Sensor *nox_sensor) { nox_sensor_ = nox_sensor; }
+  void set_voc_algorithm_tuning(uint16_t index_offset, uint16_t learning_time_offset_hours,
+                                uint16_t learning_time_gain_hours, uint16_t gating_max_duration_minutes,
+                                uint16_t std_initial, uint16_t gain_factor) {
+    voc_tuning_params_.value().index_offset = index_offset;
+    voc_tuning_params_.value().learning_time_offset_hours = learning_time_offset_hours;
+    voc_tuning_params_.value().learning_time_gain_hours = learning_time_gain_hours;
+    voc_tuning_params_.value().gating_max_duration_minutes = gating_max_duration_minutes;
+    voc_tuning_params_.value().std_initial = std_initial;
+    voc_tuning_params_.value().gain_factor = gain_factor;
+  }
+  void set_nox_algorithm_tuning(uint16_t index_offset, uint16_t learning_time_offset_hours,
+                                uint16_t learning_time_gain_hours, uint16_t gating_max_duration_minutes,
+                                uint16_t gain_factor) {
+    nox_tuning_params_.value().index_offset = index_offset;
+    nox_tuning_params_.value().learning_time_offset_hours = learning_time_offset_hours;
+    nox_tuning_params_.value().learning_time_gain_hours = learning_time_gain_hours;
+    nox_tuning_params_.value().gating_max_duration_minutes = gating_max_duration_minutes;
+    nox_tuning_params_.value().std_initial = 50;
+    nox_tuning_params_.value().gain_factor = gain_factor;
+  }
+
+ protected:
+  void self_test_();
+
+  /// Input sensor for humidity and temperature compensation.
+  sensor::Sensor *humidity_sensor_{nullptr};
+  sensor::Sensor *temperature_sensor_{nullptr};
+  int16_t sensirion_init_sensors_();
+
+  bool measure_gas_indices_(int32_t &voc, int32_t &nox);
+  bool measure_raw_(uint16_t &voc_raw, uint16_t &nox_raw);
+
+  SgpType sgp_type_{SGP40};
+  uint64_t serial_number_;
+  uint16_t featureset_;
+
+  bool self_test_complete_;
+  uint16_t self_test_time_;
+
+  sensor::Sensor *voc_sensor_{nullptr};
+  VOCGasIndexAlgorithm voc_algorithm_;
+  optional<GasTuning> voc_tuning_params_;
+  int32_t voc_state0_;
+  int32_t voc_state1_;
+  int32_t voc_index_ = 0;
+
+  sensor::Sensor *nox_sensor_{nullptr};
+  int32_t nox_index_ = 0;
+  NOxGasIndexAlgorithm nox_algorithm_;
+  optional<GasTuning> nox_tuning_params_;
+
+  uint16_t measure_time_;
+  uint8_t samples_read_ = 0;
+  uint8_t samples_to_stabilize_ = static_cast<int8_t>(GasIndexAlgorithm_INITIAL_BLACKOUT) * 2;
+
+  bool store_baseline_;
+  ESPPreferenceObject pref_;
+  uint32_t seconds_since_last_store_;
+  SGP4xBaselines voc_baselines_storage_;
+};
+}  // namespace sgp4x
+}  // namespace esphome
diff --git a/platformio.ini b/platformio.ini
index bc2cddb9f7..82cf6eeb9a 100644
--- a/platformio.ini
+++ b/platformio.ini
@@ -39,6 +39,8 @@ lib_deps =
     bblanchon/ArduinoJson@6.18.5           ; json
     wjtje/qr-code-generator-library@1.7.0  ; qr_code
     functionpointer/arduino-MLX90393@1.0.0 ; mlx90393
+    ; This is using the repository until a new release is published to PlatformIO
+    https://github.com/Sensirion/arduino-gas-index-algorithm.git ; Sensirion Gas Index Algorithm Arduino Library
 build_flags =
     -DESPHOME_LOG_LEVEL=ESPHOME_LOG_LEVEL_VERY_VERBOSE
 src_filter =
diff --git a/tests/test2.yaml b/tests/test2.yaml
index a7a9ef9661..f88486524f 100644
--- a/tests/test2.yaml
+++ b/tests/test2.yaml
@@ -281,10 +281,27 @@ sensor:
     window_correction_factor: 1.0
     address: 0x53
     update_interval: 60s
-  - platform: sgp40
-    name: 'Workshop VOC'
+  - platform: sgp4x
+    voc:
+      name: "VOC Index"
+      id: sgp40_voc_index
+      algorithm_tuning:
+        index_offset: 100
+        learning_time_offset_hours: 12
+        learning_time_gain_hours: 12
+        gating_max_duration_minutes: 180
+        std_initial: 50
+        gain_factor: 230
+    nox:
+      name: "NOx"
+      algorithm_tuning:
+        index_offset: 100
+        learning_time_offset_hours: 12
+        learning_time_gain_hours: 12
+        gating_max_duration_minutes: 180
+        std_initial: 50
+        gain_factor: 230
     update_interval: 5s
-    store_baseline: 'true'
   - platform: mcp3008
     update_interval: 5s
     mcp3008_id: 'mcp3008_hub'

From 4f52d43347c6b87529238d737473bed974b5705e Mon Sep 17 00:00:00 2001
From: gazoodle <47351872+gazoodle@users.noreply.github.com>
Date: Thu, 19 May 2022 01:49:12 +0100
Subject: [PATCH 22/60] add support user-defined modbus functions (#3461)

---
 esphome/components/modbus/modbus.cpp | 67 ++++++++++++++++++----------
 1 file changed, 44 insertions(+), 23 deletions(-)

diff --git a/esphome/components/modbus/modbus.cpp b/esphome/components/modbus/modbus.cpp
index 60ce50097c..19b5e8019e 100644
--- a/esphome/components/modbus/modbus.cpp
+++ b/esphome/components/modbus/modbus.cpp
@@ -68,33 +68,54 @@ bool Modbus::parse_modbus_byte_(uint8_t byte) {
 
   uint8_t data_len = raw[2];
   uint8_t data_offset = 3;
-  // the response for write command mirrors the requests and data startes at offset 2 instead of 3 for read commands
-  if (function_code == 0x5 || function_code == 0x06 || function_code == 0xF || function_code == 0x10) {
-    data_offset = 2;
-    data_len = 4;
-  }
 
-  // Error ( msb indicates error )
-  // response format:  Byte[0] = device address, Byte[1] function code | 0x80 , Byte[2] excpetion code, Byte[3-4] crc
-  if ((function_code & 0x80) == 0x80) {
-    data_offset = 2;
-    data_len = 1;
-  }
+  // Per https://modbus.org/docs/Modbus_Application_Protocol_V1_1b3.pdf Ch 5 User-Defined function codes
+  if (((function_code >= 65) && (function_code <= 72)) || ((function_code >= 100) && (function_code <= 110))) {
+    // Handle user-defined function, since we don't know how big this ought to be,
+    // ideally we should delegate the entire length detection to whatever handler is
+    // installed, but wait, there is the CRC, and if we get a hit there is a good
+    // chance that this is a complete message ... admittedly there is a small chance is
+    // isn't but that is quite small given the purpose of the CRC in the first place
+    data_len = at;
+    data_offset = 1;
 
-  // Byte data_offset..data_offset+data_len-1: Data
-  if (at < data_offset + data_len)
-    return true;
+    uint16_t computed_crc = crc16(raw, data_offset + data_len);
+    uint16_t remote_crc = uint16_t(raw[data_offset + data_len]) | (uint16_t(raw[data_offset + data_len + 1]) << 8);
 
-  // Byte 3+data_len: CRC_LO (over all bytes)
-  if (at == data_offset + data_len)
-    return true;
+    if (computed_crc != remote_crc)
+      return true;
 
-  // Byte data_offset+len+1: CRC_HI (over all bytes)
-  uint16_t computed_crc = crc16(raw, data_offset + data_len);
-  uint16_t remote_crc = uint16_t(raw[data_offset + data_len]) | (uint16_t(raw[data_offset + data_len + 1]) << 8);
-  if (computed_crc != remote_crc) {
-    ESP_LOGW(TAG, "Modbus CRC Check failed! %02X!=%02X", computed_crc, remote_crc);
-    return false;
+    ESP_LOGD(TAG, "Modbus user-defined function %02X found", function_code);
+
+  } else {
+    // the response for write command mirrors the requests and data startes at offset 2 instead of 3 for read commands
+    if (function_code == 0x5 || function_code == 0x06 || function_code == 0xF || function_code == 0x10) {
+      data_offset = 2;
+      data_len = 4;
+    }
+
+    // Error ( msb indicates error )
+    // response format:  Byte[0] = device address, Byte[1] function code | 0x80 , Byte[2] excpetion code, Byte[3-4] crc
+    if ((function_code & 0x80) == 0x80) {
+      data_offset = 2;
+      data_len = 1;
+    }
+
+    // Byte data_offset..data_offset+data_len-1: Data
+    if (at < data_offset + data_len)
+      return true;
+
+    // Byte 3+data_len: CRC_LO (over all bytes)
+    if (at == data_offset + data_len)
+      return true;
+
+    // Byte data_offset+len+1: CRC_HI (over all bytes)
+    uint16_t computed_crc = crc16(raw, data_offset + data_len);
+    uint16_t remote_crc = uint16_t(raw[data_offset + data_len]) | (uint16_t(raw[data_offset + data_len + 1]) << 8);
+    if (computed_crc != remote_crc) {
+      ESP_LOGW(TAG, "Modbus CRC Check failed! %02X!=%02X", computed_crc, remote_crc);
+      return false;
+    }
   }
   std::vector<uint8_t> data(this->rx_buffer_.begin() + data_offset, this->rx_buffer_.begin() + data_offset + data_len);
   bool found = false;

From f0c890f160dc1f073b351d39525f0b377be2055f Mon Sep 17 00:00:00 2001
From: Keilin Bickar <TrumpetGod@gmail.com>
Date: Wed, 18 May 2022 20:50:44 -0400
Subject: [PATCH 23/60] Remove deprecated fan speeds (#3397)

Co-authored-by: Jesse Hills <3060199+jesserockz@users.noreply.github.com>
---
 esphome/components/api/api_connection.cpp     | 12 -----
 esphome/components/fan/fan.cpp                | 17 -------
 esphome/components/fan/fan.h                  |  7 ---
 esphome/components/fan/fan_helpers.cpp        | 23 ----------
 esphome/components/fan/fan_helpers.h          | 20 ---------
 .../components/hbridge/fan/hbridge_fan.cpp    |  1 -
 esphome/components/mqtt/mqtt_fan.cpp          | 45 +------------------
 esphome/components/speed/fan/speed_fan.cpp    |  1 -
 esphome/components/tuya/fan/tuya_fan.cpp      |  1 -
 esphome/components/web_server/web_server.cpp  | 24 ----------
 10 files changed, 2 insertions(+), 149 deletions(-)
 delete mode 100644 esphome/components/fan/fan_helpers.cpp
 delete mode 100644 esphome/components/fan/fan_helpers.h

diff --git a/esphome/components/api/api_connection.cpp b/esphome/components/api/api_connection.cpp
index 81f2465b74..4f399d95d0 100644
--- a/esphome/components/api/api_connection.cpp
+++ b/esphome/components/api/api_connection.cpp
@@ -12,9 +12,6 @@
 #ifdef USE_HOMEASSISTANT_TIME
 #include "esphome/components/homeassistant/time/homeassistant_time.h"
 #endif
-#ifdef USE_FAN
-#include "esphome/components/fan/fan_helpers.h"
-#endif
 
 namespace esphome {
 namespace api {
@@ -253,9 +250,6 @@ void APIConnection::cover_command(const CoverCommandRequest &msg) {
 #endif
 
 #ifdef USE_FAN
-// Shut-up about usage of deprecated speed_level_to_enum/speed_enum_to_level functions for a bit.
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 bool APIConnection::send_fan_state(fan::Fan *fan) {
   if (!this->state_subscription_)
     return false;
@@ -268,7 +262,6 @@ bool APIConnection::send_fan_state(fan::Fan *fan) {
     resp.oscillating = fan->oscillating;
   if (traits.supports_speed()) {
     resp.speed_level = fan->speed;
-    resp.speed = static_cast<enums::FanSpeed>(fan::speed_level_to_enum(fan->speed, traits.supported_speed_count()));
   }
   if (traits.supports_direction())
     resp.direction = static_cast<enums::FanDirection>(fan->direction);
@@ -295,8 +288,6 @@ void APIConnection::fan_command(const FanCommandRequest &msg) {
   if (fan == nullptr)
     return;
 
-  auto traits = fan->get_traits();
-
   auto call = fan->make_call();
   if (msg.has_state)
     call.set_state(msg.state);
@@ -305,14 +296,11 @@ void APIConnection::fan_command(const FanCommandRequest &msg) {
   if (msg.has_speed_level) {
     // Prefer level
     call.set_speed(msg.speed_level);
-  } else if (msg.has_speed) {
-    call.set_speed(fan::speed_enum_to_level(static_cast<fan::FanSpeed>(msg.speed), traits.supported_speed_count()));
   }
   if (msg.has_direction)
     call.set_direction(static_cast<fan::FanDirection>(msg.direction));
   call.perform();
 }
-#pragma GCC diagnostic pop
 #endif
 
 #ifdef USE_LIGHT
diff --git a/esphome/components/fan/fan.cpp b/esphome/components/fan/fan.cpp
index 5f9660f6d6..f7c4ab2e11 100644
--- a/esphome/components/fan/fan.cpp
+++ b/esphome/components/fan/fan.cpp
@@ -1,5 +1,4 @@
 #include "fan.h"
-#include "fan_helpers.h"
 #include "esphome/core/log.h"
 
 namespace esphome {
@@ -61,22 +60,6 @@ void FanCall::validate_() {
   }
 }
 
-// This whole method is deprecated, don't warn about usage of deprecated methods inside of it.
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-FanCall &FanCall::set_speed(const char *legacy_speed) {
-  const auto supported_speed_count = this->parent_.get_traits().supported_speed_count();
-  if (strcasecmp(legacy_speed, "low") == 0) {
-    this->set_speed(fan::speed_enum_to_level(FAN_SPEED_LOW, supported_speed_count));
-  } else if (strcasecmp(legacy_speed, "medium") == 0) {
-    this->set_speed(fan::speed_enum_to_level(FAN_SPEED_MEDIUM, supported_speed_count));
-  } else if (strcasecmp(legacy_speed, "high") == 0) {
-    this->set_speed(fan::speed_enum_to_level(FAN_SPEED_HIGH, supported_speed_count));
-  }
-  return *this;
-}
-#pragma GCC diagnostic pop
-
 FanCall FanRestoreState::to_call(Fan &fan) {
   auto call = fan.make_call();
   call.set_state(this->state);
diff --git a/esphome/components/fan/fan.h b/esphome/components/fan/fan.h
index cafb5843d1..ef2ecd0f3f 100644
--- a/esphome/components/fan/fan.h
+++ b/esphome/components/fan/fan.h
@@ -16,13 +16,6 @@ namespace fan {
     (obj)->dump_traits_(TAG, prefix); \
   }
 
-/// Simple enum to represent the speed of a fan. - DEPRECATED - Will be deleted soon
-enum ESPDEPRECATED("FanSpeed is deprecated.", "2021.9") FanSpeed {
-  FAN_SPEED_LOW = 0,     ///< The fan is running on low speed.
-  FAN_SPEED_MEDIUM = 1,  ///< The fan is running on medium speed.
-  FAN_SPEED_HIGH = 2     ///< The fan is running on high/full speed.
-};
-
 /// Simple enum to represent the direction of a fan.
 enum class FanDirection { FORWARD = 0, REVERSE = 1 };
 
diff --git a/esphome/components/fan/fan_helpers.cpp b/esphome/components/fan/fan_helpers.cpp
deleted file mode 100644
index 34883617e6..0000000000
--- a/esphome/components/fan/fan_helpers.cpp
+++ /dev/null
@@ -1,23 +0,0 @@
-#include <cassert>
-#include "fan_helpers.h"
-
-namespace esphome {
-namespace fan {
-
-// This whole file is deprecated, don't warn about usage of deprecated types in here.
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-
-FanSpeed speed_level_to_enum(int speed_level, int supported_speed_levels) {
-  const auto speed_ratio = static_cast<float>(speed_level) / (supported_speed_levels + 1);
-  const auto legacy_level = clamp<int>(static_cast<int>(ceilf(speed_ratio * 3)), 1, 3);
-  return static_cast<FanSpeed>(legacy_level - 1);
-}
-
-int speed_enum_to_level(FanSpeed speed, int supported_speed_levels) {
-  const auto enum_level = static_cast<int>(speed) + 1;
-  const auto speed_level = roundf(enum_level / 3.0f * supported_speed_levels);
-  return static_cast<int>(speed_level);
-}
-
-}  // namespace fan
-}  // namespace esphome
diff --git a/esphome/components/fan/fan_helpers.h b/esphome/components/fan/fan_helpers.h
deleted file mode 100644
index 8e8e3859bd..0000000000
--- a/esphome/components/fan/fan_helpers.h
+++ /dev/null
@@ -1,20 +0,0 @@
-#pragma once
-
-#include "fan.h"
-
-namespace esphome {
-namespace fan {
-
-// Shut-up about usage of deprecated FanSpeed for a bit.
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-
-ESPDEPRECATED("FanSpeed and speed_level_to_enum() are deprecated.", "2021.9")
-FanSpeed speed_level_to_enum(int speed_level, int supported_speed_levels);
-ESPDEPRECATED("FanSpeed and speed_enum_to_level() are deprecated.", "2021.9")
-int speed_enum_to_level(FanSpeed speed, int supported_speed_levels);
-
-#pragma GCC diagnostic pop
-
-}  // namespace fan
-}  // namespace esphome
diff --git a/esphome/components/hbridge/fan/hbridge_fan.cpp b/esphome/components/hbridge/fan/hbridge_fan.cpp
index 52d2b3d8b7..44cf5ae049 100644
--- a/esphome/components/hbridge/fan/hbridge_fan.cpp
+++ b/esphome/components/hbridge/fan/hbridge_fan.cpp
@@ -1,5 +1,4 @@
 #include "hbridge_fan.h"
-#include "esphome/components/fan/fan_helpers.h"
 #include "esphome/core/log.h"
 
 namespace esphome {
diff --git a/esphome/components/mqtt/mqtt_fan.cpp b/esphome/components/mqtt/mqtt_fan.cpp
index e4d867843c..6433ead6b2 100644
--- a/esphome/components/mqtt/mqtt_fan.cpp
+++ b/esphome/components/mqtt/mqtt_fan.cpp
@@ -5,7 +5,6 @@
 
 #ifdef USE_MQTT
 #ifdef USE_FAN
-#include "esphome/components/fan/fan_helpers.h"
 
 namespace esphome {
 namespace mqtt {
@@ -88,17 +87,6 @@ void MQTTFanComponent::setup() {
                     });
   }
 
-  if (this->state_->get_traits().supports_speed()) {
-    this->subscribe(this->get_speed_command_topic(), [this](const std::string &topic, const std::string &payload) {
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-      this->state_->make_call()
-          .set_speed(payload.c_str())  // NOLINT(clang-diagnostic-deprecated-declarations)
-          .perform();
-#pragma GCC diagnostic pop
-    });
-  }
-
   auto f = std::bind(&MQTTFanComponent::publish_state, this);
   this->state_->add_on_state_callback([this, f]() { this->defer("send", f); });
 }
@@ -113,8 +101,6 @@ void MQTTFanComponent::dump_config() {
   if (this->state_->get_traits().supports_speed()) {
     ESP_LOGCONFIG(TAG, "  Speed Level State Topic: '%s'", this->get_speed_level_state_topic().c_str());
     ESP_LOGCONFIG(TAG, "  Speed Level Command Topic: '%s'", this->get_speed_level_command_topic().c_str());
-    ESP_LOGCONFIG(TAG, "  Speed State Topic: '%s'", this->get_speed_state_topic().c_str());
-    ESP_LOGCONFIG(TAG, "  Speed Command Topic: '%s'", this->get_speed_command_topic().c_str());
   }
 }
 
@@ -126,10 +112,8 @@ void MQTTFanComponent::send_discovery(JsonObject root, mqtt::SendDiscoveryConfig
     root[MQTT_OSCILLATION_STATE_TOPIC] = this->get_oscillation_state_topic();
   }
   if (this->state_->get_traits().supports_speed()) {
-    root["speed_level_command_topic"] = this->get_speed_level_command_topic();
-    root["speed_level_state_topic"] = this->get_speed_level_state_topic();
-    root[MQTT_SPEED_COMMAND_TOPIC] = this->get_speed_command_topic();
-    root[MQTT_SPEED_STATE_TOPIC] = this->get_speed_state_topic();
+    root[MQTT_PERCENTAGE_COMMAND_TOPIC] = this->get_speed_level_command_topic();
+    root[MQTT_PERCENTAGE_STATE_TOPIC] = this->get_speed_level_state_topic();
   }
 }
 bool MQTTFanComponent::publish_state() {
@@ -148,31 +132,6 @@ bool MQTTFanComponent::publish_state() {
     bool success = this->publish(this->get_speed_level_state_topic(), payload);
     failed = failed || !success;
   }
-  if (traits.supports_speed()) {
-    const char *payload;
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-    // NOLINTNEXTLINE(clang-diagnostic-deprecated-declarations)
-    switch (fan::speed_level_to_enum(this->state_->speed, traits.supported_speed_count())) {
-      case FAN_SPEED_LOW: {  // NOLINT(clang-diagnostic-deprecated-declarations)
-        payload = "low";
-        break;
-      }
-      case FAN_SPEED_MEDIUM: {  // NOLINT(clang-diagnostic-deprecated-declarations)
-        payload = "medium";
-        break;
-      }
-      default:
-      case FAN_SPEED_HIGH: {  // NOLINT(clang-diagnostic-deprecated-declarations)
-        payload = "high";
-        break;
-      }
-    }
-#pragma GCC diagnostic pop
-    bool success = this->publish(this->get_speed_state_topic(), payload);
-    failed = failed || !success;
-  }
-
   return !failed;
 }
 
diff --git a/esphome/components/speed/fan/speed_fan.cpp b/esphome/components/speed/fan/speed_fan.cpp
index 9ed201982a..3a65f2c365 100644
--- a/esphome/components/speed/fan/speed_fan.cpp
+++ b/esphome/components/speed/fan/speed_fan.cpp
@@ -1,5 +1,4 @@
 #include "speed_fan.h"
-#include "esphome/components/fan/fan_helpers.h"
 #include "esphome/core/log.h"
 
 namespace esphome {
diff --git a/esphome/components/tuya/fan/tuya_fan.cpp b/esphome/components/tuya/fan/tuya_fan.cpp
index 019b504deb..813aee4aa0 100644
--- a/esphome/components/tuya/fan/tuya_fan.cpp
+++ b/esphome/components/tuya/fan/tuya_fan.cpp
@@ -1,5 +1,4 @@
 #include "esphome/core/log.h"
-#include "esphome/components/fan/fan_helpers.h"
 #include "tuya_fan.h"
 
 namespace esphome {
diff --git a/esphome/components/web_server/web_server.cpp b/esphome/components/web_server/web_server.cpp
index 6822ce9953..18374d606b 100644
--- a/esphome/components/web_server/web_server.cpp
+++ b/esphome/components/web_server/web_server.cpp
@@ -21,10 +21,6 @@
 #include "esphome/components/logger/logger.h"
 #endif
 
-#ifdef USE_FAN
-#include "esphome/components/fan/fan_helpers.h"
-#endif
-
 #ifdef USE_CLIMATE
 #include "esphome/components/climate/climate.h"
 #endif
@@ -482,22 +478,6 @@ std::string WebServer::fan_json(fan::Fan *obj, JsonDetail start_config) {
     if (traits.supports_speed()) {
       root["speed_level"] = obj->speed;
       root["speed_count"] = traits.supported_speed_count();
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-      // NOLINTNEXTLINE(clang-diagnostic-deprecated-declarations)
-      switch (fan::speed_level_to_enum(obj->speed, traits.supported_speed_count())) {
-        case fan::FAN_SPEED_LOW:  // NOLINT(clang-diagnostic-deprecated-declarations)
-          root["speed"] = "low";
-          break;
-        case fan::FAN_SPEED_MEDIUM:  // NOLINT(clang-diagnostic-deprecated-declarations)
-          root["speed"] = "medium";
-          break;
-        case fan::FAN_SPEED_HIGH:  // NOLINT(clang-diagnostic-deprecated-declarations)
-          root["speed"] = "high";
-          break;
-      }
-#pragma GCC diagnostic pop
     }
     if (obj->get_traits().supports_oscillation())
       root["oscillation"] = obj->oscillating;
@@ -518,10 +498,6 @@ void WebServer::handle_fan_request(AsyncWebServerRequest *request, const UrlMatc
       auto call = obj->turn_on();
       if (request->hasParam("speed")) {
         String speed = request->getParam("speed")->value();
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-        call.set_speed(speed.c_str());  // NOLINT(clang-diagnostic-deprecated-declarations)
-#pragma GCC diagnostic pop
       }
       if (request->hasParam("speed_level")) {
         String speed_level = request->getParam("speed_level")->value();

From dda1ddcb26b9ca891ca5de668673a92bcf87ca22 Mon Sep 17 00:00:00 2001
From: Jesse Hills <3060199+jesserockz@users.noreply.github.com>
Date: Thu, 19 May 2022 16:23:40 +1200
Subject: [PATCH 24/60] Add missing import to bedjet (#3490)

---
 esphome/components/bedjet/bedjet.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/esphome/components/bedjet/bedjet.h b/esphome/components/bedjet/bedjet.h
index 0565be6045..750a20594f 100644
--- a/esphome/components/bedjet/bedjet.h
+++ b/esphome/components/bedjet/bedjet.h
@@ -4,6 +4,7 @@
 #include "esphome/components/esp32_ble_tracker/esp32_ble_tracker.h"
 #include "esphome/components/climate/climate.h"
 #include "esphome/core/component.h"
+#include "esphome/core/defines.h"
 #include "esphome/core/hal.h"
 #include "bedjet_base.h"
 

From d9d2edeb080297c3f4b0e0d82eee161222466692 Mon Sep 17 00:00:00 2001
From: Jesse Hills <3060199+jesserockz@users.noreply.github.com>
Date: Thu, 19 May 2022 21:21:42 +1200
Subject: [PATCH 25/60] Fix compile issues on windows (#3491)

---
 esphome/components/sonoff_d1/sonoff_d1.cpp               | 3 +--
 esphome/components/tuya/text_sensor/tuya_text_sensor.cpp | 2 +-
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/esphome/components/sonoff_d1/sonoff_d1.cpp b/esphome/components/sonoff_d1/sonoff_d1.cpp
index b4bcbc6760..d07f9229b6 100644
--- a/esphome/components/sonoff_d1/sonoff_d1.cpp
+++ b/esphome/components/sonoff_d1/sonoff_d1.cpp
@@ -41,7 +41,6 @@
  *  O                         FF FF FF FF FF FF FF FF    - Not used
  *  M                                                 6C - CRC over bytes 2 to F (Addition)
 \*********************************************************************************************/
-#include <cmath>
 #include "sonoff_d1.h"
 
 namespace esphome {
@@ -263,7 +262,7 @@ void SonoffD1Output::write_state(light::LightState *state) {
   state->current_values_as_brightness(&brightness);
 
   // Convert ESPHome's brightness (0-1) to the device's internal brightness (0-100)
-  const uint8_t calculated_brightness = std::round(brightness * 100);
+  const uint8_t calculated_brightness = (uint8_t) roundf(brightness * 100);
 
   if (calculated_brightness == 0) {
     // if(binary) ESP_LOGD(TAG, "current_values_as_binary() returns true for zero brightness");
diff --git a/esphome/components/tuya/text_sensor/tuya_text_sensor.cpp b/esphome/components/tuya/text_sensor/tuya_text_sensor.cpp
index 0b51ba90c4..602595e89d 100644
--- a/esphome/components/tuya/text_sensor/tuya_text_sensor.cpp
+++ b/esphome/components/tuya/text_sensor/tuya_text_sensor.cpp
@@ -20,7 +20,7 @@ void TuyaTextSensor::setup() {
         break;
       }
       default:
-        ESP_LOGW(TAG, "Unsupported data type for tuya text sensor %u: %#02hhX", datapoint.id, datapoint.type);
+        ESP_LOGW(TAG, "Unsupported data type for tuya text sensor %u: %#02hhX", datapoint.id, (uint8_t) datapoint.type);
         break;
     }
   });

From 7092f7663e5d129690f5a6603c002778bb2f444d Mon Sep 17 00:00:00 2001
From: Sergey Dudanov <sergey.dudanov@gmail.com>
Date: Mon, 23 May 2022 11:51:45 +0300
Subject: [PATCH 26/60] midea: New power_toggle action. Auto-use remote
 transmitter. (#3496)

---
 esphome/components/midea/ac_automations.h  |  5 ++++
 esphome/components/midea/air_conditioner.h |  1 +
 esphome/components/midea/climate.py        | 13 +++++++++-
 tests/test1.yaml                           | 28 +++++++++++++++-------
 4 files changed, 38 insertions(+), 9 deletions(-)

diff --git a/esphome/components/midea/ac_automations.h b/esphome/components/midea/ac_automations.h
index d4ed2e7168..5084fd1eec 100644
--- a/esphome/components/midea/ac_automations.h
+++ b/esphome/components/midea/ac_automations.h
@@ -56,6 +56,11 @@ template<typename... Ts> class PowerOffAction : public MideaActionBase<Ts...> {
   void play(Ts... x) override { this->parent_->do_power_off(); }
 };
 
+template<typename... Ts> class PowerToggleAction : public MideaActionBase<Ts...> {
+ public:
+  void play(Ts... x) override { this->parent_->do_power_toggle(); }
+};
+
 }  // namespace ac
 }  // namespace midea
 }  // namespace esphome
diff --git a/esphome/components/midea/air_conditioner.h b/esphome/components/midea/air_conditioner.h
index a6023b78bb..d809aa78f6 100644
--- a/esphome/components/midea/air_conditioner.h
+++ b/esphome/components/midea/air_conditioner.h
@@ -39,6 +39,7 @@ class AirConditioner : public ApplianceBase<dudanov::midea::ac::AirConditioner>,
   void do_beeper_off() { this->set_beeper_feedback(false); }
   void do_power_on() { this->base_.setPowerState(true); }
   void do_power_off() { this->base_.setPowerState(false); }
+  void do_power_toggle() { this->base_.setPowerState(this->mode == ClimateMode::CLIMATE_MODE_OFF); }
   void set_supported_modes(const std::set<ClimateMode> &modes) { this->supported_modes_ = modes; }
   void set_supported_swing_modes(const std::set<ClimateSwingMode> &modes) { this->supported_swing_modes_ = modes; }
   void set_supported_presets(const std::set<ClimatePreset> &presets) { this->supported_presets_ = presets; }
diff --git a/esphome/components/midea/climate.py b/esphome/components/midea/climate.py
index 46c0019efa..80b1461576 100644
--- a/esphome/components/midea/climate.py
+++ b/esphome/components/midea/climate.py
@@ -113,7 +113,7 @@ CONFIG_SCHEMA = cv.All(
             cv.Optional(CONF_PERIOD, default="1s"): cv.time_period,
             cv.Optional(CONF_TIMEOUT, default="2s"): cv.time_period,
             cv.Optional(CONF_NUM_ATTEMPTS, default=3): cv.int_range(min=1, max=5),
-            cv.Optional(CONF_TRANSMITTER_ID): cv.use_id(
+            cv.OnlyWith(CONF_TRANSMITTER_ID, "remote_transmitter"): cv.use_id(
                 remote_transmitter.RemoteTransmitterComponent
             ),
             cv.Optional(CONF_BEEPER, default=False): cv.boolean,
@@ -163,6 +163,7 @@ BeeperOnAction = midea_ac_ns.class_("BeeperOnAction", automation.Action)
 BeeperOffAction = midea_ac_ns.class_("BeeperOffAction", automation.Action)
 PowerOnAction = midea_ac_ns.class_("PowerOnAction", automation.Action)
 PowerOffAction = midea_ac_ns.class_("PowerOffAction", automation.Action)
+PowerToggleAction = midea_ac_ns.class_("PowerToggleAction", automation.Action)
 
 MIDEA_ACTION_BASE_SCHEMA = cv.Schema(
     {
@@ -249,6 +250,16 @@ async def power_off_to_code(var, config, args):
     pass
 
 
+# Power Toggle action
+@register_action(
+    "power_toggle",
+    PowerToggleAction,
+    cv.Schema({}),
+)
+async def power_inv_to_code(var, config, args):
+    pass
+
+
 async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
diff --git a/tests/test1.yaml b/tests/test1.yaml
index 7bb1fbe954..52aa03c371 100644
--- a/tests/test1.yaml
+++ b/tests/test1.yaml
@@ -1901,14 +1901,6 @@ script:
           preset: SLEEP
 
 switch:
-  - platform: template
-    name: MIDEA_AC_TOGGLE_LIGHT
-    turn_on_action:
-      midea_ac.display_toggle:
-  - platform: template
-    name: MIDEA_AC_SWING_STEP
-    turn_on_action:
-      midea_ac.swing_step:
   - platform: template
     name: MIDEA_AC_BEEPER_CONTROL
     optimistic: true
@@ -2834,3 +2826,23 @@ button:
           id: scd40
       - scd4x.factory_reset:
           id: scd40
+  - platform: template
+    name: Midea Display Toggle
+    on_press:
+      midea_ac.display_toggle:
+  - platform: template
+    name: Midea Swing Step
+    on_press:
+      midea_ac.swing_step:
+  - platform: template
+    name: Midea Power On
+    on_press:
+      midea_ac.power_on:
+  - platform: template
+    name: Midea Power Off
+    on_press:
+      midea_ac.power_off:
+  - platform: template
+    name: Midea Power Inverse
+    on_press:
+      midea_ac.power_toggle:

From a8ceeaa7b0616b132091f2fcd1d02c137238e4d8 Mon Sep 17 00:00:00 2001
From: Martin <25747549+martgras@users.noreply.github.com>
Date: Mon, 23 May 2022 10:56:26 +0200
Subject: [PATCH 27/60] esp32: fix NVS (#3497)

---
 esphome/components/esp32/preferences.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/esphome/components/esp32/preferences.cpp b/esphome/components/esp32/preferences.cpp
index a78159825e..aa03c5acc7 100644
--- a/esphome/components/esp32/preferences.cpp
+++ b/esphome/components/esp32/preferences.cpp
@@ -156,7 +156,7 @@ class ESP32Preferences : public ESPPreferences {
       ESP_LOGV(TAG, "nvs_get_blob('%s') failed: %s", to_save.key.c_str(), esp_err_to_name(err));
       return true;
     }
-    return to_save.data == stored_data.data;
+    return to_save.data != stored_data.data;
   }
 };
 

From 9dc804ee27426ee3550855347e30b4ebd2fcd2d9 Mon Sep 17 00:00:00 2001
From: joseph douce <josephdouce@gmail.com>
Date: Tue, 24 May 2022 01:52:54 +0100
Subject: [PATCH 28/60] Output a true RMS voltage % (#3494)

---
 esphome/components/ac_dimmer/ac_dimmer.cpp | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/esphome/components/ac_dimmer/ac_dimmer.cpp b/esphome/components/ac_dimmer/ac_dimmer.cpp
index e9af828a9d..1d0cd8d0ab 100644
--- a/esphome/components/ac_dimmer/ac_dimmer.cpp
+++ b/esphome/components/ac_dimmer/ac_dimmer.cpp
@@ -121,7 +121,11 @@ void IRAM_ATTR HOT AcDimmerDataStore::gpio_intr() {
       // calculate time until enable in µs: (1.0-value)*cycle_time, but with integer arithmetic
       // also take into account min_power
       auto min_us = this->cycle_time_us * this->min_power / 1000;
-      this->enable_time_us = std::max((uint32_t) 1, ((65535 - this->value) * (this->cycle_time_us - min_us)) / 65535);
+      // calculate required value to provide a true RMS voltage output
+      this->enable_time_us =
+          std::max((uint32_t) 1, (uint32_t)((65535 - (acos(1 - (2 * this->value / 65535.0)) / 3.14159 * 65535)) *
+                                            (this->cycle_time_us - min_us)) /
+                                     65535);
       if (this->method == DIM_METHOD_LEADING_PULSE) {
         // Minimum pulse time should be enough for the triac to trigger when it is close to the ZC zone
         // this is for brightness near 99%

From cd35ead890a934d474093e6c9791c5551e08ce04 Mon Sep 17 00:00:00 2001
From: Wumpf <r_andreas2@web.de>
Date: Tue, 24 May 2022 03:00:06 +0200
Subject: [PATCH 29/60] [scd4x] Fix not passing arguments to templatable value
 for perform_forced_calibration (#3495)

---
 esphome/components/scd4x/automation.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/esphome/components/scd4x/automation.h b/esphome/components/scd4x/automation.h
index 21ecb2ea4c..dc43e9eb56 100644
--- a/esphome/components/scd4x/automation.h
+++ b/esphome/components/scd4x/automation.h
@@ -11,7 +11,7 @@ template<typename... Ts> class PerformForcedCalibrationAction : public Action<Ts
  public:
   void play(Ts... x) override {
     if (this->value_.has_value()) {
-      this->parent_->perform_forced_calibration(value_.value());
+      this->parent_->perform_forced_calibration(this->value_.value(x...));
     }
   }
 

From adb7aa69509d2389144433e36a0cf965c47776c0 Mon Sep 17 00:00:00 2001
From: Michael Davidson <mrmdavidson@sadorangeproductions.com>
Date: Wed, 25 May 2022 13:44:26 +1000
Subject: [PATCH 30/60] Thermostat preset with modes (#3298)

* Rework HOME/AWAY support to being driven via a map of ClimatePreset/ThermostatClimateTargetTempConfig
This opens up to theoretically being able to support other presets (ECO, SLEEP, etc)

* Add support for additional presets
Configuration takes the form;
```
climate:
  platform: preset
  ...
  preset:
    [eco | away | boost | comfort | home | sleep | activity]:
      default_target_temperature_low: 20
      default_target_temperature_high: 24
```

These will be available in the Home Assistant UI and, like the existing Home/Away config will reset the temperature in line with these defaults when selected. The existing away_config/home_config is still respected (although preset->home/preset->away will be applied after them and override them if both styles are specified)

* Add support for specifying MODE, FAN_MODE and SWING_MODE on a preset
When switching presets these will implicitly flow through to the controller. However calls to climate.control which specify any of these will take precedence even when changing the mode (think of the preset version as the default for that preset)

* Add `preset_change` mode trigger
When defined this trigger will fire when the preset for the thermostat has been changed. The intent of this is similar to `auto_mode` - it's not intended to be used to control the preset's state (eg. communicate with the physical thermostat) but instead might be used to update a visual indicator, for instance.

* Apply lint, clang-format, and clang-tidy fixes

* Additional clang-format fixes

* Wrap log related strings in LOG_STR_ARG

* Add support for custom presets
This also changes the configuration syntax to;
```yaml
  preset:
    # Standard preset
    - name: [eco | away | boost | comfort | home | sleep | activity]
      default_target_temperature_low: 20
      ...
    # Custom preset
    - name: My custom preset
      default_target_temperature_low: 18
```

For the end user there is no difference between a custom and built in preset. For developers custom presets are set via `climate.control` `custom_preset` property instead of the `preset`

* Lint/clang-format/clang-tidy fixes

* Additional lint/clang-format/clang-tidy fixes

* Clang-tidy changes

* Sort imports

* Improve configuration validation for presets
- Unify temperature validation across default, away, and preset configuration
- Validate modes for presets have the required actions

* Trigger a refresh after changing internals of the thermostat

* Apply formatting fixes

* Validate mode, fan_mode, and swing_mode on presets

* Add preset temperature validation against visual min/max configuration

* Apply code formatting fixes

* Fix preset temperature validation
---
 esphome/components/thermostat/climate.py      | 235 ++++++++++++++++--
 .../thermostat/thermostat_climate.cpp         | 191 ++++++++++----
 .../thermostat/thermostat_climate.h           |  42 +++-
 3 files changed, 373 insertions(+), 95 deletions(-)

diff --git a/esphome/components/thermostat/climate.py b/esphome/components/thermostat/climate.py
index 20565e811c..5e26e6d6de 100644
--- a/esphome/components/thermostat/climate.py
+++ b/esphome/components/thermostat/climate.py
@@ -14,6 +14,7 @@ from esphome.const import (
     CONF_DEFAULT_TARGET_TEMPERATURE_LOW,
     CONF_DRY_ACTION,
     CONF_DRY_MODE,
+    CONF_FAN_MODE,
     CONF_FAN_MODE_ON_ACTION,
     CONF_FAN_MODE_OFF_ACTION,
     CONF_FAN_MODE_AUTO_ACTION,
@@ -37,6 +38,7 @@ from esphome.const import (
     CONF_IDLE_ACTION,
     CONF_MAX_COOLING_RUN_TIME,
     CONF_MAX_HEATING_RUN_TIME,
+    CONF_MAX_TEMPERATURE,
     CONF_MIN_COOLING_OFF_TIME,
     CONF_MIN_COOLING_RUN_TIME,
     CONF_MIN_FAN_MODE_SWITCHING_TIME,
@@ -45,7 +47,11 @@ from esphome.const import (
     CONF_MIN_HEATING_OFF_TIME,
     CONF_MIN_HEATING_RUN_TIME,
     CONF_MIN_IDLE_TIME,
+    CONF_MIN_TEMPERATURE,
+    CONF_NAME,
+    CONF_MODE,
     CONF_OFF_MODE,
+    CONF_PRESET,
     CONF_SENSOR,
     CONF_SET_POINT_MINIMUM_DIFFERENTIAL,
     CONF_STARTUP_DELAY,
@@ -55,11 +61,15 @@ from esphome.const import (
     CONF_SUPPLEMENTAL_HEATING_DELTA,
     CONF_SWING_BOTH_ACTION,
     CONF_SWING_HORIZONTAL_ACTION,
+    CONF_SWING_MODE,
     CONF_SWING_OFF_ACTION,
     CONF_SWING_VERTICAL_ACTION,
     CONF_TARGET_TEMPERATURE_CHANGE_ACTION,
+    CONF_VISUAL,
 )
 
+CONF_PRESET_CHANGE = "preset_change"
+
 CODEOWNERS = ["@kbx81"]
 
 climate_ns = cg.esphome_ns.namespace("climate")
@@ -82,6 +92,38 @@ CLIMATE_MODES = {
 }
 validate_climate_mode = cv.enum(CLIMATE_MODES, upper=True)
 
+ClimatePreset = climate_ns.enum("ClimatePreset")
+
+PRESET_CONFIG_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(): cv.declare_id(ThermostatClimateTargetTempConfig),
+        cv.Required(CONF_NAME): cv.string_strict,
+        cv.Optional(CONF_MODE): validate_climate_mode,
+        cv.Optional(CONF_DEFAULT_TARGET_TEMPERATURE_HIGH): cv.temperature,
+        cv.Optional(CONF_DEFAULT_TARGET_TEMPERATURE_LOW): cv.temperature,
+        cv.Optional(CONF_FAN_MODE): cv.templatable(climate.validate_climate_fan_mode),
+        cv.Optional(CONF_SWING_MODE): cv.templatable(
+            climate.validate_climate_swing_mode
+        ),
+    }
+)
+
+
+def validate_temperature_preset(preset, root_config, name, requirements):
+    # verify temperature settings for the provided preset / default / away configuration
+    for config_temp, req_actions in requirements.items():
+        for req_action in req_actions:
+            # verify corresponding default target temperature exists when a given climate action exists
+            if config_temp not in preset and req_action in root_config:
+                raise cv.Invalid(
+                    f"{config_temp} must be defined in {name} config when using {req_action}"
+                )
+            # if a given climate action is NOT defined, it should not have a default target temperature
+            if config_temp in preset and req_action not in root_config:
+                raise cv.Invalid(
+                    f"{config_temp} is defined in {name} config with no {req_action}"
+                )
+
 
 def validate_thermostat(config):
     # verify corresponding action(s) exist(s) for any defined climate mode or action
@@ -235,33 +277,22 @@ def validate_thermostat(config):
             CONF_DEFAULT_TARGET_TEMPERATURE_LOW: [CONF_HEAT_ACTION],
         }
 
-    for config_temp, req_actions in requirements.items():
-        for req_action in req_actions:
-            # verify corresponding default target temperature exists when a given climate action exists
-            if config_temp not in config and req_action in config:
-                raise cv.Invalid(
-                    f"{config_temp} must be defined when using {req_action}"
-                )
-            # if a given climate action is NOT defined, it should not have a default target temperature
-            if config_temp in config and req_action not in config:
-                raise cv.Invalid(f"{config_temp} is defined with no {req_action}")
+    # Validate temperature requirements for default configuraation
+    validate_temperature_preset(config, config, "default", requirements)
 
+    # Validate temperature requirements for away configuration
     if CONF_AWAY_CONFIG in config:
         away = config[CONF_AWAY_CONFIG]
-        for config_temp, req_actions in requirements.items():
-            for req_action in req_actions:
-                # verify corresponding default target temperature exists when a given climate action exists
-                if config_temp not in away and req_action in config:
-                    raise cv.Invalid(
-                        f"{config_temp} must be defined in away configuration when using {req_action}"
-                    )
-                # if a given climate action is NOT defined, it should not have a default target temperature
-                if config_temp in away and req_action not in config:
-                    raise cv.Invalid(
-                        f"{config_temp} is defined in away configuration with no {req_action}"
-                    )
+        validate_temperature_preset(away, config, "away", requirements)
 
-    # verify default climate mode is valid given above configuration
+    # Validate temperature requirements for presets
+    if CONF_PRESET in config:
+        for preset_config in config[CONF_PRESET]:
+            validate_temperature_preset(
+                preset_config, config, preset_config[CONF_NAME], requirements
+            )
+
+    # Verify default climate mode is valid given above configuration
     default_mode = config[CONF_DEFAULT_MODE]
     requirements = {
         "HEAT_COOL": [CONF_COOL_ACTION, CONF_HEAT_ACTION],
@@ -270,13 +301,108 @@ def validate_thermostat(config):
         "DRY": [CONF_DRY_ACTION],
         "FAN_ONLY": [CONF_FAN_ONLY_ACTION],
         "AUTO": [CONF_COOL_ACTION, CONF_HEAT_ACTION],
-    }.get(default_mode, [])
-    for req in requirements:
+        "OFF": [],
+    }
+    actions_for_default_mode = requirements.get(default_mode, [])
+    for req in actions_for_default_mode:
         if req not in config:
             raise cv.Invalid(
                 f"{CONF_DEFAULT_MODE} is set to {default_mode} but {req} is not present in the configuration"
             )
 
+    # Verify that the modes for presets are valid given the configuration
+    if CONF_PRESET in config:
+        # Preset temperature vs Visual temperature validation
+
+        # Default visual configuration from climate_traits.h
+        visual_min_temperature = 10.0
+        visual_max_temperature = 30.0
+        if CONF_VISUAL in config:
+            visual_config = config[CONF_VISUAL]
+
+            if CONF_MIN_TEMPERATURE in visual_config:
+                visual_min_temperature = visual_config[CONF_MIN_TEMPERATURE]
+
+            if CONF_MAX_TEMPERATURE in visual_config:
+                visual_max_temperature = visual_config[CONF_MAX_TEMPERATURE]
+
+        for preset_config in config[CONF_PRESET]:
+            if CONF_DEFAULT_TARGET_TEMPERATURE_LOW in preset_config:
+                preset_min_temperature = preset_config[
+                    CONF_DEFAULT_TARGET_TEMPERATURE_LOW
+                ]
+                if preset_min_temperature < visual_min_temperature:
+                    raise cv.Invalid(
+                        f"{CONF_DEFAULT_TARGET_TEMPERATURE_LOW} for {preset_config[CONF_NAME]} is set to {preset_min_temperature} which is less than the visual minimum temperature of {visual_min_temperature}"
+                    )
+
+            if CONF_DEFAULT_TARGET_TEMPERATURE_HIGH in preset_config:
+                preset_max_temperature = preset_config[
+                    CONF_DEFAULT_TARGET_TEMPERATURE_HIGH
+                ]
+                if preset_max_temperature > visual_max_temperature:
+                    raise cv.Invalid(
+                        f"{CONF_DEFAULT_TARGET_TEMPERATURE_HIGH} for {preset_config[CONF_NAME]} is set to {preset_max_temperature} which is more than the visual maximum temperature of {visual_max_temperature}"
+                    )
+
+        # Mode validation
+        for preset_config in config[CONF_PRESET]:
+            if CONF_MODE not in preset_config:
+                continue
+
+            mode = preset_config[CONF_MODE]
+
+            for req in requirements[mode]:
+                if req not in config:
+                    raise cv.Invalid(
+                        f"{CONF_MODE} is set to {mode} for {preset_config[CONF_NAME]} but {req} is not present in the configuration"
+                    )
+
+        # Fan mode requirements
+        requirements = {
+            "ON": [CONF_FAN_MODE_ON_ACTION],
+            "OFF": [CONF_FAN_MODE_OFF_ACTION],
+            "AUTO": [CONF_FAN_MODE_AUTO_ACTION],
+            "LOW": [CONF_FAN_MODE_LOW_ACTION],
+            "MEDIUM": [CONF_FAN_MODE_MEDIUM_ACTION],
+            "HIGH": [CONF_FAN_MODE_HIGH_ACTION],
+            "MIDDLE": [CONF_FAN_MODE_MIDDLE_ACTION],
+            "FOCUS": [CONF_FAN_MODE_FOCUS_ACTION],
+            "DIFFUSE": [CONF_FAN_MODE_DIFFUSE_ACTION],
+        }
+
+        for preset_config in config[CONF_PRESET]:
+            if CONF_FAN_MODE not in preset_config:
+                continue
+
+            fan_mode = preset_config[CONF_FAN_MODE]
+
+            for req in requirements[fan_mode]:
+                if req not in config:
+                    raise cv.Invalid(
+                        f"{CONF_FAN_MODE} is set to {fan_mode} for {preset_config[CONF_NAME]} but {req} is not present in the configuration"
+                    )
+
+        # Swing mode requirements
+        requirements = {
+            "OFF": [CONF_SWING_OFF_ACTION],
+            "BOTH": [CONF_SWING_BOTH_ACTION],
+            "VERTICAL": [CONF_SWING_VERTICAL_ACTION],
+            "HORIZONTAL": [CONF_SWING_HORIZONTAL_ACTION],
+        }
+
+        for preset_config in config[CONF_PRESET]:
+            if CONF_SWING_MODE not in preset_config:
+                continue
+
+            swing_mode = preset_config[CONF_SWING_MODE]
+
+            for req in requirements[swing_mode]:
+                if req not in config:
+                    raise cv.Invalid(
+                        f"{CONF_SWING_MODE} is set to {swing_mode} for {preset_config[CONF_NAME]} but {req} is not present in the configuration"
+                    )
+
     if config[CONF_FAN_WITH_COOLING] is True and CONF_FAN_ONLY_ACTION not in config:
         raise cv.Invalid(
             f"{CONF_FAN_ONLY_ACTION} must be defined to use {CONF_FAN_WITH_COOLING}"
@@ -415,6 +541,10 @@ CONFIG_SCHEMA = cv.All(
                     cv.Optional(CONF_DEFAULT_TARGET_TEMPERATURE_LOW): cv.temperature,
                 }
             ),
+            cv.Optional(CONF_PRESET): cv.ensure_list(PRESET_CONFIG_SCHEMA),
+            cv.Optional(CONF_PRESET_CHANGE): automation.validate_automation(
+                single=True
+            ),
         }
     ).extend(cv.COMPONENT_SCHEMA),
     cv.has_at_least_one_key(
@@ -531,7 +661,7 @@ async def to_code(config):
     cg.add(var.set_supports_fan_with_heating(config[CONF_FAN_WITH_HEATING]))
 
     cg.add(var.set_use_startup_delay(config[CONF_STARTUP_DELAY]))
-    cg.add(var.set_normal_config(normal_config))
+    cg.add(var.set_preset_config(ClimatePreset.CLIMATE_PRESET_HOME, normal_config))
 
     await automation.build_automation(
         var.get_idle_action_trigger(), [], config[CONF_IDLE_ACTION]
@@ -694,4 +824,55 @@ async def to_code(config):
             away_config = ThermostatClimateTargetTempConfig(
                 away[CONF_DEFAULT_TARGET_TEMPERATURE_LOW]
             )
-        cg.add(var.set_away_config(away_config))
+        cg.add(var.set_preset_config(ClimatePreset.CLIMATE_PRESET_AWAY, away_config))
+
+    if CONF_PRESET in config:
+        for preset_config in config[CONF_PRESET]:
+
+            name = preset_config[CONF_NAME]
+            standard_preset = None
+            if name.upper() in climate.CLIMATE_PRESETS:
+                standard_preset = climate.CLIMATE_PRESETS[name.upper()]
+
+            if two_points_available is True:
+                preset_target_config = ThermostatClimateTargetTempConfig(
+                    preset_config[CONF_DEFAULT_TARGET_TEMPERATURE_LOW],
+                    preset_config[CONF_DEFAULT_TARGET_TEMPERATURE_HIGH],
+                )
+            elif CONF_DEFAULT_TARGET_TEMPERATURE_HIGH in preset_config:
+                preset_target_config = ThermostatClimateTargetTempConfig(
+                    preset_config[CONF_DEFAULT_TARGET_TEMPERATURE_HIGH]
+                )
+            elif CONF_DEFAULT_TARGET_TEMPERATURE_LOW in preset_config:
+                preset_target_config = ThermostatClimateTargetTempConfig(
+                    preset_config[CONF_DEFAULT_TARGET_TEMPERATURE_LOW]
+                )
+
+            preset_target_variable = cg.new_variable(
+                preset_config[CONF_ID], preset_target_config
+            )
+
+            if CONF_MODE in preset_config:
+                cg.add(preset_target_variable.set_mode(preset_config[CONF_MODE]))
+
+            if CONF_FAN_MODE in preset_config:
+                cg.add(
+                    preset_target_variable.set_fan_mode(preset_config[CONF_FAN_MODE])
+                )
+
+            if CONF_SWING_MODE in preset_config:
+                cg.add(
+                    preset_target_variable.set_swing_mode(
+                        preset_config[CONF_SWING_MODE]
+                    )
+                )
+
+            if standard_preset is not None:
+                cg.add(var.set_preset_config(standard_preset, preset_target_variable))
+            else:
+                cg.add(var.set_custom_preset_config(name, preset_target_variable))
+
+    if CONF_PRESET_CHANGE in config:
+        await automation.build_automation(
+            var.get_preset_change_trigger(), [], config[CONF_PRESET_CHANGE]
+        )
diff --git a/esphome/components/thermostat/thermostat_climate.cpp b/esphome/components/thermostat/thermostat_climate.cpp
index 760525e2cd..dc4e1e437e 100644
--- a/esphome/components/thermostat/thermostat_climate.cpp
+++ b/esphome/components/thermostat/thermostat_climate.cpp
@@ -32,7 +32,7 @@ void ThermostatClimate::setup() {
   } else {
     // restore from defaults, change_away handles temps for us
     this->mode = this->default_mode_;
-    this->change_away_(false);
+    this->change_preset_(climate::CLIMATE_PRESET_HOME);
   }
   // refresh the climate action based on the restored settings, we'll publish_state() later
   this->switch_to_action_(this->compute_action_(), false);
@@ -162,11 +162,20 @@ void ThermostatClimate::control(const climate::ClimateCall &call) {
   if (call.get_preset().has_value()) {
     // setup_complete_ blocks modifying/resetting the temps immediately after boot
     if (this->setup_complete_) {
-      this->change_away_(*call.get_preset() == climate::CLIMATE_PRESET_AWAY);
+      this->change_preset_(*call.get_preset());
     } else {
       this->preset = *call.get_preset();
     }
   }
+  if (call.get_custom_preset().has_value()) {
+    // setup_complete_ blocks modifying/resetting the temps immediately after boot
+    if (this->setup_complete_) {
+      this->change_custom_preset_(*call.get_custom_preset());
+    } else {
+      this->custom_preset = *call.get_custom_preset();
+    }
+  }
+
   if (call.get_mode().has_value())
     this->mode = *call.get_mode();
   if (call.get_fan_mode().has_value())
@@ -236,8 +245,12 @@ climate::ClimateTraits ThermostatClimate::traits() {
   if (supports_swing_mode_vertical_)
     traits.add_supported_swing_mode(climate::CLIMATE_SWING_VERTICAL);
 
-  if (supports_away_)
-    traits.set_supported_presets({climate::CLIMATE_PRESET_HOME, climate::CLIMATE_PRESET_AWAY});
+  for (auto &it : this->preset_config_) {
+    traits.add_supported_preset(it.first);
+  }
+  for (auto &it : this->custom_preset_config_) {
+    traits.add_supported_custom_preset(it.first);
+  }
 
   traits.set_supports_two_point_target_temperature(this->supports_two_points_);
   traits.set_supports_action(true);
@@ -910,30 +923,112 @@ bool ThermostatClimate::supplemental_heating_required_() {
           (this->supplemental_action_ == climate::CLIMATE_ACTION_HEATING));
 }
 
-void ThermostatClimate::change_away_(bool away) {
-  if (!away) {
+void ThermostatClimate::dump_preset_config_(const std::string &preset,
+                                            const ThermostatClimateTargetTempConfig &config) {
+  const auto *preset_name = preset.c_str();
+
+  if (this->supports_heat_) {
     if (this->supports_two_points_) {
-      this->target_temperature_low = this->normal_config_.default_temperature_low;
-      this->target_temperature_high = this->normal_config_.default_temperature_high;
-    } else
-      this->target_temperature = this->normal_config_.default_temperature;
-  } else {
-    if (this->supports_two_points_) {
-      this->target_temperature_low = this->away_config_.default_temperature_low;
-      this->target_temperature_high = this->away_config_.default_temperature_high;
-    } else
-      this->target_temperature = this->away_config_.default_temperature;
+      ESP_LOGCONFIG(TAG, "      %s Default Target Temperature Low: %.1f°C", preset_name,
+                    config.default_temperature_low);
+    } else {
+      ESP_LOGCONFIG(TAG, "      %s Default Target Temperature Low: %.1f°C", preset_name, config.default_temperature);
+    }
+  }
+  if ((this->supports_cool_) || (this->supports_fan_only_)) {
+    if (this->supports_two_points_) {
+      ESP_LOGCONFIG(TAG, "      %s Default Target Temperature High: %.1f°C", preset_name,
+                    config.default_temperature_high);
+    } else {
+      ESP_LOGCONFIG(TAG, "      %s Default Target Temperature High: %.1f°C", preset_name, config.default_temperature);
+    }
+  }
+
+  if (config.mode_.has_value()) {
+    ESP_LOGCONFIG(TAG, "      %s Default Mode: %s", preset_name,
+                  LOG_STR_ARG(climate::climate_mode_to_string(*config.mode_)));
+  }
+  if (config.fan_mode_.has_value()) {
+    ESP_LOGCONFIG(TAG, "      %s Default Fan Mode: %s", preset_name,
+                  LOG_STR_ARG(climate::climate_fan_mode_to_string(*config.fan_mode_)));
+  }
+  if (config.swing_mode_.has_value()) {
+    ESP_LOGCONFIG(TAG, "      %s Default Swing Mode: %s", preset_name,
+                  LOG_STR_ARG(climate::climate_swing_mode_to_string(*config.swing_mode_)));
   }
-  this->preset = away ? climate::CLIMATE_PRESET_AWAY : climate::CLIMATE_PRESET_HOME;
 }
 
-void ThermostatClimate::set_normal_config(const ThermostatClimateTargetTempConfig &normal_config) {
-  this->normal_config_ = normal_config;
+void ThermostatClimate::change_preset_(climate::ClimatePreset preset) {
+  auto config = this->preset_config_.find(preset);
+
+  if (config != this->preset_config_.end()) {
+    ESP_LOGI(TAG, "Switching to preset  %s", LOG_STR_ARG(climate::climate_preset_to_string(preset)));
+    this->change_preset_internal_(config->second);
+
+    this->custom_preset.reset();
+    this->preset = preset;
+  } else {
+    ESP_LOGE(TAG, "Preset %s is not configured, ignoring.", LOG_STR_ARG(climate::climate_preset_to_string(preset)));
+  }
 }
 
-void ThermostatClimate::set_away_config(const ThermostatClimateTargetTempConfig &away_config) {
-  this->supports_away_ = true;
-  this->away_config_ = away_config;
+void ThermostatClimate::change_custom_preset_(const std::string &custom_preset) {
+  auto config = this->custom_preset_config_.find(custom_preset);
+
+  if (config != this->custom_preset_config_.end()) {
+    ESP_LOGI(TAG, "Switching to custom preset  %s", custom_preset.c_str());
+    this->change_preset_internal_(config->second);
+
+    this->preset.reset();
+    this->custom_preset = custom_preset;
+  } else {
+    ESP_LOGE(TAG, "Custom Preset %s is not configured, ignoring.", custom_preset.c_str());
+  }
+}
+
+void ThermostatClimate::change_preset_internal_(const ThermostatClimateTargetTempConfig &config) {
+  if (this->supports_two_points_) {
+    this->target_temperature_low = config.default_temperature_low;
+    this->target_temperature_high = config.default_temperature_high;
+  } else {
+    this->target_temperature = config.default_temperature;
+  }
+
+  // Note: The mode, fan_mode, and swing_mode can all be defined on the preset but if the climate.control call
+  // also specifies them then the control's version will override these for that call
+  if (config.mode_.has_value()) {
+    this->mode = *config.mode_;
+    ESP_LOGV(TAG, "Setting mode to %s", LOG_STR_ARG(climate::climate_mode_to_string(*config.mode_)));
+  }
+
+  if (config.fan_mode_.has_value()) {
+    this->fan_mode = *config.fan_mode_;
+    ESP_LOGV(TAG, "Setting fan mode to %s", LOG_STR_ARG(climate::climate_fan_mode_to_string(*config.fan_mode_)));
+  }
+
+  if (config.swing_mode_.has_value()) {
+    ESP_LOGV(TAG, "Setting swing mode to %s", LOG_STR_ARG(climate::climate_swing_mode_to_string(*config.swing_mode_)));
+    this->swing_mode = *config.swing_mode_;
+  }
+
+  // Fire any preset changed trigger if defined
+  if (this->preset != preset) {
+    Trigger<> *trig = this->preset_change_trigger_;
+    assert(trig != nullptr);
+    trig->trigger();
+  }
+
+  this->refresh();
+}
+
+void ThermostatClimate::set_preset_config(climate::ClimatePreset preset,
+                                          const ThermostatClimateTargetTempConfig &config) {
+  this->preset_config_[preset] = config;
+}
+
+void ThermostatClimate::set_custom_preset_config(const std::string &name,
+                                                 const ThermostatClimateTargetTempConfig &config) {
+  this->custom_preset_config_[name] = config;
 }
 
 ThermostatClimate::ThermostatClimate()
@@ -963,7 +1058,8 @@ ThermostatClimate::ThermostatClimate()
       swing_mode_off_trigger_(new Trigger<>()),
       swing_mode_horizontal_trigger_(new Trigger<>()),
       swing_mode_vertical_trigger_(new Trigger<>()),
-      temperature_change_trigger_(new Trigger<>()) {}
+      temperature_change_trigger_(new Trigger<>()),
+      preset_change_trigger_(new Trigger<>()) {}
 
 void ThermostatClimate::set_default_mode(climate::ClimateMode default_mode) { this->default_mode_ = default_mode; }
 void ThermostatClimate::set_set_point_minimum_differential(float differential) {
@@ -1112,23 +1208,11 @@ Trigger<> *ThermostatClimate::get_swing_mode_off_trigger() const { return this->
 Trigger<> *ThermostatClimate::get_swing_mode_horizontal_trigger() const { return this->swing_mode_horizontal_trigger_; }
 Trigger<> *ThermostatClimate::get_swing_mode_vertical_trigger() const { return this->swing_mode_vertical_trigger_; }
 Trigger<> *ThermostatClimate::get_temperature_change_trigger() const { return this->temperature_change_trigger_; }
+Trigger<> *ThermostatClimate::get_preset_change_trigger() const { return this->preset_change_trigger_; }
 
 void ThermostatClimate::dump_config() {
   LOG_CLIMATE("", "Thermostat", this);
-  if (this->supports_heat_) {
-    if (this->supports_two_points_) {
-      ESP_LOGCONFIG(TAG, "  Default Target Temperature Low: %.1f°C", this->normal_config_.default_temperature_low);
-    } else {
-      ESP_LOGCONFIG(TAG, "  Default Target Temperature Low: %.1f°C", this->normal_config_.default_temperature);
-    }
-  }
-  if ((this->supports_cool_) || (this->supports_fan_only_ && this->supports_fan_only_cooling_)) {
-    if (this->supports_two_points_) {
-      ESP_LOGCONFIG(TAG, "  Default Target Temperature High: %.1f°C", this->normal_config_.default_temperature_high);
-    } else {
-      ESP_LOGCONFIG(TAG, "  Default Target Temperature High: %.1f°C", this->normal_config_.default_temperature);
-    }
-  }
+
   if (this->supports_two_points_)
     ESP_LOGCONFIG(TAG, "  Minimum Set Point Differential: %.1f°C", this->set_point_minimum_differential_);
   ESP_LOGCONFIG(TAG, "  Start-up Delay Enabled: %s", YESNO(this->use_startup_delay_));
@@ -1194,24 +1278,21 @@ void ThermostatClimate::dump_config() {
   ESP_LOGCONFIG(TAG, "  Supports SWING MODE HORIZONTAL: %s", YESNO(this->supports_swing_mode_horizontal_));
   ESP_LOGCONFIG(TAG, "  Supports SWING MODE VERTICAL: %s", YESNO(this->supports_swing_mode_vertical_));
   ESP_LOGCONFIG(TAG, "  Supports TWO SET POINTS: %s", YESNO(this->supports_two_points_));
-  ESP_LOGCONFIG(TAG, "  Supports AWAY mode: %s", YESNO(this->supports_away_));
-  if (this->supports_away_) {
-    if (this->supports_heat_) {
-      if (this->supports_two_points_) {
-        ESP_LOGCONFIG(TAG, "    Away Default Target Temperature Low: %.1f°C",
-                      this->away_config_.default_temperature_low);
-      } else {
-        ESP_LOGCONFIG(TAG, "    Away Default Target Temperature Low: %.1f°C", this->away_config_.default_temperature);
-      }
-    }
-    if ((this->supports_cool_) || (this->supports_fan_only_)) {
-      if (this->supports_two_points_) {
-        ESP_LOGCONFIG(TAG, "    Away Default Target Temperature High: %.1f°C",
-                      this->away_config_.default_temperature_high);
-      } else {
-        ESP_LOGCONFIG(TAG, "    Away Default Target Temperature High: %.1f°C", this->away_config_.default_temperature);
-      }
-    }
+
+  ESP_LOGCONFIG(TAG, "  Supported PRESETS: ");
+  for (auto &it : this->preset_config_) {
+    const auto *preset_name = LOG_STR_ARG(climate::climate_preset_to_string(it.first));
+
+    ESP_LOGCONFIG(TAG, "    Supports %s: %s", preset_name, YESNO(true));
+    this->dump_preset_config_(preset_name, it.second);
+  }
+
+  ESP_LOGCONFIG(TAG, "  Supported CUSTOM PRESETS: ");
+  for (auto &it : this->custom_preset_config_) {
+    const auto *preset_name = it.first.c_str();
+
+    ESP_LOGCONFIG(TAG, "    Supports %s: %s", preset_name, YESNO(true));
+    this->dump_preset_config_(preset_name, it.second);
   }
 }
 
diff --git a/esphome/components/thermostat/thermostat_climate.h b/esphome/components/thermostat/thermostat_climate.h
index 8d3e926752..c9231370ba 100644
--- a/esphome/components/thermostat/thermostat_climate.h
+++ b/esphome/components/thermostat/thermostat_climate.h
@@ -4,6 +4,7 @@
 #include "esphome/core/automation.h"
 #include "esphome/components/climate/climate.h"
 #include "esphome/components/sensor/sensor.h"
+#include <map>
 
 namespace esphome {
 namespace thermostat {
@@ -34,6 +35,10 @@ struct ThermostatClimateTargetTempConfig {
   ThermostatClimateTargetTempConfig(float default_temperature);
   ThermostatClimateTargetTempConfig(float default_temperature_low, float default_temperature_high);
 
+  void set_fan_mode(climate::ClimateFanMode fan_mode) { this->fan_mode_ = fan_mode; }
+  void set_swing_mode(climate::ClimateSwingMode swing_mode) { this->swing_mode_ = swing_mode; }
+  void set_mode(climate::ClimateMode mode) { this->mode_ = mode; }
+
   float default_temperature{NAN};
   float default_temperature_low{NAN};
   float default_temperature_high{NAN};
@@ -41,6 +46,9 @@ struct ThermostatClimateTargetTempConfig {
   float cool_overrun_{NAN};
   float heat_deadband_{NAN};
   float heat_overrun_{NAN};
+  optional<climate::ClimateFanMode> fan_mode_{};
+  optional<climate::ClimateSwingMode> swing_mode_{};
+  optional<climate::ClimateMode> mode_{};
 };
 
 class ThermostatClimate : public climate::Climate, public Component {
@@ -94,8 +102,8 @@ class ThermostatClimate : public climate::Climate, public Component {
   void set_supports_swing_mode_vertical(bool supports_swing_mode_vertical);
   void set_supports_two_points(bool supports_two_points);
 
-  void set_normal_config(const ThermostatClimateTargetTempConfig &normal_config);
-  void set_away_config(const ThermostatClimateTargetTempConfig &away_config);
+  void set_preset_config(climate::ClimatePreset preset, const ThermostatClimateTargetTempConfig &config);
+  void set_custom_preset_config(const std::string &name, const ThermostatClimateTargetTempConfig &config);
 
   Trigger<> *get_cool_action_trigger() const;
   Trigger<> *get_supplemental_cool_action_trigger() const;
@@ -124,6 +132,7 @@ class ThermostatClimate : public climate::Climate, public Component {
   Trigger<> *get_swing_mode_off_trigger() const;
   Trigger<> *get_swing_mode_vertical_trigger() const;
   Trigger<> *get_temperature_change_trigger() const;
+  Trigger<> *get_preset_change_trigger() const;
   /// Get current hysteresis values
   float cool_deadband();
   float cool_overrun();
@@ -149,8 +158,14 @@ class ThermostatClimate : public climate::Climate, public Component {
   /// Override control to change settings of the climate device.
   void control(const climate::ClimateCall &call) override;
 
-  /// Change the away setting, will reset target temperatures to defaults.
-  void change_away_(bool away);
+  /// Change to a provided preset setting; will reset temperature, mode, fan, and swing modes accordingly
+  void change_preset_(climate::ClimatePreset preset);
+  /// Change to a provided custom preset setting; will reset temperature, mode, fan, and swing modes accordingly
+  void change_custom_preset_(const std::string &custom_preset);
+
+  /// Applies the temperature, mode, fan, and swing modes of the provded config.
+  /// This is agnostic of custom vs built in preset
+  void change_preset_internal_(const ThermostatClimateTargetTempConfig &config);
 
   /// Return the traits of this controller.
   climate::ClimateTraits traits() override;
@@ -210,6 +225,8 @@ class ThermostatClimate : public climate::Climate, public Component {
   bool supplemental_cooling_required_();
   bool supplemental_heating_required_();
 
+  void dump_preset_config_(const std::string &preset_name, const ThermostatClimateTargetTempConfig &config);
+
   /// The sensor used for getting the current temperature
   sensor::Sensor *sensor_{nullptr};
 
@@ -267,11 +284,6 @@ class ThermostatClimate : public climate::Climate, public Component {
   /// A false value means that the controller has no such support.
   bool supports_two_points_{false};
 
-  /// Whether the controller supports an "away" mode
-  ///
-  /// A false value means that the controller has no such mode.
-  bool supports_away_{false};
-
   /// Flags indicating if maximum allowable run time was exceeded
   bool cooling_max_runtime_exceeded_{false};
   bool heating_max_runtime_exceeded_{false};
@@ -368,6 +380,9 @@ class ThermostatClimate : public climate::Climate, public Component {
   /// The trigger to call when the target temperature(s) change(es).
   Trigger<> *temperature_change_trigger_{nullptr};
 
+  /// The triggr to call when the preset mode changes
+  Trigger<> *preset_change_trigger_{nullptr};
+
   /// A reference to the trigger that was previously active.
   ///
   /// This is so that the previous trigger can be stopped before enabling a new one
@@ -409,10 +424,6 @@ class ThermostatClimate : public climate::Climate, public Component {
   /// Minimum allowable duration in seconds for action timers
   const uint8_t min_timer_duration_{1};
 
-  /// Temperature data for normal/home and away modes
-  ThermostatClimateTargetTempConfig normal_config_{};
-  ThermostatClimateTargetTempConfig away_config_{};
-
   /// Climate action timers
   std::vector<ThermostatClimateTimer> timer_{
       {"cool_run", false, 0, std::bind(&ThermostatClimate::cooling_max_run_time_timer_callback_, this)},
@@ -425,6 +436,11 @@ class ThermostatClimate : public climate::Climate, public Component {
       {"heat_off", false, 0, std::bind(&ThermostatClimate::heating_off_timer_callback_, this)},
       {"heat_on", false, 0, std::bind(&ThermostatClimate::heating_on_timer_callback_, this)},
       {"idle_on", false, 0, std::bind(&ThermostatClimate::idle_on_timer_callback_, this)}};
+
+  /// The set of standard preset configurations this thermostat supports (Eg. AWAY, ECO, etc)
+  std::map<climate::ClimatePreset, ThermostatClimateTargetTempConfig> preset_config_{};
+  /// The set of custom preset configurations this thermostat supports (eg. "My Custom Preset")
+  std::map<std::string, ThermostatClimateTargetTempConfig> custom_preset_config_{};
 };
 
 }  // namespace thermostat

From d2cefbf22495b3c62956a455c6bbc63daf40c96b Mon Sep 17 00:00:00 2001
From: Jan Grewe <jan@faked.org>
Date: Mon, 30 May 2022 21:29:57 +0200
Subject: [PATCH 31/60] Allow Prometheus component to export internal
 components (#3508)

Co-authored-by: Jan Grewe <jan.grewe@flixbus.com>
---
 esphome/components/prometheus/__init__.py          |  8 +++++++-
 .../components/prometheus/prometheus_handler.cpp   | 14 +++++++-------
 esphome/components/prometheus/prometheus_handler.h |  8 ++++++++
 3 files changed, 22 insertions(+), 8 deletions(-)

diff --git a/esphome/components/prometheus/__init__.py b/esphome/components/prometheus/__init__.py
index 45345f06e8..e7c0459251 100644
--- a/esphome/components/prometheus/__init__.py
+++ b/esphome/components/prometheus/__init__.py
@@ -1,6 +1,9 @@
 import esphome.config_validation as cv
 import esphome.codegen as cg
-from esphome.const import CONF_ID
+from esphome.const import (
+    CONF_ID,
+    CONF_INCLUDE_INTERNAL,
+)
 from esphome.components.web_server_base import CONF_WEB_SERVER_BASE_ID
 from esphome.components import web_server_base
 
@@ -15,6 +18,7 @@ CONFIG_SCHEMA = cv.Schema(
         cv.GenerateID(CONF_WEB_SERVER_BASE_ID): cv.use_id(
             web_server_base.WebServerBase
         ),
+        cv.Optional(CONF_INCLUDE_INTERNAL, default=False): cv.boolean,
     },
     cv.only_with_arduino,
 ).extend(cv.COMPONENT_SCHEMA)
@@ -27,3 +31,5 @@ async def to_code(config):
 
     var = cg.new_Pvariable(config[CONF_ID], paren)
     await cg.register_component(var, config)
+
+    cg.add(var.set_include_internal(config[CONF_INCLUDE_INTERNAL]))
diff --git a/esphome/components/prometheus/prometheus_handler.cpp b/esphome/components/prometheus/prometheus_handler.cpp
index e4dd6b9043..a52347ba57 100644
--- a/esphome/components/prometheus/prometheus_handler.cpp
+++ b/esphome/components/prometheus/prometheus_handler.cpp
@@ -61,7 +61,7 @@ void PrometheusHandler::sensor_type_(AsyncResponseStream *stream) {
   stream->print(F("#TYPE esphome_sensor_failed GAUGE\n"));
 }
 void PrometheusHandler::sensor_row_(AsyncResponseStream *stream, sensor::Sensor *obj) {
-  if (obj->is_internal())
+  if (obj->is_internal() && !this->include_internal_)
     return;
   if (!std::isnan(obj->state)) {
     // We have a valid value, output this value
@@ -98,7 +98,7 @@ void PrometheusHandler::binary_sensor_type_(AsyncResponseStream *stream) {
   stream->print(F("#TYPE esphome_binary_sensor_failed GAUGE\n"));
 }
 void PrometheusHandler::binary_sensor_row_(AsyncResponseStream *stream, binary_sensor::BinarySensor *obj) {
-  if (obj->is_internal())
+  if (obj->is_internal() && !this->include_internal_)
     return;
   if (obj->has_state()) {
     // We have a valid value, output this value
@@ -134,7 +134,7 @@ void PrometheusHandler::fan_type_(AsyncResponseStream *stream) {
   stream->print(F("#TYPE esphome_fan_oscillation GAUGE\n"));
 }
 void PrometheusHandler::fan_row_(AsyncResponseStream *stream, fan::Fan *obj) {
-  if (obj->is_internal())
+  if (obj->is_internal() && !this->include_internal_)
     return;
   stream->print(F("esphome_fan_failed{id=\""));
   stream->print(obj->get_object_id().c_str());
@@ -179,7 +179,7 @@ void PrometheusHandler::light_type_(AsyncResponseStream *stream) {
   stream->print(F("#TYPE esphome_light_effect_active GAUGE\n"));
 }
 void PrometheusHandler::light_row_(AsyncResponseStream *stream, light::LightState *obj) {
-  if (obj->is_internal())
+  if (obj->is_internal() && !this->include_internal_)
     return;
   // State
   stream->print(F("esphome_light_state{id=\""));
@@ -255,7 +255,7 @@ void PrometheusHandler::cover_type_(AsyncResponseStream *stream) {
   stream->print(F("#TYPE esphome_cover_failed GAUGE\n"));
 }
 void PrometheusHandler::cover_row_(AsyncResponseStream *stream, cover::Cover *obj) {
-  if (obj->is_internal())
+  if (obj->is_internal() && !this->include_internal_)
     return;
   if (!std::isnan(obj->position)) {
     // We have a valid value, output this value
@@ -298,7 +298,7 @@ void PrometheusHandler::switch_type_(AsyncResponseStream *stream) {
   stream->print(F("#TYPE esphome_switch_failed GAUGE\n"));
 }
 void PrometheusHandler::switch_row_(AsyncResponseStream *stream, switch_::Switch *obj) {
-  if (obj->is_internal())
+  if (obj->is_internal() && !this->include_internal_)
     return;
   stream->print(F("esphome_switch_failed{id=\""));
   stream->print(obj->get_object_id().c_str());
@@ -322,7 +322,7 @@ void PrometheusHandler::lock_type_(AsyncResponseStream *stream) {
   stream->print(F("#TYPE esphome_lock_failed GAUGE\n"));
 }
 void PrometheusHandler::lock_row_(AsyncResponseStream *stream, lock::Lock *obj) {
-  if (obj->is_internal())
+  if (obj->is_internal() && !this->include_internal_)
     return;
   stream->print(F("esphome_lock_failed{id=\""));
   stream->print(obj->get_object_id().c_str());
diff --git a/esphome/components/prometheus/prometheus_handler.h b/esphome/components/prometheus/prometheus_handler.h
index 5c8d51c60f..b378e46ea3 100644
--- a/esphome/components/prometheus/prometheus_handler.h
+++ b/esphome/components/prometheus/prometheus_handler.h
@@ -13,6 +13,13 @@ class PrometheusHandler : public AsyncWebHandler, public Component {
  public:
   PrometheusHandler(web_server_base::WebServerBase *base) : base_(base) {}
 
+  /** Determine whether internal components should be exported as metrics.
+   * Defaults to false.
+   *
+   * @param include_internal Whether internal components should be exported.
+   */
+  void set_include_internal(bool include_internal) { include_internal_ = include_internal; }
+
   bool canHandle(AsyncWebServerRequest *request) override {
     if (request->method() == HTTP_GET) {
       if (request->url() == "/metrics")
@@ -84,6 +91,7 @@ class PrometheusHandler : public AsyncWebHandler, public Component {
 #endif
 
   web_server_base::WebServerBase *base_;
+  bool include_internal_{false};
 };
 
 }  // namespace prometheus

From 708672ec7e18745ca76be2afffb05ca320986568 Mon Sep 17 00:00:00 2001
From: Joe <jhansche@themeetgroup.com>
Date: Mon, 30 May 2022 23:45:01 -0400
Subject: [PATCH 32/60] [BedJet] Add configurable heating strategy (#3519)

Co-authored-by: Jesse Hills <3060199+jesserockz@users.noreply.github.com>
---
 esphome/components/bedjet/bedjet.cpp     | 28 ++++++++++++++++++++++--
 esphome/components/bedjet/bedjet.h       | 10 +++++++--
 esphome/components/bedjet/bedjet_const.h |  8 +++++++
 esphome/components/bedjet/climate.py     | 10 +++++++++
 tests/test1.yaml                         |  1 +
 5 files changed, 53 insertions(+), 4 deletions(-)

diff --git a/esphome/components/bedjet/bedjet.cpp b/esphome/components/bedjet/bedjet.cpp
index 38ed6206a8..493685448c 100644
--- a/esphome/components/bedjet/bedjet.cpp
+++ b/esphome/components/bedjet/bedjet.cpp
@@ -36,6 +36,14 @@ static uint8_t bedjet_fan_speed_to_step(const std::string &fan_step_percent) {
   return -1;
 }
 
+static BedjetButton heat_button(BedjetHeatMode mode) {
+  BedjetButton btn = BTN_HEAT;
+  if (mode == HEAT_MODE_EXTENDED) {
+    btn = BTN_EXTHT;
+  }
+  return btn;
+}
+
 void Bedjet::upgrade_firmware() {
   auto *pkt = this->codec_->get_button_request(MAGIC_UPDATE);
   auto status = this->write_bedjet_packet_(pkt);
@@ -117,7 +125,7 @@ void Bedjet::control(const ClimateCall &call) {
         pkt = this->codec_->get_button_request(BTN_OFF);
         break;
       case climate::CLIMATE_MODE_HEAT:
-        pkt = this->codec_->get_button_request(BTN_HEAT);
+        pkt = this->codec_->get_button_request(heat_button(this->heating_mode_));
         break;
       case climate::CLIMATE_MODE_FAN_ONLY:
         pkt = this->codec_->get_button_request(BTN_COOL);
@@ -186,6 +194,8 @@ void Bedjet::control(const ClimateCall &call) {
       pkt = this->codec_->get_button_request(BTN_M2);
     } else if (preset == "M3") {
       pkt = this->codec_->get_button_request(BTN_M3);
+    } else if (preset == "LTD HT") {
+      pkt = this->codec_->get_button_request(BTN_HEAT);
     } else if (preset == "EXT HT") {
       pkt = this->codec_->get_button_request(BTN_EXTHT);
     } else {
@@ -557,11 +567,25 @@ bool Bedjet::update_status_() {
       break;
 
     case MODE_HEAT:
+      this->mode = climate::CLIMATE_MODE_HEAT;
+      this->action = climate::CLIMATE_ACTION_HEATING;
+      this->preset.reset();
+      if (this->heating_mode_ == HEAT_MODE_EXTENDED) {
+        this->set_custom_preset_("LTD HT");
+      } else {
+        this->custom_preset.reset();
+      }
+      break;
+
     case MODE_EXTHT:
       this->mode = climate::CLIMATE_MODE_HEAT;
       this->action = climate::CLIMATE_ACTION_HEATING;
-      this->custom_preset.reset();
       this->preset.reset();
+      if (this->heating_mode_ == HEAT_MODE_EXTENDED) {
+        this->custom_preset.reset();
+      } else {
+        this->set_custom_preset_("EXT HT");
+      }
       break;
 
     case MODE_COOL:
diff --git a/esphome/components/bedjet/bedjet.h b/esphome/components/bedjet/bedjet.h
index 750a20594f..5d66f6f252 100644
--- a/esphome/components/bedjet/bedjet.h
+++ b/esphome/components/bedjet/bedjet.h
@@ -40,6 +40,8 @@ class Bedjet : public climate::Climate, public esphome::ble_client::BLEClientNod
   void set_time_id(time::RealTimeClock *time_id) { this->time_id_ = time_id; }
 #endif
   void set_status_timeout(uint32_t timeout) { this->timeout_ = timeout; }
+  /** Sets the default strategy to use for climate::CLIMATE_MODE_HEAT. */
+  void set_heating_mode(BedjetHeatMode mode) { this->heating_mode_ = mode; }
 
   /** Attempts to check for and apply firmware updates. */
   void upgrade_firmware();
@@ -68,12 +70,15 @@ class Bedjet : public climate::Climate, public esphome::ble_client::BLEClientNod
         // We could fetch biodata from bedjet and set these names that way.
         // But then we have to invert the lookup in order to send the right preset.
         // For now, we can leave them as M1-3 to match the remote buttons.
-        // EXT HT added to match remote button.
-        "EXT HT",
         "M1",
         "M2",
         "M3",
     });
+    if (this->heating_mode_ == HEAT_MODE_EXTENDED) {
+      traits.add_supported_custom_preset("LTD HT");
+    } else {
+      traits.add_supported_custom_preset("EXT HT");
+    }
     traits.set_visual_min_temperature(19.0);
     traits.set_visual_max_temperature(43.0);
     traits.set_visual_temperature_step(1.0);
@@ -90,6 +95,7 @@ class Bedjet : public climate::Climate, public esphome::ble_client::BLEClientNod
 #endif
 
   uint32_t timeout_{DEFAULT_STATUS_TIMEOUT};
+  BedjetHeatMode heating_mode_ = HEAT_MODE_HEAT;
 
   static const uint32_t MIN_NOTIFY_THROTTLE = 5000;
   static const uint32_t NOTIFY_WARN_THRESHOLD = 300000;
diff --git a/esphome/components/bedjet/bedjet_const.h b/esphome/components/bedjet/bedjet_const.h
index ae10ca1885..16f73717c6 100644
--- a/esphome/components/bedjet/bedjet_const.h
+++ b/esphome/components/bedjet/bedjet_const.h
@@ -24,6 +24,14 @@ enum BedjetMode : uint8_t {
   MODE_WAIT = 6,
 };
 
+/** Optional heating strategies to use for climate::CLIMATE_MODE_HEAT. */
+enum BedjetHeatMode {
+  /// HVACMode.HEAT is handled using BTN_HEAT (default)
+  HEAT_MODE_HEAT,
+  /// HVACMode.HEAT is handled using BTN_EXTHT
+  HEAT_MODE_EXTENDED,
+};
+
 enum BedjetButton : uint8_t {
   /// Turn BedJet off
   BTN_OFF = 0x1,
diff --git a/esphome/components/bedjet/climate.py b/esphome/components/bedjet/climate.py
index 49353934f6..d718ba9969 100644
--- a/esphome/components/bedjet/climate.py
+++ b/esphome/components/bedjet/climate.py
@@ -2,6 +2,7 @@ import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.components import climate, ble_client, time
 from esphome.const import (
+    CONF_HEAT_MODE,
     CONF_ID,
     CONF_RECEIVE_TIMEOUT,
     CONF_TIME_ID,
@@ -14,11 +15,19 @@ bedjet_ns = cg.esphome_ns.namespace("bedjet")
 Bedjet = bedjet_ns.class_(
     "Bedjet", climate.Climate, ble_client.BLEClientNode, cg.PollingComponent
 )
+BedjetHeatMode = bedjet_ns.enum("BedjetHeatMode")
+BEDJET_HEAT_MODES = {
+    "heat": BedjetHeatMode.HEAT_MODE_HEAT,
+    "extended": BedjetHeatMode.HEAT_MODE_EXTENDED,
+}
 
 CONFIG_SCHEMA = (
     climate.CLIMATE_SCHEMA.extend(
         {
             cv.GenerateID(): cv.declare_id(Bedjet),
+            cv.Optional(CONF_HEAT_MODE, default="heat"): cv.enum(
+                BEDJET_HEAT_MODES, lower=True
+            ),
             cv.Optional(CONF_TIME_ID): cv.use_id(time.RealTimeClock),
             cv.Optional(
                 CONF_RECEIVE_TIMEOUT, default="0s"
@@ -35,6 +44,7 @@ async def to_code(config):
     await cg.register_component(var, config)
     await climate.register_climate(var, config)
     await ble_client.register_ble_node(var, config)
+    cg.add(var.set_heating_mode(config[CONF_HEAT_MODE]))
     if CONF_TIME_ID in config:
         time_ = await cg.get_variable(config[CONF_TIME_ID])
         cg.add(var.set_time_id(time_))
diff --git a/tests/test1.yaml b/tests/test1.yaml
index 52aa03c371..1b8ed7e370 100644
--- a/tests/test1.yaml
+++ b/tests/test1.yaml
@@ -1886,6 +1886,7 @@ climate:
   - platform: bedjet
     name: My Bedjet
     ble_client_id: my_bedjet_ble_client
+    heat_mode: extended
 
 script:
   - id: climate_custom

From 5aa42e5e66a5a65528e3dd6218e17b59970dfc82 Mon Sep 17 00:00:00 2001
From: jimtng <2554958+jimtng@users.noreply.github.com>
Date: Tue, 31 May 2022 14:45:18 +1000
Subject: [PATCH 33/60] Add variable substitutions for !include (#3510)

---
 esphome/components/substitutions/__init__.py  | 33 +++++++-------
 esphome/yaml_util.py                          | 44 ++++++++++++++++++-
 .../fixtures/yaml_util/includes/included.yaml |  2 +
 .../fixtures/yaml_util/includes/list.yaml     |  2 +
 .../fixtures/yaml_util/includes/scalar.yaml   |  1 +
 .../fixtures/yaml_util/includetest.yaml       | 17 +++++++
 tests/unit_tests/test_yaml_util.py            | 13 ++++++
 7 files changed, 95 insertions(+), 17 deletions(-)
 create mode 100644 tests/unit_tests/fixtures/yaml_util/includes/included.yaml
 create mode 100644 tests/unit_tests/fixtures/yaml_util/includes/list.yaml
 create mode 100644 tests/unit_tests/fixtures/yaml_util/includes/scalar.yaml
 create mode 100644 tests/unit_tests/fixtures/yaml_util/includetest.yaml
 create mode 100644 tests/unit_tests/test_yaml_util.py

diff --git a/esphome/components/substitutions/__init__.py b/esphome/components/substitutions/__init__.py
index 6188b14b35..5a3da1abbe 100644
--- a/esphome/components/substitutions/__init__.py
+++ b/esphome/components/substitutions/__init__.py
@@ -48,7 +48,7 @@ VARIABLE_PROG = re.compile(
 )
 
 
-def _expand_substitutions(substitutions, value, path):
+def _expand_substitutions(substitutions, value, path, ignore_missing):
     if "$" not in value:
         return value
 
@@ -66,13 +66,14 @@ def _expand_substitutions(substitutions, value, path):
         if name.startswith("{") and name.endswith("}"):
             name = name[1:-1]
         if name not in substitutions:
-            _LOGGER.warning(
-                "Found '%s' (see %s) which looks like a substitution, but '%s' was "
-                "not declared",
-                orig_value,
-                "->".join(str(x) for x in path),
-                name,
-            )
+            if not ignore_missing:
+                _LOGGER.warning(
+                    "Found '%s' (see %s) which looks like a substitution, but '%s' was "
+                    "not declared",
+                    orig_value,
+                    "->".join(str(x) for x in path),
+                    name,
+                )
             i = j
             continue
 
@@ -92,37 +93,37 @@ def _expand_substitutions(substitutions, value, path):
     return value
 
 
-def _substitute_item(substitutions, item, path):
+def _substitute_item(substitutions, item, path, ignore_missing):
     if isinstance(item, list):
         for i, it in enumerate(item):
-            sub = _substitute_item(substitutions, it, path + [i])
+            sub = _substitute_item(substitutions, it, path + [i], ignore_missing)
             if sub is not None:
                 item[i] = sub
     elif isinstance(item, dict):
         replace_keys = []
         for k, v in item.items():
             if path or k != CONF_SUBSTITUTIONS:
-                sub = _substitute_item(substitutions, k, path + [k])
+                sub = _substitute_item(substitutions, k, path + [k], ignore_missing)
                 if sub is not None:
                     replace_keys.append((k, sub))
-            sub = _substitute_item(substitutions, v, path + [k])
+            sub = _substitute_item(substitutions, v, path + [k], ignore_missing)
             if sub is not None:
                 item[k] = sub
         for old, new in replace_keys:
             item[new] = merge_config(item.get(old), item.get(new))
             del item[old]
     elif isinstance(item, str):
-        sub = _expand_substitutions(substitutions, item, path)
+        sub = _expand_substitutions(substitutions, item, path, ignore_missing)
         if sub != item:
             return sub
     elif isinstance(item, core.Lambda):
-        sub = _expand_substitutions(substitutions, item.value, path)
+        sub = _expand_substitutions(substitutions, item.value, path, ignore_missing)
         if sub != item:
             item.value = sub
     return None
 
 
-def do_substitution_pass(config, command_line_substitutions):
+def do_substitution_pass(config, command_line_substitutions, ignore_missing=False):
     if CONF_SUBSTITUTIONS not in config and not command_line_substitutions:
         return
 
@@ -151,4 +152,4 @@ def do_substitution_pass(config, command_line_substitutions):
     config[CONF_SUBSTITUTIONS] = substitutions
     # Move substitutions to the first place to replace substitutions in them correctly
     config.move_to_end(CONF_SUBSTITUTIONS, False)
-    _substitute_item(substitutions, config, [])
+    _substitute_item(substitutions, config, [], ignore_missing)
diff --git a/esphome/yaml_util.py b/esphome/yaml_util.py
index 57009be57e..75aec0edc8 100644
--- a/esphome/yaml_util.py
+++ b/esphome/yaml_util.py
@@ -251,7 +251,49 @@ class ESPHomeLoader(yaml.SafeLoader):  # pylint: disable=too-many-ancestors
 
     @_add_data_ref
     def construct_include(self, node):
-        return _load_yaml_internal(self._rel_path(node.value))
+        def extract_file_vars(node):
+            fields = self.construct_yaml_map(node)
+            file = fields.get("file")
+            if file is None:
+                raise yaml.MarkedYAMLError("Must include 'file'", node.start_mark)
+            vars = fields.get("vars")
+            if vars:
+                vars = {k: str(v) for k, v in vars.items()}
+            return file, vars
+
+        def substitute_vars(config, vars):
+            from esphome.const import CONF_SUBSTITUTIONS
+            from esphome.components import substitutions
+
+            org_subs = None
+            result = config
+            if not isinstance(config, dict):
+                # when the included yaml contains a list or a scalar
+                # wrap it into an OrderedDict because do_substitution_pass expects it
+                result = OrderedDict([("yaml", config)])
+            elif CONF_SUBSTITUTIONS in result:
+                org_subs = result.pop(CONF_SUBSTITUTIONS)
+
+            result[CONF_SUBSTITUTIONS] = vars
+            # Ignore missing vars that refer to the top level substitutions
+            substitutions.do_substitution_pass(result, None, ignore_missing=True)
+            result.pop(CONF_SUBSTITUTIONS)
+
+            if not isinstance(config, dict):
+                result = result["yaml"]  # unwrap the result
+            elif org_subs:
+                result[CONF_SUBSTITUTIONS] = org_subs
+            return result
+
+        if isinstance(node, yaml.nodes.MappingNode):
+            file, vars = extract_file_vars(node)
+        else:
+            file, vars = node.value, None
+
+        result = _load_yaml_internal(self._rel_path(file))
+        if vars:
+            result = substitute_vars(result, vars)
+        return result
 
     @_add_data_ref
     def construct_include_dir_list(self, node):
diff --git a/tests/unit_tests/fixtures/yaml_util/includes/included.yaml b/tests/unit_tests/fixtures/yaml_util/includes/included.yaml
new file mode 100644
index 0000000000..e9fca324a3
--- /dev/null
+++ b/tests/unit_tests/fixtures/yaml_util/includes/included.yaml
@@ -0,0 +1,2 @@
+---
+ssid: ${name}
diff --git a/tests/unit_tests/fixtures/yaml_util/includes/list.yaml b/tests/unit_tests/fixtures/yaml_util/includes/list.yaml
new file mode 100644
index 0000000000..2fb3838631
--- /dev/null
+++ b/tests/unit_tests/fixtures/yaml_util/includes/list.yaml
@@ -0,0 +1,2 @@
+---
+- ${var1}
diff --git a/tests/unit_tests/fixtures/yaml_util/includes/scalar.yaml b/tests/unit_tests/fixtures/yaml_util/includes/scalar.yaml
new file mode 100644
index 0000000000..ddd2156b5e
--- /dev/null
+++ b/tests/unit_tests/fixtures/yaml_util/includes/scalar.yaml
@@ -0,0 +1 @@
+${var1}
diff --git a/tests/unit_tests/fixtures/yaml_util/includetest.yaml b/tests/unit_tests/fixtures/yaml_util/includetest.yaml
new file mode 100644
index 0000000000..959283df60
--- /dev/null
+++ b/tests/unit_tests/fixtures/yaml_util/includetest.yaml
@@ -0,0 +1,17 @@
+---
+substitutions:
+  name: original
+
+wifi: !include
+  file: includes/included.yaml
+  vars:
+    name: my_custom_ssid
+
+esphome:
+  # should be substituted as 'original', not overwritten by vars in the !include above
+  name: ${name}
+  name_add_mac_suffix: true
+  platform: esp8266
+  board: !include { file: includes/scalar.yaml, vars: { var1: nodemcu } }
+
+  libraries: !include { file: includes/list.yaml, vars: { var1: Wire } }
diff --git a/tests/unit_tests/test_yaml_util.py b/tests/unit_tests/test_yaml_util.py
new file mode 100644
index 0000000000..8ee991f5b3
--- /dev/null
+++ b/tests/unit_tests/test_yaml_util.py
@@ -0,0 +1,13 @@
+from esphome import yaml_util
+from esphome.components import substitutions
+
+
+def test_include_with_vars(fixture_path):
+    yaml_file = fixture_path / "yaml_util" / "includetest.yaml"
+
+    actual = yaml_util.load_yaml(yaml_file)
+    substitutions.do_substitution_pass(actual, None)
+    assert actual["esphome"]["name"] == "original"
+    assert actual["esphome"]["libraries"][0] == "Wire"
+    assert actual["esphome"]["board"] == "nodemcu"
+    assert actual["wifi"]["ssid"] == "my_custom_ssid"

From a922efeafa9c46bd64fb9de7e88b05ea92de3d2c Mon Sep 17 00:00:00 2001
From: Wolfgang Tremmel <wtremmel@users.noreply.github.com>
Date: Tue, 31 May 2022 06:49:18 +0200
Subject: [PATCH 34/60] Change rain intensity sensor string (#3511)

---
 esphome/components/hydreon_rgxx/sensor.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/esphome/components/hydreon_rgxx/sensor.py b/esphome/components/hydreon_rgxx/sensor.py
index 409500305a..c604f8d3c1 100644
--- a/esphome/components/hydreon_rgxx/sensor.py
+++ b/esphome/components/hydreon_rgxx/sensor.py
@@ -37,7 +37,7 @@ SUPPORTED_SENSORS = {
 PROTOCOL_NAMES = {
     CONF_MOISTURE: "R",
     CONF_ACC: "Acc",
-    CONF_R_INT: "Rint",
+    CONF_R_INT: "RInt",
     CONF_EVENT_ACC: "EventAcc",
     CONF_TOTAL_ACC: "TotalAcc",
 }

From 6221f6d47d9522e62c1894bccb83c8cbc2bbb7f0 Mon Sep 17 00:00:00 2001
From: Jesse Hills <3060199+jesserockz@users.noreply.github.com>
Date: Thu, 2 Jun 2022 17:00:17 +1200
Subject: [PATCH 35/60] Implement Media Player and I2S Media player (#3487)

---
 CODEOWNERS                                    |   2 +
 esphome/components/api/api.proto              |  62 +++-
 esphome/components/api/api_connection.cpp     |  46 +++
 esphome/components/api/api_connection.h       |   5 +
 esphome/components/api/api_pb2.cpp            | 278 ++++++++++++++++++
 esphome/components/api/api_pb2.h              |  67 +++++
 esphome/components/api/api_pb2_service.cpp    |  42 +++
 esphome/components/api/api_pb2_service.h      |  15 +
 esphome/components/api/api_server.cpp         |   9 +
 esphome/components/api/api_server.h           |   3 +
 esphome/components/api/list_entities.cpp      |   6 +
 esphome/components/api/list_entities.h        |   3 +
 esphome/components/api/subscribe_state.cpp    |   5 +
 esphome/components/api/subscribe_state.h      |   3 +
 esphome/components/i2s_audio/__init__.py      |   0
 .../i2s_audio/i2s_audio_media_player.cpp      | 132 +++++++++
 .../i2s_audio/i2s_audio_media_player.h        |  63 ++++
 esphome/components/i2s_audio/media_player.py  |  94 ++++++
 esphome/components/media_player/__init__.py   |  64 ++++
 .../components/media_player/media_player.cpp  | 115 ++++++++
 .../components/media_player/media_player.h    |  91 ++++++
 esphome/core/application.h                    |  19 ++
 esphome/core/component_iterator.cpp           |  18 ++
 esphome/core/component_iterator.h             |   6 +
 esphome/core/controller.cpp                   |   6 +
 esphome/core/controller.h                     |   6 +
 esphome/core/defines.h                        |   1 +
 platformio.ini                                |   2 +
 tests/test4.yaml                              |   9 +
 29 files changed, 1170 insertions(+), 2 deletions(-)
 create mode 100644 esphome/components/i2s_audio/__init__.py
 create mode 100644 esphome/components/i2s_audio/i2s_audio_media_player.cpp
 create mode 100644 esphome/components/i2s_audio/i2s_audio_media_player.h
 create mode 100644 esphome/components/i2s_audio/media_player.py
 create mode 100644 esphome/components/media_player/__init__.py
 create mode 100644 esphome/components/media_player/media_player.cpp
 create mode 100644 esphome/components/media_player/media_player.h

diff --git a/CODEOWNERS b/CODEOWNERS
index 3e82a372ce..d5ce5e6920 100644
--- a/CODEOWNERS
+++ b/CODEOWNERS
@@ -88,6 +88,7 @@ esphome/components/honeywellabp/* @RubyBailey
 esphome/components/hrxl_maxsonar_wr/* @netmikey
 esphome/components/hydreon_rgxx/* @functionpointer
 esphome/components/i2c/* @esphome/core
+esphome/components/i2s_audio/* @jesserockz
 esphome/components/improv_serial/* @esphome/core
 esphome/components/ina260/* @MrEditor97
 esphome/components/inkbird_ibsth1_mini/* @fkirill
@@ -119,6 +120,7 @@ esphome/components/mcp47a1/* @jesserockz
 esphome/components/mcp9808/* @k7hpn
 esphome/components/md5/* @esphome/core
 esphome/components/mdns/* @esphome/core
+esphome/components/media_player/* @jesserockz
 esphome/components/midea/* @dudanov
 esphome/components/midea_ir/* @dudanov
 esphome/components/mitsubishi/* @RubyBailey
diff --git a/esphome/components/api/api.proto b/esphome/components/api/api.proto
index bd39893825..3e9a62f3d8 100644
--- a/esphome/components/api/api.proto
+++ b/esphome/components/api/api.proto
@@ -42,6 +42,7 @@ service APIConnection {
   rpc select_command (SelectCommandRequest) returns (void) {}
   rpc button_command (ButtonCommandRequest) returns (void) {}
   rpc lock_command (LockCommandRequest) returns (void) {}
+  rpc media_player_command (MediaPlayerCommandRequest) returns (void) {}
 }
 
 
@@ -991,7 +992,7 @@ message ListEntitiesLockResponse {
   bool supports_open = 9;
   bool requires_code = 10;
 
-  # Not yet implemented:
+  // Not yet implemented:
   string code_format = 11;
 }
 message LockStateResponse {
@@ -1010,7 +1011,7 @@ message LockCommandRequest {
   fixed32 key = 1;
   LockCommand command = 2;
 
-  # Not yet implemented:
+  // Not yet implemented:
   bool has_code = 3;
   string code = 4;
 }
@@ -1040,3 +1041,60 @@ message ButtonCommandRequest {
   fixed32 key = 1;
 }
 
+// ==================== MEDIA PLAYER ====================
+enum MediaPlayerState {
+  MEDIA_PLAYER_STATE_NONE = 0;
+  MEDIA_PLAYER_STATE_IDLE = 1;
+  MEDIA_PLAYER_STATE_PLAYING = 2;
+  MEDIA_PLAYER_STATE_PAUSED = 3;
+}
+enum MediaPlayerCommand {
+  MEDIA_PLAYER_COMMAND_PLAY = 0;
+  MEDIA_PLAYER_COMMAND_PAUSE = 1;
+  MEDIA_PLAYER_COMMAND_STOP = 2;
+  MEDIA_PLAYER_COMMAND_MUTE = 3;
+  MEDIA_PLAYER_COMMAND_UNMUTE = 4;
+}
+message ListEntitiesMediaPlayerResponse {
+  option (id) = 63;
+  option (source) = SOURCE_SERVER;
+  option (ifdef) = "USE_MEDIA_PLAYER";
+
+  string object_id = 1;
+  fixed32 key = 2;
+  string name = 3;
+  string unique_id = 4;
+
+  string icon = 5;
+  bool disabled_by_default = 6;
+  EntityCategory entity_category = 7;
+
+  bool supports_pause = 8;
+}
+message MediaPlayerStateResponse {
+  option (id) = 64;
+  option (source) = SOURCE_SERVER;
+  option (ifdef) = "USE_MEDIA_PLAYER";
+  option (no_delay) = true;
+  fixed32 key = 1;
+  MediaPlayerState state = 2;
+  float volume = 3;
+  bool muted = 4;
+}
+message MediaPlayerCommandRequest {
+  option (id) = 65;
+  option (source) = SOURCE_CLIENT;
+  option (ifdef) = "USE_MEDIA_PLAYER";
+  option (no_delay) = true;
+
+  fixed32 key = 1;
+
+  bool has_command = 2;
+  MediaPlayerCommand command = 3;
+
+  bool has_volume = 4;
+  float volume = 5;
+
+  bool has_media_url = 6;
+  string media_url = 7;
+}
diff --git a/esphome/components/api/api_connection.cpp b/esphome/components/api/api_connection.cpp
index 4f399d95d0..9028034c90 100644
--- a/esphome/components/api/api_connection.cpp
+++ b/esphome/components/api/api_connection.cpp
@@ -733,6 +733,52 @@ void APIConnection::lock_command(const LockCommandRequest &msg) {
 }
 #endif
 
+#ifdef USE_MEDIA_PLAYER
+bool APIConnection::send_media_player_state(media_player::MediaPlayer *media_player) {
+  if (!this->state_subscription_)
+    return false;
+
+  MediaPlayerStateResponse resp{};
+  resp.key = media_player->get_object_id_hash();
+  resp.state = static_cast<enums::MediaPlayerState>(media_player->state);
+  resp.volume = media_player->volume;
+  resp.muted = media_player->is_muted();
+  return this->send_media_player_state_response(resp);
+}
+bool APIConnection::send_media_player_info(media_player::MediaPlayer *media_player) {
+  ListEntitiesMediaPlayerResponse msg;
+  msg.key = media_player->get_object_id_hash();
+  msg.object_id = media_player->get_object_id();
+  msg.name = media_player->get_name();
+  msg.unique_id = get_default_unique_id("media_player", media_player);
+  msg.icon = media_player->get_icon();
+  msg.disabled_by_default = media_player->is_disabled_by_default();
+  msg.entity_category = static_cast<enums::EntityCategory>(media_player->get_entity_category());
+
+  auto traits = media_player->get_traits();
+  msg.supports_pause = traits.get_supports_pause();
+
+  return this->send_list_entities_media_player_response(msg);
+}
+void APIConnection::media_player_command(const MediaPlayerCommandRequest &msg) {
+  media_player::MediaPlayer *media_player = App.get_media_player_by_key(msg.key);
+  if (media_player == nullptr)
+    return;
+
+  auto call = media_player->make_call();
+  if (msg.has_command) {
+    call.set_command(static_cast<media_player::MediaPlayerCommand>(msg.command));
+  }
+  if (msg.has_volume) {
+    call.set_volume(msg.volume);
+  }
+  if (msg.has_media_url) {
+    call.set_media_url(msg.media_url);
+  }
+  call.perform();
+}
+#endif
+
 #ifdef USE_ESP32_CAMERA
 void APIConnection::send_camera_state(std::shared_ptr<esp32_camera::CameraImage> image) {
   if (!this->state_subscription_)
diff --git a/esphome/components/api/api_connection.h b/esphome/components/api/api_connection.h
index 10f0becc54..0787d2f7eb 100644
--- a/esphome/components/api/api_connection.h
+++ b/esphome/components/api/api_connection.h
@@ -82,6 +82,11 @@ class APIConnection : public APIServerConnection {
   bool send_lock_state(lock::Lock *a_lock, lock::LockState state);
   bool send_lock_info(lock::Lock *a_lock);
   void lock_command(const LockCommandRequest &msg) override;
+#endif
+#ifdef USE_MEDIA_PLAYER
+  bool send_media_player_state(media_player::MediaPlayer *media_player);
+  bool send_media_player_info(media_player::MediaPlayer *media_player);
+  void media_player_command(const MediaPlayerCommandRequest &msg) override;
 #endif
   bool send_log_message(int level, const char *tag, const char *line);
   void send_homeassistant_service_call(const HomeassistantServiceResponse &call) {
diff --git a/esphome/components/api/api_pb2.cpp b/esphome/components/api/api_pb2.cpp
index 5a78587473..70f909c07a 100644
--- a/esphome/components/api/api_pb2.cpp
+++ b/esphome/components/api/api_pb2.cpp
@@ -308,6 +308,36 @@ template<> const char *proto_enum_to_string<enums::LockCommand>(enums::LockComma
       return "UNKNOWN";
   }
 }
+template<> const char *proto_enum_to_string<enums::MediaPlayerState>(enums::MediaPlayerState value) {
+  switch (value) {
+    case enums::MEDIA_PLAYER_STATE_NONE:
+      return "MEDIA_PLAYER_STATE_NONE";
+    case enums::MEDIA_PLAYER_STATE_IDLE:
+      return "MEDIA_PLAYER_STATE_IDLE";
+    case enums::MEDIA_PLAYER_STATE_PLAYING:
+      return "MEDIA_PLAYER_STATE_PLAYING";
+    case enums::MEDIA_PLAYER_STATE_PAUSED:
+      return "MEDIA_PLAYER_STATE_PAUSED";
+    default:
+      return "UNKNOWN";
+  }
+}
+template<> const char *proto_enum_to_string<enums::MediaPlayerCommand>(enums::MediaPlayerCommand value) {
+  switch (value) {
+    case enums::MEDIA_PLAYER_COMMAND_PLAY:
+      return "MEDIA_PLAYER_COMMAND_PLAY";
+    case enums::MEDIA_PLAYER_COMMAND_PAUSE:
+      return "MEDIA_PLAYER_COMMAND_PAUSE";
+    case enums::MEDIA_PLAYER_COMMAND_STOP:
+      return "MEDIA_PLAYER_COMMAND_STOP";
+    case enums::MEDIA_PLAYER_COMMAND_MUTE:
+      return "MEDIA_PLAYER_COMMAND_MUTE";
+    case enums::MEDIA_PLAYER_COMMAND_UNMUTE:
+      return "MEDIA_PLAYER_COMMAND_UNMUTE";
+    default:
+      return "UNKNOWN";
+  }
+}
 bool HelloRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
     case 1: {
@@ -4574,6 +4604,254 @@ void ButtonCommandRequest::dump_to(std::string &out) const {
   out.append("}");
 }
 #endif
+bool ListEntitiesMediaPlayerResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
+  switch (field_id) {
+    case 6: {
+      this->disabled_by_default = value.as_bool();
+      return true;
+    }
+    case 7: {
+      this->entity_category = value.as_enum<enums::EntityCategory>();
+      return true;
+    }
+    case 8: {
+      this->supports_pause = value.as_bool();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+bool ListEntitiesMediaPlayerResponse::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
+  switch (field_id) {
+    case 1: {
+      this->object_id = value.as_string();
+      return true;
+    }
+    case 3: {
+      this->name = value.as_string();
+      return true;
+    }
+    case 4: {
+      this->unique_id = value.as_string();
+      return true;
+    }
+    case 5: {
+      this->icon = value.as_string();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+bool ListEntitiesMediaPlayerResponse::decode_32bit(uint32_t field_id, Proto32Bit value) {
+  switch (field_id) {
+    case 2: {
+      this->key = value.as_fixed32();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+void ListEntitiesMediaPlayerResponse::encode(ProtoWriteBuffer buffer) const {
+  buffer.encode_string(1, this->object_id);
+  buffer.encode_fixed32(2, this->key);
+  buffer.encode_string(3, this->name);
+  buffer.encode_string(4, this->unique_id);
+  buffer.encode_string(5, this->icon);
+  buffer.encode_bool(6, this->disabled_by_default);
+  buffer.encode_enum<enums::EntityCategory>(7, this->entity_category);
+  buffer.encode_bool(8, this->supports_pause);
+}
+#ifdef HAS_PROTO_MESSAGE_DUMP
+void ListEntitiesMediaPlayerResponse::dump_to(std::string &out) const {
+  __attribute__((unused)) char buffer[64];
+  out.append("ListEntitiesMediaPlayerResponse {\n");
+  out.append("  object_id: ");
+  out.append("'").append(this->object_id).append("'");
+  out.append("\n");
+
+  out.append("  key: ");
+  sprintf(buffer, "%u", this->key);
+  out.append(buffer);
+  out.append("\n");
+
+  out.append("  name: ");
+  out.append("'").append(this->name).append("'");
+  out.append("\n");
+
+  out.append("  unique_id: ");
+  out.append("'").append(this->unique_id).append("'");
+  out.append("\n");
+
+  out.append("  icon: ");
+  out.append("'").append(this->icon).append("'");
+  out.append("\n");
+
+  out.append("  disabled_by_default: ");
+  out.append(YESNO(this->disabled_by_default));
+  out.append("\n");
+
+  out.append("  entity_category: ");
+  out.append(proto_enum_to_string<enums::EntityCategory>(this->entity_category));
+  out.append("\n");
+
+  out.append("  supports_pause: ");
+  out.append(YESNO(this->supports_pause));
+  out.append("\n");
+  out.append("}");
+}
+#endif
+bool MediaPlayerStateResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
+  switch (field_id) {
+    case 2: {
+      this->state = value.as_enum<enums::MediaPlayerState>();
+      return true;
+    }
+    case 4: {
+      this->muted = value.as_bool();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+bool MediaPlayerStateResponse::decode_32bit(uint32_t field_id, Proto32Bit value) {
+  switch (field_id) {
+    case 1: {
+      this->key = value.as_fixed32();
+      return true;
+    }
+    case 3: {
+      this->volume = value.as_float();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+void MediaPlayerStateResponse::encode(ProtoWriteBuffer buffer) const {
+  buffer.encode_fixed32(1, this->key);
+  buffer.encode_enum<enums::MediaPlayerState>(2, this->state);
+  buffer.encode_float(3, this->volume);
+  buffer.encode_bool(4, this->muted);
+}
+#ifdef HAS_PROTO_MESSAGE_DUMP
+void MediaPlayerStateResponse::dump_to(std::string &out) const {
+  __attribute__((unused)) char buffer[64];
+  out.append("MediaPlayerStateResponse {\n");
+  out.append("  key: ");
+  sprintf(buffer, "%u", this->key);
+  out.append(buffer);
+  out.append("\n");
+
+  out.append("  state: ");
+  out.append(proto_enum_to_string<enums::MediaPlayerState>(this->state));
+  out.append("\n");
+
+  out.append("  volume: ");
+  sprintf(buffer, "%g", this->volume);
+  out.append(buffer);
+  out.append("\n");
+
+  out.append("  muted: ");
+  out.append(YESNO(this->muted));
+  out.append("\n");
+  out.append("}");
+}
+#endif
+bool MediaPlayerCommandRequest::decode_varint(uint32_t field_id, ProtoVarInt value) {
+  switch (field_id) {
+    case 2: {
+      this->has_command = value.as_bool();
+      return true;
+    }
+    case 3: {
+      this->command = value.as_enum<enums::MediaPlayerCommand>();
+      return true;
+    }
+    case 4: {
+      this->has_volume = value.as_bool();
+      return true;
+    }
+    case 6: {
+      this->has_media_url = value.as_bool();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+bool MediaPlayerCommandRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
+  switch (field_id) {
+    case 7: {
+      this->media_url = value.as_string();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+bool MediaPlayerCommandRequest::decode_32bit(uint32_t field_id, Proto32Bit value) {
+  switch (field_id) {
+    case 1: {
+      this->key = value.as_fixed32();
+      return true;
+    }
+    case 5: {
+      this->volume = value.as_float();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+void MediaPlayerCommandRequest::encode(ProtoWriteBuffer buffer) const {
+  buffer.encode_fixed32(1, this->key);
+  buffer.encode_bool(2, this->has_command);
+  buffer.encode_enum<enums::MediaPlayerCommand>(3, this->command);
+  buffer.encode_bool(4, this->has_volume);
+  buffer.encode_float(5, this->volume);
+  buffer.encode_bool(6, this->has_media_url);
+  buffer.encode_string(7, this->media_url);
+}
+#ifdef HAS_PROTO_MESSAGE_DUMP
+void MediaPlayerCommandRequest::dump_to(std::string &out) const {
+  __attribute__((unused)) char buffer[64];
+  out.append("MediaPlayerCommandRequest {\n");
+  out.append("  key: ");
+  sprintf(buffer, "%u", this->key);
+  out.append(buffer);
+  out.append("\n");
+
+  out.append("  has_command: ");
+  out.append(YESNO(this->has_command));
+  out.append("\n");
+
+  out.append("  command: ");
+  out.append(proto_enum_to_string<enums::MediaPlayerCommand>(this->command));
+  out.append("\n");
+
+  out.append("  has_volume: ");
+  out.append(YESNO(this->has_volume));
+  out.append("\n");
+
+  out.append("  volume: ");
+  sprintf(buffer, "%g", this->volume);
+  out.append(buffer);
+  out.append("\n");
+
+  out.append("  has_media_url: ");
+  out.append(YESNO(this->has_media_url));
+  out.append("\n");
+
+  out.append("  media_url: ");
+  out.append("'").append(this->media_url).append("'");
+  out.append("\n");
+  out.append("}");
+}
+#endif
 
 }  // namespace api
 }  // namespace esphome
diff --git a/esphome/components/api/api_pb2.h b/esphome/components/api/api_pb2.h
index 28c0a7ce88..ec1cdc35ac 100644
--- a/esphome/components/api/api_pb2.h
+++ b/esphome/components/api/api_pb2.h
@@ -141,6 +141,19 @@ enum LockCommand : uint32_t {
   LOCK_LOCK = 1,
   LOCK_OPEN = 2,
 };
+enum MediaPlayerState : uint32_t {
+  MEDIA_PLAYER_STATE_NONE = 0,
+  MEDIA_PLAYER_STATE_IDLE = 1,
+  MEDIA_PLAYER_STATE_PLAYING = 2,
+  MEDIA_PLAYER_STATE_PAUSED = 3,
+};
+enum MediaPlayerCommand : uint32_t {
+  MEDIA_PLAYER_COMMAND_PLAY = 0,
+  MEDIA_PLAYER_COMMAND_PAUSE = 1,
+  MEDIA_PLAYER_COMMAND_STOP = 2,
+  MEDIA_PLAYER_COMMAND_MUTE = 3,
+  MEDIA_PLAYER_COMMAND_UNMUTE = 4,
+};
 
 }  // namespace enums
 
@@ -1146,6 +1159,60 @@ class ButtonCommandRequest : public ProtoMessage {
  protected:
   bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
 };
+class ListEntitiesMediaPlayerResponse : public ProtoMessage {
+ public:
+  std::string object_id{};
+  uint32_t key{0};
+  std::string name{};
+  std::string unique_id{};
+  std::string icon{};
+  bool disabled_by_default{false};
+  enums::EntityCategory entity_category{};
+  bool supports_pause{false};
+  void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  void dump_to(std::string &out) const override;
+#endif
+
+ protected:
+  bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
+  bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
+};
+class MediaPlayerStateResponse : public ProtoMessage {
+ public:
+  uint32_t key{0};
+  enums::MediaPlayerState state{};
+  float volume{0.0f};
+  bool muted{false};
+  void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  void dump_to(std::string &out) const override;
+#endif
+
+ protected:
+  bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
+};
+class MediaPlayerCommandRequest : public ProtoMessage {
+ public:
+  uint32_t key{0};
+  bool has_command{false};
+  enums::MediaPlayerCommand command{};
+  bool has_volume{false};
+  float volume{0.0f};
+  bool has_media_url{false};
+  std::string media_url{};
+  void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  void dump_to(std::string &out) const override;
+#endif
+
+ protected:
+  bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
+  bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
+};
 
 }  // namespace api
 }  // namespace esphome
diff --git a/esphome/components/api/api_pb2_service.cpp b/esphome/components/api/api_pb2_service.cpp
index d981a3bf4e..bd146cb54d 100644
--- a/esphome/components/api/api_pb2_service.cpp
+++ b/esphome/components/api/api_pb2_service.cpp
@@ -310,6 +310,24 @@ bool APIServerConnectionBase::send_list_entities_button_response(const ListEntit
 #endif
 #ifdef USE_BUTTON
 #endif
+#ifdef USE_MEDIA_PLAYER
+bool APIServerConnectionBase::send_list_entities_media_player_response(const ListEntitiesMediaPlayerResponse &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  ESP_LOGVV(TAG, "send_list_entities_media_player_response: %s", msg.dump().c_str());
+#endif
+  return this->send_message_<ListEntitiesMediaPlayerResponse>(msg, 63);
+}
+#endif
+#ifdef USE_MEDIA_PLAYER
+bool APIServerConnectionBase::send_media_player_state_response(const MediaPlayerStateResponse &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  ESP_LOGVV(TAG, "send_media_player_state_response: %s", msg.dump().c_str());
+#endif
+  return this->send_message_<MediaPlayerStateResponse>(msg, 64);
+}
+#endif
+#ifdef USE_MEDIA_PLAYER
+#endif
 bool APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type, uint8_t *msg_data) {
   switch (msg_type) {
     case 1: {
@@ -563,6 +581,17 @@ bool APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       ESP_LOGVV(TAG, "on_button_command_request: %s", msg.dump().c_str());
 #endif
       this->on_button_command_request(msg);
+#endif
+      break;
+    }
+    case 65: {
+#ifdef USE_MEDIA_PLAYER
+      MediaPlayerCommandRequest msg;
+      msg.decode(msg_data, msg_size);
+#ifdef HAS_PROTO_MESSAGE_DUMP
+      ESP_LOGVV(TAG, "on_media_player_command_request: %s", msg.dump().c_str());
+#endif
+      this->on_media_player_command_request(msg);
 #endif
       break;
     }
@@ -813,6 +842,19 @@ void APIServerConnection::on_lock_command_request(const LockCommandRequest &msg)
   this->lock_command(msg);
 }
 #endif
+#ifdef USE_MEDIA_PLAYER
+void APIServerConnection::on_media_player_command_request(const MediaPlayerCommandRequest &msg) {
+  if (!this->is_connection_setup()) {
+    this->on_no_setup_connection();
+    return;
+  }
+  if (!this->is_authenticated()) {
+    this->on_unauthenticated_access();
+    return;
+  }
+  this->media_player_command(msg);
+}
+#endif
 
 }  // namespace api
 }  // namespace esphome
diff --git a/esphome/components/api/api_pb2_service.h b/esphome/components/api/api_pb2_service.h
index 5aaf831c91..28ad3fbd15 100644
--- a/esphome/components/api/api_pb2_service.h
+++ b/esphome/components/api/api_pb2_service.h
@@ -144,6 +144,15 @@ class APIServerConnectionBase : public ProtoService {
 #endif
 #ifdef USE_BUTTON
   virtual void on_button_command_request(const ButtonCommandRequest &value){};
+#endif
+#ifdef USE_MEDIA_PLAYER
+  bool send_list_entities_media_player_response(const ListEntitiesMediaPlayerResponse &msg);
+#endif
+#ifdef USE_MEDIA_PLAYER
+  bool send_media_player_state_response(const MediaPlayerStateResponse &msg);
+#endif
+#ifdef USE_MEDIA_PLAYER
+  virtual void on_media_player_command_request(const MediaPlayerCommandRequest &value){};
 #endif
  protected:
   bool read_message(uint32_t msg_size, uint32_t msg_type, uint8_t *msg_data) override;
@@ -192,6 +201,9 @@ class APIServerConnection : public APIServerConnectionBase {
 #endif
 #ifdef USE_LOCK
   virtual void lock_command(const LockCommandRequest &msg) = 0;
+#endif
+#ifdef USE_MEDIA_PLAYER
+  virtual void media_player_command(const MediaPlayerCommandRequest &msg) = 0;
 #endif
  protected:
   void on_hello_request(const HelloRequest &msg) override;
@@ -236,6 +248,9 @@ class APIServerConnection : public APIServerConnectionBase {
 #ifdef USE_LOCK
   void on_lock_command_request(const LockCommandRequest &msg) override;
 #endif
+#ifdef USE_MEDIA_PLAYER
+  void on_media_player_command_request(const MediaPlayerCommandRequest &msg) override;
+#endif
 };
 
 }  // namespace api
diff --git a/esphome/components/api/api_server.cpp b/esphome/components/api/api_server.cpp
index 1f2800f298..8375a82313 100644
--- a/esphome/components/api/api_server.cpp
+++ b/esphome/components/api/api_server.cpp
@@ -272,6 +272,15 @@ void APIServer::on_lock_update(lock::Lock *obj) {
 }
 #endif
 
+#ifdef USE_MEDIA_PLAYER
+void APIServer::on_media_player_update(media_player::MediaPlayer *obj) {
+  if (obj->is_internal())
+    return;
+  for (auto &c : this->clients_)
+    c->send_media_player_state(obj);
+}
+#endif
+
 float APIServer::get_setup_priority() const { return setup_priority::AFTER_WIFI; }
 void APIServer::set_port(uint16_t port) { this->port_ = port; }
 APIServer *global_api_server = nullptr;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
diff --git a/esphome/components/api/api_server.h b/esphome/components/api/api_server.h
index f03a83fc7b..6997e23cac 100644
--- a/esphome/components/api/api_server.h
+++ b/esphome/components/api/api_server.h
@@ -68,6 +68,9 @@ class APIServer : public Component, public Controller {
 #endif
 #ifdef USE_LOCK
   void on_lock_update(lock::Lock *obj) override;
+#endif
+#ifdef USE_MEDIA_PLAYER
+  void on_media_player_update(media_player::MediaPlayer *obj) override;
 #endif
   void send_homeassistant_service_call(const HomeassistantServiceResponse &call);
   void register_user_service(UserServiceDescriptor *descriptor) { this->user_services_.push_back(descriptor); }
diff --git a/esphome/components/api/list_entities.cpp b/esphome/components/api/list_entities.cpp
index 9f55fda617..85d4cd61ef 100644
--- a/esphome/components/api/list_entities.cpp
+++ b/esphome/components/api/list_entities.cpp
@@ -64,5 +64,11 @@ bool ListEntitiesIterator::on_number(number::Number *number) { return this->clie
 bool ListEntitiesIterator::on_select(select::Select *select) { return this->client_->send_select_info(select); }
 #endif
 
+#ifdef USE_MEDIA_PLAYER
+bool ListEntitiesIterator::on_media_player(media_player::MediaPlayer *media_player) {
+  return this->client_->send_media_player_info(media_player);
+}
+#endif
+
 }  // namespace api
 }  // namespace esphome
diff --git a/esphome/components/api/list_entities.h b/esphome/components/api/list_entities.h
index 51c343eb03..4fbaa509a2 100644
--- a/esphome/components/api/list_entities.h
+++ b/esphome/components/api/list_entities.h
@@ -51,6 +51,9 @@ class ListEntitiesIterator : public ComponentIterator {
 #endif
 #ifdef USE_LOCK
   bool on_lock(lock::Lock *a_lock) override;
+#endif
+#ifdef USE_MEDIA_PLAYER
+  bool on_media_player(media_player::MediaPlayer *media_player) override;
 #endif
   bool on_end() override;
 
diff --git a/esphome/components/api/subscribe_state.cpp b/esphome/components/api/subscribe_state.cpp
index ba277502c8..1d1ba0245e 100644
--- a/esphome/components/api/subscribe_state.cpp
+++ b/esphome/components/api/subscribe_state.cpp
@@ -50,6 +50,11 @@ bool InitialStateIterator::on_select(select::Select *select) {
 #ifdef USE_LOCK
 bool InitialStateIterator::on_lock(lock::Lock *a_lock) { return this->client_->send_lock_state(a_lock, a_lock->state); }
 #endif
+#ifdef USE_MEDIA_PLAYER
+bool InitialStateIterator::on_media_player(media_player::MediaPlayer *media_player) {
+  return this->client_->send_media_player_state(media_player);
+}
+#endif
 InitialStateIterator::InitialStateIterator(APIConnection *client) : client_(client) {}
 
 }  // namespace api
diff --git a/esphome/components/api/subscribe_state.h b/esphome/components/api/subscribe_state.h
index 515e1a2d07..7a7ba697c0 100644
--- a/esphome/components/api/subscribe_state.h
+++ b/esphome/components/api/subscribe_state.h
@@ -48,6 +48,9 @@ class InitialStateIterator : public ComponentIterator {
 #endif
 #ifdef USE_LOCK
   bool on_lock(lock::Lock *a_lock) override;
+#endif
+#ifdef USE_MEDIA_PLAYER
+  bool on_media_player(media_player::MediaPlayer *media_player) override;
 #endif
  protected:
   APIConnection *client_;
diff --git a/esphome/components/i2s_audio/__init__.py b/esphome/components/i2s_audio/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/esphome/components/i2s_audio/i2s_audio_media_player.cpp b/esphome/components/i2s_audio/i2s_audio_media_player.cpp
new file mode 100644
index 0000000000..0ab3237aeb
--- /dev/null
+++ b/esphome/components/i2s_audio/i2s_audio_media_player.cpp
@@ -0,0 +1,132 @@
+#include "i2s_audio_media_player.h"
+
+#ifdef USE_ESP32_FRAMEWORK_ARDUINO
+
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace i2s_audio {
+
+static const char *const TAG = "audio";
+
+void I2SAudioMediaPlayer::control(const media_player::MediaPlayerCall &call) {
+  if (call.get_media_url().has_value()) {
+    if (this->audio_->isRunning())
+      this->audio_->stopSong();
+    this->high_freq_.start();
+    this->audio_->connecttohost(call.get_media_url().value().c_str());
+    this->state = media_player::MEDIA_PLAYER_STATE_PLAYING;
+  }
+  if (call.get_volume().has_value()) {
+    this->volume = call.get_volume().value();
+    this->set_volume_(volume);
+    this->unmute_();
+  }
+  if (call.get_command().has_value()) {
+    switch (call.get_command().value()) {
+      case media_player::MEDIA_PLAYER_COMMAND_PLAY:
+        if (!this->audio_->isRunning())
+          this->audio_->pauseResume();
+        this->state = media_player::MEDIA_PLAYER_STATE_PLAYING;
+        break;
+      case media_player::MEDIA_PLAYER_COMMAND_PAUSE:
+        if (this->audio_->isRunning())
+          this->audio_->pauseResume();
+        this->state = media_player::MEDIA_PLAYER_STATE_PAUSED;
+        break;
+      case media_player::MEDIA_PLAYER_COMMAND_STOP:
+        this->stop_();
+        break;
+      case media_player::MEDIA_PLAYER_COMMAND_MUTE:
+        this->mute_();
+        break;
+      case media_player::MEDIA_PLAYER_COMMAND_UNMUTE:
+        this->unmute_();
+        break;
+    }
+  }
+  this->publish_state();
+}
+
+void I2SAudioMediaPlayer::mute_() {
+  if (this->mute_pin_ != nullptr) {
+    this->mute_pin_->digital_write(true);
+  } else {
+    this->set_volume_(0.0f, false);
+  }
+  this->muted_ = true;
+}
+void I2SAudioMediaPlayer::unmute_() {
+  if (this->mute_pin_ != nullptr) {
+    this->mute_pin_->digital_write(false);
+  } else {
+    this->set_volume_(this->volume, false);
+  }
+  this->muted_ = false;
+}
+void I2SAudioMediaPlayer::set_volume_(float volume, bool publish) {
+  this->audio_->setVolume(remap<uint8_t, float>(volume, 0.0f, 1.0f, 0, 21));
+  if (publish)
+    this->volume = volume;
+}
+
+void I2SAudioMediaPlayer::stop_() {
+  if (this->audio_->isRunning())
+    this->audio_->stopSong();
+  this->high_freq_.stop();
+  this->state = media_player::MEDIA_PLAYER_STATE_IDLE;
+}
+
+void I2SAudioMediaPlayer::setup() {
+  ESP_LOGCONFIG(TAG, "Setting up Audio...");
+  if (this->internal_dac_mode_ != I2S_DAC_CHANNEL_DISABLE) {
+    this->audio_ = make_unique<Audio>(true, this->internal_dac_mode_);
+  } else {
+    this->audio_ = make_unique<Audio>(false);
+    this->audio_->setPinout(this->bclk_pin_, this->lrclk_pin_, this->dout_pin_);
+    this->audio_->forceMono(this->external_dac_channels_ == 1);
+  }
+  this->state = media_player::MEDIA_PLAYER_STATE_IDLE;
+}
+
+void I2SAudioMediaPlayer::loop() {
+  this->audio_->loop();
+  if (this->state == media_player::MEDIA_PLAYER_STATE_PLAYING && !this->audio_->isRunning()) {
+    this->stop_();
+    this->publish_state();
+  }
+}
+
+media_player::MediaPlayerTraits I2SAudioMediaPlayer::get_traits() {
+  auto traits = media_player::MediaPlayerTraits();
+  traits.set_supports_pause(true);
+  return traits;
+};
+
+void I2SAudioMediaPlayer::dump_config() {
+  ESP_LOGCONFIG(TAG, "Audio:");
+  if (this->is_failed()) {
+    ESP_LOGCONFIG(TAG, "Audio failed to initialize!");
+    return;
+  }
+  if (this->internal_dac_mode_ != I2S_DAC_CHANNEL_DISABLE) {
+    switch (this->internal_dac_mode_) {
+      case I2S_DAC_CHANNEL_LEFT_EN:
+        ESP_LOGCONFIG(TAG, "  Internal DAC mode: Left");
+        break;
+      case I2S_DAC_CHANNEL_RIGHT_EN:
+        ESP_LOGCONFIG(TAG, "  Internal DAC mode: Right");
+        break;
+      case I2S_DAC_CHANNEL_BOTH_EN:
+        ESP_LOGCONFIG(TAG, "  Internal DAC mode: Left & Right");
+        break;
+      default:
+        break;
+    }
+  }
+}
+
+}  // namespace i2s_audio
+}  // namespace esphome
+
+#endif  // USE_ESP32_FRAMEWORK_ARDUINO
diff --git a/esphome/components/i2s_audio/i2s_audio_media_player.h b/esphome/components/i2s_audio/i2s_audio_media_player.h
new file mode 100644
index 0000000000..89bd128a33
--- /dev/null
+++ b/esphome/components/i2s_audio/i2s_audio_media_player.h
@@ -0,0 +1,63 @@
+#pragma once
+
+#ifdef USE_ESP32_FRAMEWORK_ARDUINO
+
+#include "esphome/components/media_player/media_player.h"
+#include "esphome/core/component.h"
+#include "esphome/core/gpio.h"
+#include "esphome/core/helpers.h"
+
+#include <Audio.h>
+
+namespace esphome {
+namespace i2s_audio {
+
+class I2SAudioMediaPlayer : public Component, public media_player::MediaPlayer {
+ public:
+  void setup() override;
+  float get_setup_priority() const override { return esphome::setup_priority::LATE; }
+
+  void loop() override;
+
+  void dump_config() override;
+
+  void set_dout_pin(uint8_t pin) { this->dout_pin_ = pin; }
+  void set_bclk_pin(uint8_t pin) { this->bclk_pin_ = pin; }
+  void set_lrclk_pin(uint8_t pin) { this->lrclk_pin_ = pin; }
+  void set_mute_pin(GPIOPin *mute_pin) { this->mute_pin_ = mute_pin; }
+  void set_internal_dac_mode(i2s_dac_mode_t mode) { this->internal_dac_mode_ = mode; }
+  void set_external_dac_channels(uint8_t channels) { this->external_dac_channels_ = channels; }
+
+  media_player::MediaPlayerTraits get_traits() override;
+
+  bool is_muted() const override { return this->muted_; }
+
+ protected:
+  void control(const media_player::MediaPlayerCall &call) override;
+
+  void mute_();
+  void unmute_();
+  void set_volume_(float volume, bool publish = true);
+  void stop_();
+
+  std::unique_ptr<Audio> audio_;
+
+  uint8_t dout_pin_{0};
+  uint8_t din_pin_{0};
+  uint8_t bclk_pin_;
+  uint8_t lrclk_pin_;
+
+  GPIOPin *mute_pin_{nullptr};
+  bool muted_{false};
+  float unmuted_volume_{0};
+
+  i2s_dac_mode_t internal_dac_mode_{I2S_DAC_CHANNEL_DISABLE};
+  uint8_t external_dac_channels_;
+
+  HighFrequencyLoopRequester high_freq_;
+};
+
+}  // namespace i2s_audio
+}  // namespace esphome
+
+#endif  // USE_ESP32_FRAMEWORK_ARDUINO
diff --git a/esphome/components/i2s_audio/media_player.py b/esphome/components/i2s_audio/media_player.py
new file mode 100644
index 0000000000..e2bdbe2d88
--- /dev/null
+++ b/esphome/components/i2s_audio/media_player.py
@@ -0,0 +1,94 @@
+import esphome.codegen as cg
+from esphome.components import media_player
+import esphome.config_validation as cv
+
+from esphome import pins
+
+from esphome.const import CONF_ID, CONF_MODE
+from esphome.core import CORE
+
+CODEOWNERS = ["@jesserockz"]
+DEPENDENCIES = ["esp32"]
+
+i2s_audio_ns = cg.esphome_ns.namespace("i2s_audio")
+
+I2SAudioMediaPlayer = i2s_audio_ns.class_(
+    "I2SAudioMediaPlayer", cg.Component, media_player.MediaPlayer
+)
+
+i2s_dac_mode_t = cg.global_ns.enum("i2s_dac_mode_t")
+
+CONF_I2S_DOUT_PIN = "i2s_dout_pin"
+CONF_I2S_BCLK_PIN = "i2s_bclk_pin"
+CONF_I2S_LRCLK_PIN = "i2s_lrclk_pin"
+CONF_MUTE_PIN = "mute_pin"
+CONF_AUDIO_ID = "audio_id"
+CONF_DAC_TYPE = "dac_type"
+
+INTERNAL_DAC_OPTIONS = {
+    "left": i2s_dac_mode_t.I2S_DAC_CHANNEL_LEFT_EN,
+    "right": i2s_dac_mode_t.I2S_DAC_CHANNEL_RIGHT_EN,
+    "stereo": i2s_dac_mode_t.I2S_DAC_CHANNEL_BOTH_EN,
+}
+
+EXTERNAL_DAC_OPTIONS = ["mono", "stereo"]
+
+CONFIG_SCHEMA = cv.All(
+    cv.typed_schema(
+        {
+            "internal": cv.Schema(
+                {
+                    cv.GenerateID(): cv.declare_id(I2SAudioMediaPlayer),
+                    cv.Required(CONF_MODE): cv.enum(INTERNAL_DAC_OPTIONS, lower=True),
+                }
+            )
+            .extend(media_player.MEDIA_PLAYER_SCHEMA)
+            .extend(cv.COMPONENT_SCHEMA),
+            "external": cv.Schema(
+                {
+                    cv.GenerateID(): cv.declare_id(I2SAudioMediaPlayer),
+                    cv.Required(
+                        CONF_I2S_DOUT_PIN
+                    ): pins.internal_gpio_output_pin_number,
+                    cv.Required(
+                        CONF_I2S_BCLK_PIN
+                    ): pins.internal_gpio_output_pin_number,
+                    cv.Required(
+                        CONF_I2S_LRCLK_PIN
+                    ): pins.internal_gpio_output_pin_number,
+                    cv.Optional(CONF_MUTE_PIN): pins.gpio_output_pin_schema,
+                    cv.Optional(CONF_MODE, default="mono"): cv.one_of(
+                        *EXTERNAL_DAC_OPTIONS, lower=True
+                    ),
+                }
+            )
+            .extend(media_player.MEDIA_PLAYER_SCHEMA)
+            .extend(cv.COMPONENT_SCHEMA),
+        },
+        key=CONF_DAC_TYPE,
+    ),
+    cv.only_with_arduino,
+)
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+    await media_player.register_media_player(var, config)
+
+    if config[CONF_DAC_TYPE] == "internal":
+        cg.add(var.set_internal_dac_mode(config[CONF_MODE]))
+    else:
+        cg.add(var.set_dout_pin(config[CONF_I2S_DOUT_PIN]))
+        cg.add(var.set_bclk_pin(config[CONF_I2S_BCLK_PIN]))
+        cg.add(var.set_lrclk_pin(config[CONF_I2S_LRCLK_PIN]))
+        if CONF_MUTE_PIN in config:
+            pin = await cg.gpio_pin_expression(config[CONF_MUTE_PIN])
+            cg.add(var.set_mute_pin(pin))
+        cg.add(var.set_external_dac_channels(2 if config[CONF_MODE] == "stereo" else 1))
+
+    if CORE.is_esp32:
+        cg.add_library("WiFiClientSecure", None)
+        cg.add_library("HTTPClient", None)
+        cg.add_library("esphome/ESP32-audioI2S", "2.1.0")
+        cg.add_build_flag("-DAUDIO_NO_SD_FS")
diff --git a/esphome/components/media_player/__init__.py b/esphome/components/media_player/__init__.py
new file mode 100644
index 0000000000..91cf613ed9
--- /dev/null
+++ b/esphome/components/media_player/__init__.py
@@ -0,0 +1,64 @@
+from esphome import automation
+import esphome.config_validation as cv
+import esphome.codegen as cg
+
+from esphome.automation import maybe_simple_id
+from esphome.const import CONF_ID
+from esphome.core import CORE
+from esphome.coroutine import coroutine_with_priority
+from esphome.cpp_helpers import setup_entity
+
+
+CODEOWNERS = ["@jesserockz"]
+
+IS_PLATFORM_COMPONENT = True
+
+media_player_ns = cg.esphome_ns.namespace("media_player")
+
+MediaPlayer = media_player_ns.class_("MediaPlayer")
+
+PlayAction = media_player_ns.class_(
+    "PlayAction", automation.Action, cg.Parented.template(MediaPlayer)
+)
+PauseAction = media_player_ns.class_(
+    "PauseAction", automation.Action, cg.Parented.template(MediaPlayer)
+)
+StopAction = media_player_ns.class_(
+    "StopAction", automation.Action, cg.Parented.template(MediaPlayer)
+)
+
+
+async def setup_media_player_core_(var, config):
+    await setup_entity(var, config)
+
+
+async def register_media_player(var, config):
+    if not CORE.has_id(config[CONF_ID]):
+        var = cg.Pvariable(config[CONF_ID], var)
+    cg.add(cg.App.register_media_player(var))
+    await setup_media_player_core_(var, config)
+
+
+MEDIA_PLAYER_SCHEMA = cv.ENTITY_BASE_SCHEMA.extend(cv.Schema({}))
+
+
+MEDIA_PLAYER_ACTION_SCHEMA = maybe_simple_id()(
+    {cv.Required(CONF_ID): cv.use_id(MediaPlayer)}
+)
+
+
+@automation.register_action("media_player.play", PlayAction, MEDIA_PLAYER_ACTION_SCHEMA)
+@automation.register_action(
+    "media_player.pause", PauseAction, MEDIA_PLAYER_ACTION_SCHEMA
+)
+@automation.register_action("media_player.stop", StopAction, MEDIA_PLAYER_ACTION_SCHEMA)
+async def media_player_action(config, action_id, template_arg, args):
+    var = cg.new_Pvariable(action_id, template_arg)
+    await cg.register_parented(var, config[CONF_ID])
+    return var
+
+
+@coroutine_with_priority(100.0)
+async def to_code(config):
+    cg.add_global(media_player_ns.using)
+    cg.add_define("USE_MEDIA_PLAYER")
diff --git a/esphome/components/media_player/media_player.cpp b/esphome/components/media_player/media_player.cpp
new file mode 100644
index 0000000000..00ad31ab18
--- /dev/null
+++ b/esphome/components/media_player/media_player.cpp
@@ -0,0 +1,115 @@
+#include "media_player.h"
+
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace media_player {
+
+static const char *const TAG = "media_player";
+
+const char *media_player_state_to_string(MediaPlayerState state) {
+  switch (state) {
+    case MEDIA_PLAYER_STATE_IDLE:
+      return "IDLE";
+    case MEDIA_PLAYER_STATE_PLAYING:
+      return "PLAYING";
+    case MEDIA_PLAYER_STATE_PAUSED:
+      return "PAUSED";
+    case MEDIA_PLAYER_STATE_NONE:
+    default:
+      return "UNKNOWN";
+  }
+}
+
+const char *media_player_command_to_string(MediaPlayerCommand command) {
+  switch (command) {
+    case MEDIA_PLAYER_COMMAND_PLAY:
+      return "PLAY";
+    case MEDIA_PLAYER_COMMAND_PAUSE:
+      return "PAUSE";
+    case MEDIA_PLAYER_COMMAND_STOP:
+      return "STOP";
+    case MEDIA_PLAYER_COMMAND_MUTE:
+      return "MUTE";
+    case MEDIA_PLAYER_COMMAND_UNMUTE:
+      return "UNMUTE";
+    default:
+      return "UNKNOWN";
+  }
+}
+
+void MediaPlayerCall::validate_() {
+  if (this->media_url_.has_value()) {
+    if (this->command_.has_value()) {
+      ESP_LOGW(TAG, "MediaPlayerCall: Setting both command and media_url is not needed.");
+      this->command_.reset();
+    }
+  }
+  if (this->volume_.has_value()) {
+    if (this->volume_.value() < 0.0f || this->volume_.value() > 1.0f) {
+      ESP_LOGW(TAG, "MediaPlayerCall: Volume must be between 0.0 and 1.0.");
+      this->volume_.reset();
+    }
+  }
+}
+
+void MediaPlayerCall::perform() {
+  ESP_LOGD(TAG, "'%s' - Setting", this->parent_->get_name().c_str());
+  this->validate_();
+  if (this->command_.has_value()) {
+    const char *command_s = media_player_command_to_string(this->command_.value());
+    ESP_LOGD(TAG, "  Command: %s", command_s);
+  }
+  if (this->media_url_.has_value()) {
+    ESP_LOGD(TAG, "  Media URL: %s", this->media_url_.value().c_str());
+  }
+  if (this->volume_.has_value()) {
+    ESP_LOGD(TAG, "  Volume: %.2f", this->volume_.value());
+  }
+  this->parent_->control(*this);
+}
+
+MediaPlayerCall &MediaPlayerCall::set_command(MediaPlayerCommand command) {
+  this->command_ = command;
+  return *this;
+}
+MediaPlayerCall &MediaPlayerCall::set_command(optional<MediaPlayerCommand> command) {
+  this->command_ = command;
+  return *this;
+}
+MediaPlayerCall &MediaPlayerCall::set_command(const std::string &command) {
+  if (str_equals_case_insensitive(command, "PLAY")) {
+    this->set_command(MEDIA_PLAYER_COMMAND_PLAY);
+  } else if (str_equals_case_insensitive(command, "PAUSE")) {
+    this->set_command(MEDIA_PLAYER_COMMAND_PAUSE);
+  } else if (str_equals_case_insensitive(command, "STOP")) {
+    this->set_command(MEDIA_PLAYER_COMMAND_STOP);
+  } else if (str_equals_case_insensitive(command, "MUTE")) {
+    this->set_command(MEDIA_PLAYER_COMMAND_MUTE);
+  } else if (str_equals_case_insensitive(command, "UNMUTE")) {
+    this->set_command(MEDIA_PLAYER_COMMAND_UNMUTE);
+  } else {
+    ESP_LOGW(TAG, "'%s' - Unrecognized command %s", this->parent_->get_name().c_str(), command.c_str());
+  }
+  return *this;
+}
+
+MediaPlayerCall &MediaPlayerCall::set_media_url(const std::string &media_url) {
+  this->media_url_ = media_url;
+  return *this;
+}
+
+MediaPlayerCall &MediaPlayerCall::set_volume(float volume) {
+  this->volume_ = volume;
+  return *this;
+}
+
+void MediaPlayer::add_on_state_callback(std::function<void()> &&callback) {
+  this->state_callback_.add(std::move(callback));
+}
+uint32_t MediaPlayer::hash_base() { return 1938496157UL; }
+
+void MediaPlayer::publish_state() { this->state_callback_.call(); }
+
+}  // namespace media_player
+}  // namespace esphome
diff --git a/esphome/components/media_player/media_player.h b/esphome/components/media_player/media_player.h
new file mode 100644
index 0000000000..9a86874996
--- /dev/null
+++ b/esphome/components/media_player/media_player.h
@@ -0,0 +1,91 @@
+#pragma once
+
+#include "esphome/core/entity_base.h"
+#include "esphome/core/helpers.h"
+
+namespace esphome {
+namespace media_player {
+
+enum MediaPlayerState : uint8_t {
+  MEDIA_PLAYER_STATE_NONE = 0,
+  MEDIA_PLAYER_STATE_IDLE = 1,
+  MEDIA_PLAYER_STATE_PLAYING = 2,
+  MEDIA_PLAYER_STATE_PAUSED = 3
+};
+const char *media_player_state_to_string(MediaPlayerState state);
+
+enum MediaPlayerCommand : uint8_t {
+  MEDIA_PLAYER_COMMAND_PLAY = 0,
+  MEDIA_PLAYER_COMMAND_PAUSE = 1,
+  MEDIA_PLAYER_COMMAND_STOP = 2,
+  MEDIA_PLAYER_COMMAND_MUTE = 3,
+  MEDIA_PLAYER_COMMAND_UNMUTE = 4
+};
+const char *media_player_command_to_string(MediaPlayerCommand command);
+
+class MediaPlayer;
+
+class MediaPlayerTraits {
+ public:
+  MediaPlayerTraits() = default;
+
+  void set_supports_pause(bool supports_pause) { this->supports_pause_ = supports_pause; }
+
+  bool get_supports_pause() const { return this->supports_pause_; }
+
+ protected:
+  bool supports_pause_{false};
+};
+
+class MediaPlayerCall {
+ public:
+  MediaPlayerCall(MediaPlayer *parent) : parent_(parent) {}
+
+  MediaPlayerCall &set_command(MediaPlayerCommand command);
+  MediaPlayerCall &set_command(optional<MediaPlayerCommand> command);
+  MediaPlayerCall &set_command(const std::string &command);
+
+  MediaPlayerCall &set_media_url(const std::string &url);
+
+  MediaPlayerCall &set_volume(float volume);
+
+  void perform();
+
+  const optional<MediaPlayerCommand> &get_command() const { return command_; }
+  const optional<std::string> &get_media_url() const { return media_url_; }
+  const optional<float> &get_volume() const { return volume_; }
+
+ protected:
+  void validate_();
+  MediaPlayer *const parent_;
+  optional<MediaPlayerCommand> command_;
+  optional<std::string> media_url_;
+  optional<float> volume_;
+};
+
+class MediaPlayer : public EntityBase {
+ public:
+  MediaPlayerState state{MEDIA_PLAYER_STATE_NONE};
+  float volume{1.0f};
+
+  MediaPlayerCall make_call() { return MediaPlayerCall(this); }
+
+  void publish_state();
+
+  void add_on_state_callback(std::function<void()> &&callback);
+
+  virtual bool is_muted() const { return false; }
+
+  virtual MediaPlayerTraits get_traits() = 0;
+
+ protected:
+  friend MediaPlayerCall;
+
+  virtual void control(const MediaPlayerCall &call) = 0;
+  uint32_t hash_base() override;
+
+  CallbackManager<void()> state_callback_{};
+};
+
+}  // namespace media_player
+}  // namespace esphome
diff --git a/esphome/core/application.h b/esphome/core/application.h
index cec6e7baa9..453b15822e 100644
--- a/esphome/core/application.h
+++ b/esphome/core/application.h
@@ -45,6 +45,9 @@
 #ifdef USE_LOCK
 #include "esphome/components/lock/lock.h"
 #endif
+#ifdef USE_MEDIA_PLAYER
+#include "esphome/components/media_player/media_player.h"
+#endif
 
 namespace esphome {
 
@@ -111,6 +114,10 @@ class Application {
   void register_lock(lock::Lock *a_lock) { this->locks_.push_back(a_lock); }
 #endif
 
+#ifdef USE_MEDIA_PLAYER
+  void register_media_player(media_player::MediaPlayer *media_player) { this->media_players_.push_back(media_player); }
+#endif
+
   /// Register the component in this Application instance.
   template<class C> C *register_component(C *c) {
     static_assert(std::is_base_of<Component, C>::value, "Only Component subclasses can be registered");
@@ -273,6 +280,15 @@ class Application {
     return nullptr;
   }
 #endif
+#ifdef USE_MEDIA_PLAYER
+  const std::vector<media_player::MediaPlayer *> &get_media_players() { return this->media_players_; }
+  media_player::MediaPlayer *get_media_player_by_key(uint32_t key, bool include_internal = false) {
+    for (auto *obj : this->media_players_)
+      if (obj->get_object_id_hash() == key && (include_internal || !obj->is_internal()))
+        return obj;
+    return nullptr;
+  }
+#endif
 
   Scheduler scheduler;
 
@@ -324,6 +340,9 @@ class Application {
 #ifdef USE_LOCK
   std::vector<lock::Lock *> locks_{};
 #endif
+#ifdef USE_MEDIA_PLAYER
+  std::vector<media_player::MediaPlayer *> media_players_{};
+#endif
 
   std::string name_;
   std::string compilation_time_;
diff --git a/esphome/core/component_iterator.cpp b/esphome/core/component_iterator.cpp
index 4781607a2d..16c56a90c5 100644
--- a/esphome/core/component_iterator.cpp
+++ b/esphome/core/component_iterator.cpp
@@ -231,6 +231,21 @@ void ComponentIterator::advance() {
         }
       }
       break;
+#endif
+#ifdef USE_MEDIA_PLAYER
+    case IteratorState::MEDIA_PLAYER:
+      if (this->at_ >= App.get_media_players().size()) {
+        advance_platform = true;
+      } else {
+        auto *media_player = App.get_media_players()[this->at_];
+        if (media_player->is_internal() && !this->include_internal_) {
+          success = true;
+          break;
+        } else {
+          success = this->on_media_player(media_player);
+        }
+      }
+      break;
 #endif
     case IteratorState::MAX:
       if (this->on_end()) {
@@ -254,4 +269,7 @@ bool ComponentIterator::on_service(api::UserServiceDescriptor *service) { return
 #ifdef USE_ESP32_CAMERA
 bool ComponentIterator::on_camera(esp32_camera::ESP32Camera *camera) { return true; }
 #endif
+#ifdef USE_MEDIA_PLAYER
+bool ComponentIterator::on_media_player(media_player::MediaPlayer *media_player) { return true; }
+#endif
 }  // namespace esphome
diff --git a/esphome/core/component_iterator.h b/esphome/core/component_iterator.h
index bd95fe95e1..e8e048bd73 100644
--- a/esphome/core/component_iterator.h
+++ b/esphome/core/component_iterator.h
@@ -62,6 +62,9 @@ class ComponentIterator {
 #endif
 #ifdef USE_LOCK
   virtual bool on_lock(lock::Lock *a_lock) = 0;
+#endif
+#ifdef USE_MEDIA_PLAYER
+  virtual bool on_media_player(media_player::MediaPlayer *media_player);
 #endif
   virtual bool on_end();
 
@@ -110,6 +113,9 @@ class ComponentIterator {
 #endif
 #ifdef USE_LOCK
     LOCK,
+#endif
+#ifdef USE_MEDIA_PLAYER
+    MEDIA_PLAYER,
 #endif
     MAX,
   } state_{IteratorState::NONE};
diff --git a/esphome/core/controller.cpp b/esphome/core/controller.cpp
index 7d63a3d143..857ee6398f 100644
--- a/esphome/core/controller.cpp
+++ b/esphome/core/controller.cpp
@@ -73,6 +73,12 @@ void Controller::setup_controller(bool include_internal) {
       obj->add_on_state_callback([this, obj]() { this->on_lock_update(obj); });
   }
 #endif
+#ifdef USE_MEDIA_PLAYER
+  for (auto *obj : App.get_media_players()) {
+    if (include_internal || !obj->is_internal())
+      obj->add_on_state_callback([this, obj]() { this->on_media_player_update(obj); });
+  }
+#endif
 }
 
 }  // namespace esphome
diff --git a/esphome/core/controller.h b/esphome/core/controller.h
index 419624a2ae..0966504c43 100644
--- a/esphome/core/controller.h
+++ b/esphome/core/controller.h
@@ -37,6 +37,9 @@
 #ifdef USE_LOCK
 #include "esphome/components/lock/lock.h"
 #endif
+#ifdef USE_MEDIA_PLAYER
+#include "esphome/components/media_player/media_player.h"
+#endif
 
 namespace esphome {
 
@@ -76,6 +79,9 @@ class Controller {
 #ifdef USE_LOCK
   virtual void on_lock_update(lock::Lock *obj){};
 #endif
+#ifdef USE_MEDIA_PLAYER
+  virtual void on_media_player_update(media_player::MediaPlayer *obj){};
+#endif
 };
 
 }  // namespace esphome
diff --git a/esphome/core/defines.h b/esphome/core/defines.h
index c854e2b987..5b1d567aa4 100644
--- a/esphome/core/defines.h
+++ b/esphome/core/defines.h
@@ -29,6 +29,7 @@
 #define USE_LOCK
 #define USE_LOGGER
 #define USE_MDNS
+#define USE_MEDIA_PLAYER
 #define USE_MQTT
 #define USE_NUMBER
 #define USE_OTA_PASSWORD
diff --git a/platformio.ini b/platformio.ini
index 82cf6eeb9a..fb33087a8a 100644
--- a/platformio.ini
+++ b/platformio.ini
@@ -120,10 +120,12 @@ lib_deps =
     HTTPClient                      ; http_request,nextion (Arduino built-in)
     ESPmDNS                         ; mdns (Arduino built-in)
     DNSServer                       ; captive_portal (Arduino built-in)
+    esphome/ESP32-audioI2S@2.1.0    ; i2s_audio
 build_flags =
     ${common:arduino.build_flags}
     -DUSE_ESP32
     -DUSE_ESP32_FRAMEWORK_ARDUINO
+    -DAUDIO_NO_SD_FS                ; i2s_audio
 extra_scripts = post:esphome/components/esp32/post_build.py.script
 
 ; This are common settings for the ESP32 (all variants) using IDF.
diff --git a/tests/test4.yaml b/tests/test4.yaml
index 0e9f14e0d6..ce7a87411e 100644
--- a/tests/test4.yaml
+++ b/tests/test4.yaml
@@ -604,3 +604,12 @@ touchscreen:
       - logger.log:
           format: Touch at (%d, %d)
           args: ["touch.x", "touch.y"]
+
+media_player:
+  - platform: i2s_audio
+    name: ${friendly_name}
+    dac_type: external
+    i2s_lrclk_pin: GPIO26
+    i2s_dout_pin: GPIO25
+    i2s_bclk_pin: GPIO27
+    mute_pin: GPIO14

From 4f57bf786b4b5982a26863e9813df0c60b564bff Mon Sep 17 00:00:00 2001
From: jimtng <2554958+jimtng@users.noreply.github.com>
Date: Fri, 3 Jun 2022 11:51:50 +1000
Subject: [PATCH 36/60] Add mqtt.on_connect and mqtt.on_disconnect triggers
 (#3520)

---
 esphome/components/mqtt/__init__.py     | 26 +++++++++++++++++++++++++
 esphome/components/mqtt/mqtt_client.cpp |  8 ++++++++
 esphome/components/mqtt/mqtt_client.h   | 21 ++++++++++++++++++++
 tests/test1.yaml                        |  7 +++++++
 4 files changed, 62 insertions(+)

diff --git a/esphome/components/mqtt/__init__.py b/esphome/components/mqtt/__init__.py
index b2548d6081..3f9275e231 100644
--- a/esphome/components/mqtt/__init__.py
+++ b/esphome/components/mqtt/__init__.py
@@ -24,6 +24,8 @@ from esphome.const import (
     CONF_LOG_TOPIC,
     CONF_ON_JSON_MESSAGE,
     CONF_ON_MESSAGE,
+    CONF_ON_CONNECT,
+    CONF_ON_DISCONNECT,
     CONF_PASSWORD,
     CONF_PAYLOAD,
     CONF_PAYLOAD_AVAILABLE,
@@ -90,6 +92,10 @@ MQTTMessageTrigger = mqtt_ns.class_(
 MQTTJsonMessageTrigger = mqtt_ns.class_(
     "MQTTJsonMessageTrigger", automation.Trigger.template(cg.JsonObjectConst)
 )
+MQTTConnectTrigger = mqtt_ns.class_("MQTTConnectTrigger", automation.Trigger.template())
+MQTTDisconnectTrigger = mqtt_ns.class_(
+    "MQTTDisconnectTrigger", automation.Trigger.template()
+)
 MQTTComponent = mqtt_ns.class_("MQTTComponent", cg.Component)
 MQTTConnectedCondition = mqtt_ns.class_("MQTTConnectedCondition", Condition)
 
@@ -212,6 +218,18 @@ CONFIG_SCHEMA = cv.All(
             cv.Optional(
                 CONF_REBOOT_TIMEOUT, default="15min"
             ): cv.positive_time_period_milliseconds,
+            cv.Optional(CONF_ON_CONNECT): automation.validate_automation(
+                {
+                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(MQTTConnectTrigger),
+                }
+            ),
+            cv.Optional(CONF_ON_DISCONNECT): automation.validate_automation(
+                {
+                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
+                        MQTTDisconnectTrigger
+                    ),
+                }
+            ),
             cv.Optional(CONF_ON_MESSAGE): automation.validate_automation(
                 {
                     cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(MQTTMessageTrigger),
@@ -362,6 +380,14 @@ async def to_code(config):
         trig = cg.new_Pvariable(conf[CONF_TRIGGER_ID], conf[CONF_TOPIC], conf[CONF_QOS])
         await automation.build_automation(trig, [(cg.JsonObjectConst, "x")], conf)
 
+    for conf in config.get(CONF_ON_CONNECT, []):
+        trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
+        await automation.build_automation(trigger, [], conf)
+
+    for conf in config.get(CONF_ON_DISCONNECT, []):
+        trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
+        await automation.build_automation(trigger, [], conf)
+
 
 MQTT_PUBLISH_ACTION_SCHEMA = cv.Schema(
     {
diff --git a/esphome/components/mqtt/mqtt_client.cpp b/esphome/components/mqtt/mqtt_client.cpp
index 12a43dc232..157504fb41 100644
--- a/esphome/components/mqtt/mqtt_client.cpp
+++ b/esphome/components/mqtt/mqtt_client.cpp
@@ -572,6 +572,14 @@ void MQTTClientComponent::on_shutdown() {
   this->mqtt_backend_.disconnect();
 }
 
+void MQTTClientComponent::set_on_connect(mqtt_on_connect_callback_t &&callback) {
+  this->mqtt_backend_.set_on_connect(std::forward<mqtt_on_connect_callback_t>(callback));
+}
+
+void MQTTClientComponent::set_on_disconnect(mqtt_on_disconnect_callback_t &&callback) {
+  this->mqtt_backend_.set_on_disconnect(std::forward<mqtt_on_disconnect_callback_t>(callback));
+}
+
 #if ASYNC_TCP_SSL_ENABLED
 void MQTTClientComponent::add_ssl_fingerprint(const std::array<uint8_t, SHA1_SIZE> &fingerprint) {
   this->mqtt_backend_.setSecure(true);
diff --git a/esphome/components/mqtt/mqtt_client.h b/esphome/components/mqtt/mqtt_client.h
index 20b174a66f..0310655146 100644
--- a/esphome/components/mqtt/mqtt_client.h
+++ b/esphome/components/mqtt/mqtt_client.h
@@ -19,6 +19,11 @@
 namespace esphome {
 namespace mqtt {
 
+/** Callback for MQTT events.
+ */
+using mqtt_on_connect_callback_t = std::function<MQTTBackend::on_connect_callback_t>;
+using mqtt_on_disconnect_callback_t = std::function<MQTTBackend::on_disconnect_callback_t>;
+
 /** Callback for MQTT subscriptions.
  *
  * First parameter is the topic, the second one is the payload.
@@ -240,6 +245,8 @@ class MQTTClientComponent : public Component {
   void set_username(const std::string &username) { this->credentials_.username = username; }
   void set_password(const std::string &password) { this->credentials_.password = password; }
   void set_client_id(const std::string &client_id) { this->credentials_.client_id = client_id; }
+  void set_on_connect(mqtt_on_connect_callback_t &&callback);
+  void set_on_disconnect(mqtt_on_disconnect_callback_t &&callback);
 
  protected:
   /// Reconnect to the MQTT broker if not already connected.
@@ -328,6 +335,20 @@ class MQTTJsonMessageTrigger : public Trigger<JsonObjectConst> {
   }
 };
 
+class MQTTConnectTrigger : public Trigger<> {
+ public:
+  explicit MQTTConnectTrigger(MQTTClientComponent *&client) {
+    client->set_on_connect([this](bool session_present) { this->trigger(); });
+  }
+};
+
+class MQTTDisconnectTrigger : public Trigger<> {
+ public:
+  explicit MQTTDisconnectTrigger(MQTTClientComponent *&client) {
+    client->set_on_disconnect([this](MQTTClientDisconnectReason reason) { this->trigger(); });
+  }
+};
+
 template<typename... Ts> class MQTTPublishAction : public Action<Ts...> {
  public:
   MQTTPublishAction(MQTTClientComponent *parent) : parent_(parent) {}
diff --git a/tests/test1.yaml b/tests/test1.yaml
index 1b8ed7e370..2a157e3513 100644
--- a/tests/test1.yaml
+++ b/tests/test1.yaml
@@ -168,6 +168,13 @@ mqtt:
                 id: uart0
                 data: !lambda |-
                   return {};
+  on_connect:
+    - light.turn_on: ${roomname}_lights
+    - mqtt.publish:
+        topic: some/topic
+        payload: Hello
+  on_disconnect:
+    - light.turn_off: ${roomname}_lights
 
 i2c:
   sda: 21

From a6ff02a3cf0ae19df13bf669ce8be39cd3516526 Mon Sep 17 00:00:00 2001
From: Joe <jhansche@themeetgroup.com>
Date: Thu, 2 Jun 2022 21:53:20 -0400
Subject: [PATCH 37/60] Refactor clock syncing (#3503)

* Expose `send_local_time()` as public, for use in lambdas.
  This will send the current time configured in `time_id`.
* Add a new `set_clock()` public method, separate from time_id.
  This allows setting the clock manually, without syncing from a Time
  Component. Again this can only be called from ESPHome; i.e.,
  generally from a lambda.
---
 esphome/components/bedjet/bedjet.cpp | 49 ++++++++++++++++------------
 esphome/components/bedjet/bedjet.h   |  3 +-
 2 files changed, 30 insertions(+), 22 deletions(-)

diff --git a/esphome/components/bedjet/bedjet.cpp b/esphome/components/bedjet/bedjet.cpp
index 493685448c..60eef52334 100644
--- a/esphome/components/bedjet/bedjet.cpp
+++ b/esphome/components/bedjet/bedjet.cpp
@@ -308,7 +308,7 @@ void Bedjet::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc
 
 #ifdef USE_TIME
       if (this->time_id_.has_value()) {
-        this->send_local_time_();
+        this->send_local_time();
       }
 #endif
       break;
@@ -463,40 +463,47 @@ uint8_t Bedjet::write_notify_config_descriptor_(bool enable) {
 
 #ifdef USE_TIME
 /** Attempts to sync the local time (via `time_id`) to the BedJet device. */
-void Bedjet::send_local_time_() {
-  if (this->node_state != espbt::ClientState::ESTABLISHED) {
-    ESP_LOGV(TAG, "[%s] Not connected, cannot send time.", this->get_name().c_str());
-    return;
-  }
-  auto *time_id = *this->time_id_;
-  time::ESPTime now = time_id->now();
-  if (now.is_valid()) {
-    uint8_t hour = now.hour;
-    uint8_t minute = now.minute;
-    BedjetPacket *pkt = this->codec_->get_set_time_request(hour, minute);
-    auto status = this->write_bedjet_packet_(pkt);
-    if (status) {
-      ESP_LOGW(TAG, "Failed setting BedJet clock: %d", status);
-    } else {
-      ESP_LOGD(TAG, "[%s] BedJet clock set to: %d:%02d", this->get_name().c_str(), hour, minute);
+void Bedjet::send_local_time() {
+  if (this->time_id_.has_value()) {
+    auto *time_id = *this->time_id_;
+    time::ESPTime now = time_id->now();
+    if (now.is_valid()) {
+      this->set_clock(now.hour, now.minute);
+      ESP_LOGD(TAG, "Using time component to set BedJet clock: %d:%02d", now.hour, now.minute);
     }
+  } else {
+    ESP_LOGI(TAG, "`time_id` is not configured: will not sync BedJet clock.");
   }
 }
 
 /** Initializes time sync callbacks to support syncing current time to the BedJet. */
 void Bedjet::setup_time_() {
   if (this->time_id_.has_value()) {
-    this->send_local_time_();
+    this->send_local_time();
     auto *time_id = *this->time_id_;
-    time_id->add_on_time_sync_callback([this] { this->send_local_time_(); });
-    time::ESPTime now = time_id->now();
-    ESP_LOGD(TAG, "Using time component to set BedJet clock: %d:%02d", now.hour, now.minute);
+    time_id->add_on_time_sync_callback([this] { this->send_local_time(); });
   } else {
     ESP_LOGI(TAG, "`time_id` is not configured: will not sync BedJet clock.");
   }
 }
 #endif
 
+/** Attempt to set the BedJet device's clock to the specified time. */
+void Bedjet::set_clock(uint8_t hour, uint8_t minute) {
+  if (this->node_state != espbt::ClientState::ESTABLISHED) {
+    ESP_LOGV(TAG, "[%s] Not connected, cannot send time.", this->get_name().c_str());
+    return;
+  }
+
+  BedjetPacket *pkt = this->codec_->get_set_time_request(hour, minute);
+  auto status = this->write_bedjet_packet_(pkt);
+  if (status) {
+    ESP_LOGW(TAG, "Failed setting BedJet clock: %d", status);
+  } else {
+    ESP_LOGD(TAG, "[%s] BedJet clock set to: %d:%02d", this->get_name().c_str(), hour, minute);
+  }
+}
+
 /** Writes one BedjetPacket to the BLE client on the BEDJET_COMMAND_UUID. */
 uint8_t Bedjet::write_bedjet_packet_(BedjetPacket *pkt) {
   if (this->node_state != espbt::ClientState::ESTABLISHED) {
diff --git a/esphome/components/bedjet/bedjet.h b/esphome/components/bedjet/bedjet.h
index 5d66f6f252..cdb7d21d1a 100644
--- a/esphome/components/bedjet/bedjet.h
+++ b/esphome/components/bedjet/bedjet.h
@@ -38,7 +38,9 @@ class Bedjet : public climate::Climate, public esphome::ble_client::BLEClientNod
 
 #ifdef USE_TIME
   void set_time_id(time::RealTimeClock *time_id) { this->time_id_ = time_id; }
+  void send_local_time();
 #endif
+  void set_clock(uint8_t hour, uint8_t minute);
   void set_status_timeout(uint32_t timeout) { this->timeout_ = timeout; }
   /** Sets the default strategy to use for climate::CLIMATE_MODE_HEAT. */
   void set_heating_mode(BedjetHeatMode mode) { this->heating_mode_ = mode; }
@@ -90,7 +92,6 @@ class Bedjet : public climate::Climate, public esphome::ble_client::BLEClientNod
 
 #ifdef USE_TIME
   void setup_time_();
-  void send_local_time_();
   optional<time::RealTimeClock *> time_id_{};
 #endif
 

From 6349b5f65486ddad6b008d326406641beff270a0 Mon Sep 17 00:00:00 2001
From: Eric van Blokland <8546466+Emrvb@users.noreply.github.com>
Date: Fri, 3 Jun 2022 05:37:04 +0200
Subject: [PATCH 38/60] Added RC6 protocol support (#3514)

---
 esphome/components/remote_base/__init__.py    |  42 ++++
 .../components/remote_base/rc6_protocol.cpp   | 181 ++++++++++++++++++
 esphome/components/remote_base/rc6_protocol.h |  46 +++++
 3 files changed, 269 insertions(+)
 create mode 100644 esphome/components/remote_base/rc6_protocol.cpp
 create mode 100644 esphome/components/remote_base/rc6_protocol.h

diff --git a/esphome/components/remote_base/__init__.py b/esphome/components/remote_base/__init__.py
index f1b3e32c18..165da95d67 100644
--- a/esphome/components/remote_base/__init__.py
+++ b/esphome/components/remote_base/__init__.py
@@ -728,6 +728,48 @@ async def rc5_action(var, config, args):
     cg.add(var.set_command(template_))
 
 
+# RC6
+RC6Data, RC6BinarySensor, RC6Trigger, RC6Action, RC6Dumper = declare_protocol("RC6")
+RC6_SCHEMA = cv.Schema(
+    {
+        cv.Required(CONF_ADDRESS): cv.hex_uint8_t,
+        cv.Required(CONF_COMMAND): cv.hex_uint8_t,
+    }
+)
+
+
+@register_binary_sensor("rc6", RC6BinarySensor, RC6_SCHEMA)
+def rc6_binary_sensor(var, config):
+    cg.add(
+        var.set_data(
+            cg.StructInitializer(
+                RC6Data,
+                ("device", config[CONF_DEVICE]),
+                ("address", config[CONF_ADDRESS]),
+                ("command", config[CONF_COMMAND]),
+            )
+        )
+    )
+
+
+@register_trigger("rc6", RC6Trigger, RC6Data)
+def rc6_trigger(var, config):
+    pass
+
+
+@register_dumper("rc6", RC6Dumper)
+def rc6_dumper(var, config):
+    pass
+
+
+@register_action("rc6", RC6Action, RC6_SCHEMA)
+async def rc6_action(var, config, args):
+    template_ = await cg.templatable(config[CONF_ADDRESS], args, cg.uint8)
+    cg.add(var.set_address(template_))
+    template_ = await cg.templatable(config[CONF_COMMAND], args, cg.uint8)
+    cg.add(var.set_command(template_))
+
+
 # RC Switch Raw
 RC_SWITCH_TIMING_SCHEMA = cv.All([cv.uint8_t], cv.Length(min=2, max=2))
 
diff --git a/esphome/components/remote_base/rc6_protocol.cpp b/esphome/components/remote_base/rc6_protocol.cpp
new file mode 100644
index 0000000000..ad12c7c208
--- /dev/null
+++ b/esphome/components/remote_base/rc6_protocol.cpp
@@ -0,0 +1,181 @@
+#include "rc6_protocol.h"
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace remote_base {
+
+static const char *const RC6_TAG = "remote.rc6";
+
+static const uint16_t RC6_FREQ = 36000;
+static const uint16_t RC6_UNIT = 444;
+static const uint16_t RC6_HEADER_MARK = (6 * RC6_UNIT);
+static const uint16_t RC6_HEADER_SPACE = (2 * RC6_UNIT);
+static const uint16_t RC6_MODE_MASK = 0x07;
+
+void RC6Protocol::encode(RemoteTransmitData *dst, const RC6Data &data) {
+  dst->reserve(44);
+  dst->set_carrier_frequency(RC6_FREQ);
+
+  // Encode header
+  dst->item(RC6_HEADER_MARK, RC6_HEADER_SPACE);
+
+  int32_t next{0};
+
+  // Encode startbit+mode
+  uint8_t header{static_cast<uint8_t>((1 << 3) | data.mode)};
+
+  for (uint8_t mask = 0x8; mask; mask >>= 1) {
+    if (header & mask) {
+      if (next < 0) {
+        dst->space(-next);
+        next = 0;
+      }
+      if (next >= 0) {
+        next = next + RC6_UNIT;
+        dst->mark(next);
+        next = -RC6_UNIT;
+      }
+    } else {
+      if (next > 0) {
+        dst->mark(next);
+        next = 0;
+      }
+      if (next <= 0) {
+        next = next - RC6_UNIT;
+        dst->space(-next);
+        next = RC6_UNIT;
+      }
+    }
+  }
+
+  // Toggle
+  if (data.toggle) {
+    if (next < 0) {
+      dst->space(-next);
+      next = 0;
+    }
+    if (next >= 0) {
+      next = next + RC6_UNIT * 2;
+      dst->mark(next);
+      next = -RC6_UNIT * 2;
+    }
+  } else {
+    if (next > 0) {
+      dst->mark(next);
+      next = 0;
+    }
+    if (next <= 0) {
+      next = next - RC6_UNIT * 2;
+      dst->space(-next);
+      next = RC6_UNIT * 2;
+    }
+  }
+
+  // Encode data
+  uint16_t raw{static_cast<uint16_t>((data.address << 8) | data.command)};
+
+  for (uint16_t mask = 0x8000; mask; mask >>= 1) {
+    if (raw & mask) {
+      if (next < 0) {
+        dst->space(-next);
+        next = 0;
+      }
+      if (next >= 0) {
+        next = next + RC6_UNIT;
+        dst->mark(next);
+        next = -RC6_UNIT;
+      }
+    } else {
+      if (next > 0) {
+        dst->mark(next);
+        next = 0;
+      }
+      if (next <= 0) {
+        next = next - RC6_UNIT;
+        dst->space(-next);
+        next = RC6_UNIT;
+      }
+    }
+  }
+
+  if (next > 0) {
+    dst->mark(next);
+  } else {
+    dst->space(-next);
+  }
+}
+
+optional<RC6Data> RC6Protocol::decode(RemoteReceiveData src) {
+  RC6Data data{
+      .mode = 0,
+      .toggle = 0,
+      .address = 0,
+      .command = 0,
+  };
+
+  // Check if header matches
+  if (!src.expect_item(RC6_HEADER_MARK, RC6_HEADER_SPACE)) {
+    return {};
+  }
+
+  uint8_t bit{1};
+  uint8_t offset{0};
+  uint8_t header{0};
+  uint32_t buffer{0};
+
+  // Startbit + mode
+  while (offset < 4) {
+    bit = src.peek() > 0;
+    header = header + (bit << (3 - offset++));
+    src.advance();
+
+    if (src.peek_mark(RC6_UNIT) || src.peek_space(RC6_UNIT)) {
+      src.advance();
+    } else if (offset == 4) {
+      break;
+    } else if (!src.peek_mark(RC6_UNIT * 2) && !src.peek_space(RC6_UNIT * 2)) {
+      return {};
+    }
+  }
+
+  data.mode = header & RC6_MODE_MASK;
+
+  if (data.mode != 0) {
+    return {};  // I dont have a device to test other modes
+  }
+
+  // Toggle
+  data.toggle = src.peek() > 0;
+  src.advance();
+  if (src.peek_mark(RC6_UNIT * 2) || src.peek_space(RC6_UNIT * 2)) {
+    src.advance();
+  }
+
+  // Data
+  offset = 0;
+  while (offset < 16) {
+    bit = src.peek() > 0;
+    buffer = buffer + (bit << (15 - offset++));
+    src.advance();
+
+    if (offset == 16) {
+      break;
+    } else if (src.peek_mark(RC6_UNIT) || src.peek_space(RC6_UNIT)) {
+      src.advance();
+    } else if (!src.peek_mark(RC6_UNIT * 2) && !src.peek_space(RC6_UNIT * 2)) {
+      return {};
+    }
+  }
+
+  data.address = (0xFF00 & buffer) >> 8;
+  data.command = (0x00FF & buffer);
+  return data;
+}
+
+void RC6Protocol::dump(const RC6Data &data) {
+  ESP_LOGD(RC6_TAG, "Received RC6: mode=0x%X, address=0x%02X, command=0x%02X, toggle=0x%X", data.mode, data.address,
+           data.command, data.toggle);
+}
+
+}  // namespace remote_base
+}  // namespace esphome
diff --git a/esphome/components/remote_base/rc6_protocol.h b/esphome/components/remote_base/rc6_protocol.h
new file mode 100644
index 0000000000..980509a2fc
--- /dev/null
+++ b/esphome/components/remote_base/rc6_protocol.h
@@ -0,0 +1,46 @@
+#pragma once
+
+#include "remote_base.h"
+
+namespace esphome {
+namespace remote_base {
+
+struct RC6Data {
+  uint8_t mode : 3;
+  uint8_t toggle : 1;
+  uint8_t address;
+  uint8_t command;
+
+  bool operator==(const RC6Data &rhs) const { return address == rhs.address && command == rhs.command; }
+};
+
+class RC6Protocol : public RemoteProtocol<RC6Data> {
+ public:
+  void encode(RemoteTransmitData *dst, const RC6Data &data) override;
+  optional<RC6Data> decode(RemoteReceiveData src) override;
+  void dump(const RC6Data &data) override;
+};
+
+DECLARE_REMOTE_PROTOCOL(RC6)
+
+template<typename... Ts> class RC6Action : public RemoteTransmitterActionBase<Ts...> {
+ public:
+  TEMPLATABLE_VALUE(uint8_t, address)
+  TEMPLATABLE_VALUE(uint8_t, command)
+
+  void encode(RemoteTransmitData *dst, Ts... x) {
+    RC6Data data{};
+    data.mode = 0;
+    data.toggle = this->toggle_;
+    data.address = this->address_.value(x...);
+    data.command = this->command_.value(x...);
+    RC6Protocol().encode(dst, data);
+    this->toggle_ = !this->toggle_;
+  }
+
+ protected:
+  uint8_t toggle_{0};
+};
+
+}  // namespace remote_base
+}  // namespace esphome

From d0dda489321db07595cc15f93f5fa376f278ada0 Mon Sep 17 00:00:00 2001
From: guillempages <guillempages@users.noreply.github.com>
Date: Fri, 3 Jun 2022 05:39:04 +0200
Subject: [PATCH 39/60] Add display_type property to DisplayBuffer (#3430)

Co-authored-by: Jesse Hills <3060199+jesserockz@users.noreply.github.com>
---
 .../addressable_light/addressable_light_display.h     |  2 ++
 esphome/components/display/display_buffer.h           | 11 +++++++++++
 esphome/components/ili9341/ili9341_display.h          |  2 ++
 esphome/components/inkplate6/inkplate.h               |  4 ++++
 esphome/components/max7219digit/max7219digit.h        |  2 ++
 esphome/components/pcd8544/pcd_8544.h                 |  2 ++
 esphome/components/ssd1306_base/ssd1306_base.h        |  2 ++
 esphome/components/ssd1322_base/ssd1322_base.h        |  2 ++
 esphome/components/ssd1325_base/ssd1325_base.h        |  2 ++
 esphome/components/ssd1327_base/ssd1327_base.h        |  2 ++
 esphome/components/ssd1331_base/ssd1331_base.h        |  2 ++
 esphome/components/ssd1351_base/ssd1351_base.h        |  2 ++
 esphome/components/st7735/st7735.h                    |  2 ++
 esphome/components/st7789v/st7789v.h                  |  2 ++
 esphome/components/st7920/st7920.h                    |  2 ++
 .../components/waveshare_epaper/waveshare_epaper.h    |  2 ++
 16 files changed, 43 insertions(+)

diff --git a/esphome/components/addressable_light/addressable_light_display.h b/esphome/components/addressable_light/addressable_light_display.h
index 163faf27b0..dfafe9d98d 100644
--- a/esphome/components/addressable_light/addressable_light_display.h
+++ b/esphome/components/addressable_light/addressable_light_display.h
@@ -40,6 +40,8 @@ class AddressableLightDisplay : public display::DisplayBuffer, public PollingCom
   void setup() override;
   void display();
 
+  display::DisplayType get_display_type() override { return display::DisplayType::DISPLAY_TYPE_COLOR; }
+
  protected:
   int get_width_internal() override;
   int get_height_internal() override;
diff --git a/esphome/components/display/display_buffer.h b/esphome/components/display/display_buffer.h
index 33f55aa3d1..dc6bbdf350 100644
--- a/esphome/components/display/display_buffer.h
+++ b/esphome/components/display/display_buffer.h
@@ -85,6 +85,12 @@ enum ImageType {
   IMAGE_TYPE_RGB565 = 4,
 };
 
+enum DisplayType {
+  DISPLAY_TYPE_BINARY = 1,
+  DISPLAY_TYPE_GRAYSCALE = 2,
+  DISPLAY_TYPE_COLOR = 3,
+};
+
 enum DisplayRotation {
   DISPLAY_ROTATION_0_DEGREES = 0,
   DISPLAY_ROTATION_90_DEGREES = 90,
@@ -361,6 +367,11 @@ class DisplayBuffer {
   virtual int get_width_internal() = 0;
   DisplayRotation get_rotation() const { return this->rotation_; }
 
+  /** Get the type of display that the buffer corresponds to. In case of dynamically configurable displays,
+   * returns the type the display is currently configured to.
+   */
+  virtual DisplayType get_display_type() = 0;
+
  protected:
   void vprintf_(int x, int y, Font *font, Color color, TextAlign align, const char *format, va_list arg);
 
diff --git a/esphome/components/ili9341/ili9341_display.h b/esphome/components/ili9341/ili9341_display.h
index 6014dbf9a6..e568eead40 100644
--- a/esphome/components/ili9341/ili9341_display.h
+++ b/esphome/components/ili9341/ili9341_display.h
@@ -48,6 +48,8 @@ class ILI9341Display : public PollingComponent,
     this->initialize();
   }
 
+  display::DisplayType get_display_type() override { return display::DisplayType::DISPLAY_TYPE_COLOR; }
+
  protected:
   void draw_absolute_pixel_internal(int x, int y, Color color) override;
   void setup_pins_();
diff --git a/esphome/components/inkplate6/inkplate.h b/esphome/components/inkplate6/inkplate.h
index 9355154c5a..e650b57631 100644
--- a/esphome/components/inkplate6/inkplate.h
+++ b/esphome/components/inkplate6/inkplate.h
@@ -86,6 +86,10 @@ class Inkplate6 : public PollingComponent, public display::DisplayBuffer, public
 
   void block_partial() { this->block_partial_ = true; }
 
+  display::DisplayType get_display_type() override {
+    return get_greyscale() ? display::DisplayType::DISPLAY_TYPE_GRAYSCALE : display::DisplayType::DISPLAY_TYPE_BINARY;
+  }
+
  protected:
   void draw_absolute_pixel_internal(int x, int y, Color color) override;
   void display1b_();
diff --git a/esphome/components/max7219digit/max7219digit.h b/esphome/components/max7219digit/max7219digit.h
index 3bf934632f..3552c6b9d5 100644
--- a/esphome/components/max7219digit/max7219digit.h
+++ b/esphome/components/max7219digit/max7219digit.h
@@ -93,6 +93,8 @@ class MAX7219Component : public PollingComponent,
   uint8_t strftimedigit(const char *format, time::ESPTime time) __attribute__((format(strftime, 2, 0)));
 #endif
 
+  display::DisplayType get_display_type() override { return display::DisplayType::DISPLAY_TYPE_BINARY; }
+
  protected:
   void send_byte_(uint8_t a_register, uint8_t data);
   void send_to_all_(uint8_t a_register, uint8_t data);
diff --git a/esphome/components/pcd8544/pcd_8544.h b/esphome/components/pcd8544/pcd_8544.h
index b57662bbd9..9a69a9fec7 100644
--- a/esphome/components/pcd8544/pcd_8544.h
+++ b/esphome/components/pcd8544/pcd_8544.h
@@ -52,6 +52,8 @@ class PCD8544 : public PollingComponent,
     this->initialize();
   }
 
+  display::DisplayType get_display_type() override { return display::DisplayType::DISPLAY_TYPE_BINARY; }
+
  protected:
   void draw_absolute_pixel_internal(int x, int y, Color color) override;
 
diff --git a/esphome/components/ssd1306_base/ssd1306_base.h b/esphome/components/ssd1306_base/ssd1306_base.h
index 5ab68143c7..2f5baffb69 100644
--- a/esphome/components/ssd1306_base/ssd1306_base.h
+++ b/esphome/components/ssd1306_base/ssd1306_base.h
@@ -48,6 +48,8 @@ class SSD1306 : public PollingComponent, public display::DisplayBuffer {
   float get_setup_priority() const override { return setup_priority::PROCESSOR; }
   void fill(Color color) override;
 
+  display::DisplayType get_display_type() override { return display::DisplayType::DISPLAY_TYPE_BINARY; }
+
  protected:
   virtual void command(uint8_t value) = 0;
   virtual void write_display_data() = 0;
diff --git a/esphome/components/ssd1322_base/ssd1322_base.h b/esphome/components/ssd1322_base/ssd1322_base.h
index 6a790c0199..d672b298d6 100644
--- a/esphome/components/ssd1322_base/ssd1322_base.h
+++ b/esphome/components/ssd1322_base/ssd1322_base.h
@@ -30,6 +30,8 @@ class SSD1322 : public PollingComponent, public display::DisplayBuffer {
   float get_setup_priority() const override { return setup_priority::PROCESSOR; }
   void fill(Color color) override;
 
+  display::DisplayType get_display_type() override { return display::DisplayType::DISPLAY_TYPE_GRAYSCALE; }
+
  protected:
   virtual void command(uint8_t value) = 0;
   virtual void data(uint8_t value) = 0;
diff --git a/esphome/components/ssd1325_base/ssd1325_base.h b/esphome/components/ssd1325_base/ssd1325_base.h
index cca9412c43..8ba6a56c8b 100644
--- a/esphome/components/ssd1325_base/ssd1325_base.h
+++ b/esphome/components/ssd1325_base/ssd1325_base.h
@@ -35,6 +35,8 @@ class SSD1325 : public PollingComponent, public display::DisplayBuffer {
   float get_setup_priority() const override { return setup_priority::PROCESSOR; }
   void fill(Color color) override;
 
+  display::DisplayType get_display_type() override { return display::DisplayType::DISPLAY_TYPE_BINARY; }
+
  protected:
   virtual void command(uint8_t value) = 0;
   virtual void write_display_data() = 0;
diff --git a/esphome/components/ssd1327_base/ssd1327_base.h b/esphome/components/ssd1327_base/ssd1327_base.h
index 35b021c71b..5639beb828 100644
--- a/esphome/components/ssd1327_base/ssd1327_base.h
+++ b/esphome/components/ssd1327_base/ssd1327_base.h
@@ -30,6 +30,8 @@ class SSD1327 : public PollingComponent, public display::DisplayBuffer {
   float get_setup_priority() const override { return setup_priority::PROCESSOR; }
   void fill(Color color) override;
 
+  display::DisplayType get_display_type() override { return display::DisplayType::DISPLAY_TYPE_GRAYSCALE; }
+
  protected:
   virtual void command(uint8_t value) = 0;
   virtual void write_display_data() = 0;
diff --git a/esphome/components/ssd1331_base/ssd1331_base.h b/esphome/components/ssd1331_base/ssd1331_base.h
index b889a47fbe..be5713f208 100644
--- a/esphome/components/ssd1331_base/ssd1331_base.h
+++ b/esphome/components/ssd1331_base/ssd1331_base.h
@@ -25,6 +25,8 @@ class SSD1331 : public PollingComponent, public display::DisplayBuffer {
   float get_setup_priority() const override { return setup_priority::PROCESSOR; }
   void fill(Color color) override;
 
+  display::DisplayType get_display_type() override { return display::DisplayType::DISPLAY_TYPE_COLOR; }
+
  protected:
   virtual void command(uint8_t value) = 0;
   virtual void write_display_data() = 0;
diff --git a/esphome/components/ssd1351_base/ssd1351_base.h b/esphome/components/ssd1351_base/ssd1351_base.h
index 422e601f8b..2f1e0237cd 100644
--- a/esphome/components/ssd1351_base/ssd1351_base.h
+++ b/esphome/components/ssd1351_base/ssd1351_base.h
@@ -31,6 +31,8 @@ class SSD1351 : public PollingComponent, public display::DisplayBuffer {
   float get_setup_priority() const override { return setup_priority::PROCESSOR; }
   void fill(Color color) override;
 
+  display::DisplayType get_display_type() override { return display::DisplayType::DISPLAY_TYPE_COLOR; }
+
  protected:
   virtual void command(uint8_t value) = 0;
   virtual void data(uint8_t value) = 0;
diff --git a/esphome/components/st7735/st7735.h b/esphome/components/st7735/st7735.h
index c049fb9e83..3baa9b083a 100644
--- a/esphome/components/st7735/st7735.h
+++ b/esphome/components/st7735/st7735.h
@@ -53,6 +53,8 @@ class ST7735 : public PollingComponent,
   void set_dc_pin(GPIOPin *value) { dc_pin_ = value; }
   size_t get_buffer_length();
 
+  display::DisplayType get_display_type() override { return display::DisplayType::DISPLAY_TYPE_COLOR; }
+
  protected:
   void sendcommand_(uint8_t cmd, const uint8_t *data_bytes, uint8_t num_data_bytes);
   void senddata_(const uint8_t *data_bytes, uint8_t num_data_bytes);
diff --git a/esphome/components/st7789v/st7789v.h b/esphome/components/st7789v/st7789v.h
index 2aef043ba0..e655d22e2b 100644
--- a/esphome/components/st7789v/st7789v.h
+++ b/esphome/components/st7789v/st7789v.h
@@ -126,6 +126,8 @@ class ST7789V : public PollingComponent,
 
   void write_display_data();
 
+  display::DisplayType get_display_type() override { return display::DisplayType::DISPLAY_TYPE_COLOR; }
+
  protected:
   GPIOPin *dc_pin_;
   GPIOPin *reset_pin_{nullptr};
diff --git a/esphome/components/st7920/st7920.h b/esphome/components/st7920/st7920.h
index 5f32e7ff23..c00b7cf5e0 100644
--- a/esphome/components/st7920/st7920.h
+++ b/esphome/components/st7920/st7920.h
@@ -29,6 +29,8 @@ class ST7920 : public PollingComponent,
   void fill(Color color) override;
   void write_display_data();
 
+  display::DisplayType get_display_type() override { return display::DisplayType::DISPLAY_TYPE_BINARY; }
+
  protected:
   void draw_absolute_pixel_internal(int x, int y, Color color) override;
   int get_height_internal() override;
diff --git a/esphome/components/waveshare_epaper/waveshare_epaper.h b/esphome/components/waveshare_epaper/waveshare_epaper.h
index 7a88fecbdb..e613899149 100644
--- a/esphome/components/waveshare_epaper/waveshare_epaper.h
+++ b/esphome/components/waveshare_epaper/waveshare_epaper.h
@@ -36,6 +36,8 @@ class WaveshareEPaper : public PollingComponent,
 
   void on_safe_shutdown() override;
 
+  display::DisplayType get_display_type() override { return display::DisplayType::DISPLAY_TYPE_BINARY; }
+
  protected:
   void draw_absolute_pixel_internal(int x, int y, Color color) override;
 

From dd24ffa24e36d4bb8d8d5371bcc3b43c86fe8687 Mon Sep 17 00:00:00 2001
From: Carlos Garcia Saura <CarlosGS@users.noreply.github.com>
Date: Fri, 3 Jun 2022 06:07:35 +0200
Subject: [PATCH 40/60] Correct ADC auto-range for ESP32-S2 variant (13 bit
 adc) (#3158)

Co-authored-by: Otto Winter <otto@otto-winter.com>
---
 esphome/components/adc/adc_sensor.cpp | 45 +++++++++++++++++----------
 1 file changed, 28 insertions(+), 17 deletions(-)

diff --git a/esphome/components/adc/adc_sensor.cpp b/esphome/components/adc/adc_sensor.cpp
index ca87c8d11f..daa1d3c5cf 100644
--- a/esphome/components/adc/adc_sensor.cpp
+++ b/esphome/components/adc/adc_sensor.cpp
@@ -15,10 +15,21 @@ namespace esphome {
 namespace adc {
 
 static const char *const TAG = "adc";
-// 13 bits for S3 / 12 bit for all other esp32 variants
-// create a const to avoid the repated cast to enum
+
+// 13bit for S2, and 12bit for all other esp32 variants
 #ifdef USE_ESP32
 static const adc_bits_width_t ADC_WIDTH_MAX_SOC_BITS = static_cast<adc_bits_width_t>(ADC_WIDTH_MAX - 1);
+
+#ifndef SOC_ADC_RTC_MAX_BITWIDTH
+#if USE_ESP32_VARIANT_ESP32S2
+static const int SOC_ADC_RTC_MAX_BITWIDTH = 13;
+#else
+static const int SOC_ADC_RTC_MAX_BITWIDTH = 12;
+#endif
+#endif
+
+static const int ADC_MAX = (1 << SOC_ADC_RTC_MAX_BITWIDTH) - 1;    // 4095 (12 bit) or 8191 (13 bit)
+static const int ADC_HALF = (1 << SOC_ADC_RTC_MAX_BITWIDTH) >> 1;  // 2048 (12 bit) or 4096 (13 bit)
 #endif
 
 void ADCSensor::setup() {
@@ -75,16 +86,16 @@ void ADCSensor::dump_config() {
   } else {
     switch (this->attenuation_) {
       case ADC_ATTEN_DB_0:
-        ESP_LOGCONFIG(TAG, " Attenuation: 0db (max 1.1V)");
+        ESP_LOGCONFIG(TAG, " Attenuation: 0db");
         break;
       case ADC_ATTEN_DB_2_5:
-        ESP_LOGCONFIG(TAG, " Attenuation: 2.5db (max 1.5V)");
+        ESP_LOGCONFIG(TAG, " Attenuation: 2.5db");
         break;
       case ADC_ATTEN_DB_6:
-        ESP_LOGCONFIG(TAG, " Attenuation: 6db (max 2.2V)");
+        ESP_LOGCONFIG(TAG, " Attenuation: 6db");
         break;
       case ADC_ATTEN_DB_11:
-        ESP_LOGCONFIG(TAG, " Attenuation: 11db (max 3.9V)");
+        ESP_LOGCONFIG(TAG, " Attenuation: 11db");
         break;
       default:  // This is to satisfy the unused ADC_ATTEN_MAX
         break;
@@ -129,16 +140,16 @@ float ADCSensor::sample() {
     return mv / 1000.0f;
   }
 
-  int raw11, raw6 = 4095, raw2 = 4095, raw0 = 4095;
+  int raw11, raw6 = ADC_MAX, raw2 = ADC_MAX, raw0 = ADC_MAX;
   adc1_config_channel_atten(channel_, ADC_ATTEN_DB_11);
   raw11 = adc1_get_raw(channel_);
-  if (raw11 < 4095) {
+  if (raw11 < ADC_MAX) {
     adc1_config_channel_atten(channel_, ADC_ATTEN_DB_6);
     raw6 = adc1_get_raw(channel_);
-    if (raw6 < 4095) {
+    if (raw6 < ADC_MAX) {
       adc1_config_channel_atten(channel_, ADC_ATTEN_DB_2_5);
       raw2 = adc1_get_raw(channel_);
-      if (raw2 < 4095) {
+      if (raw2 < ADC_MAX) {
         adc1_config_channel_atten(channel_, ADC_ATTEN_DB_0);
         raw0 = adc1_get_raw(channel_);
       }
@@ -154,15 +165,15 @@ float ADCSensor::sample() {
   uint32_t mv2 = esp_adc_cal_raw_to_voltage(raw2, &cal_characteristics_[(int) ADC_ATTEN_DB_2_5]);
   uint32_t mv0 = esp_adc_cal_raw_to_voltage(raw0, &cal_characteristics_[(int) ADC_ATTEN_DB_0]);
 
-  // Contribution of each value, in range 0-2048
-  uint32_t c11 = std::min(raw11, 2048);
-  uint32_t c6 = 2048 - std::abs(raw6 - 2048);
-  uint32_t c2 = 2048 - std::abs(raw2 - 2048);
-  uint32_t c0 = std::min(4095 - raw0, 2048);
-  // max theoretical csum value is 2048*4 = 8192
+  // Contribution of each value, in range 0-2048 (12 bit ADC) or 0-4096 (13 bit ADC)
+  uint32_t c11 = std::min(raw11, ADC_HALF);
+  uint32_t c6 = ADC_HALF - std::abs(raw6 - ADC_HALF);
+  uint32_t c2 = ADC_HALF - std::abs(raw2 - ADC_HALF);
+  uint32_t c0 = std::min(ADC_MAX - raw0, ADC_HALF);
+  // max theoretical csum value is 4096*4 = 16384
   uint32_t csum = c11 + c6 + c2 + c0;
 
-  // each mv is max 3900; so max value is 3900*2048*4, fits in unsigned
+  // each mv is max 3900; so max value is 3900*4096*4, fits in unsigned32
   uint32_t mv_scaled = (mv11 * c11) + (mv6 * c6) + (mv2 * c2) + (mv0 * c0);
   return mv_scaled / (float) (csum * 1000U);
 }

From f8969605e8a025d1c907b0f2bdbd9b04869a4a49 Mon Sep 17 00:00:00 2001
From: Maurice Makaay <account+github@makaay.nl>
Date: Tue, 7 Jun 2022 01:36:54 +0200
Subject: [PATCH 41/60] Suppress first rotary encoder event (#3532)

Co-authored-by: Maurice Makaay <mmakaay1@xs4all.net>
---
 esphome/components/rotary_encoder/rotary_encoder.cpp | 3 ++-
 esphome/components/rotary_encoder/rotary_encoder.h   | 1 +
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/esphome/components/rotary_encoder/rotary_encoder.cpp b/esphome/components/rotary_encoder/rotary_encoder.cpp
index c5e9cec596..7440214b1c 100644
--- a/esphome/components/rotary_encoder/rotary_encoder.cpp
+++ b/esphome/components/rotary_encoder/rotary_encoder.cpp
@@ -103,7 +103,7 @@ void IRAM_ATTR HOT RotaryEncoderSensorStore::gpio_intr(RotaryEncoderSensorStore
     rotation_dir = -1;
   }
 
-  if (rotation_dir != 0) {
+  if (rotation_dir != 0 && !arg->first_read) {
     auto *first_zero = std::find(arg->rotation_events.begin(), arg->rotation_events.end(), 0);  // find first zero
     if (first_zero == arg->rotation_events.begin()  // are we at the start (first event this loop iteration)
         || std::signbit(*std::prev(first_zero)) !=
@@ -119,6 +119,7 @@ void IRAM_ATTR HOT RotaryEncoderSensorStore::gpio_intr(RotaryEncoderSensorStore
       *std::prev(first_zero) += rotation_dir;  // store the rotation into the previous slot
     }
   }
+  arg->first_read = false;
 
   arg->state = new_state;
 }
diff --git a/esphome/components/rotary_encoder/rotary_encoder.h b/esphome/components/rotary_encoder/rotary_encoder.h
index a69d738fa8..deba3d952d 100644
--- a/esphome/components/rotary_encoder/rotary_encoder.h
+++ b/esphome/components/rotary_encoder/rotary_encoder.h
@@ -34,6 +34,7 @@ struct RotaryEncoderSensorStore {
   int32_t max_value{INT32_MAX};
   int32_t last_read{0};
   uint8_t state{0};
+  bool first_read{true};
 
   std::array<int8_t, 8> rotation_events{};
   bool rotation_events_overflow{false};

From 612822490b9a92167f8d11f1af622d6fd93fe31d Mon Sep 17 00:00:00 2001
From: Maurice Makaay <account+github@makaay.nl>
Date: Tue, 7 Jun 2022 02:08:29 +0200
Subject: [PATCH 42/60] Fix endless 'WiFi Unknown connection status 0' loop
 (#3530)

Co-authored-by: Maurice Makaay <mmakaay1@xs4all.net>
---
 esphome/components/wifi/wifi_component.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/esphome/components/wifi/wifi_component.cpp b/esphome/components/wifi/wifi_component.cpp
index 1348b54b37..0ac227cd82 100644
--- a/esphome/components/wifi/wifi_component.cpp
+++ b/esphome/components/wifi/wifi_component.cpp
@@ -555,6 +555,7 @@ void WiFiComponent::check_connecting_finished() {
   }
 
   ESP_LOGW(TAG, "WiFi Unknown connection status %d", (int) status);
+  this->retry_connect();
 }
 
 void WiFiComponent::retry_connect() {

From dd470d4197001f4bb42d19a01e34b7369a7f7bd5 Mon Sep 17 00:00:00 2001
From: Samuel Sieb <samuel-github@sieb.net>
Date: Tue, 7 Jun 2022 03:42:13 -0700
Subject: [PATCH 43/60] support rotated ILI9341 (ILI9342) (#3526)

Co-authored-by: Samuel Sieb <samuel@sieb.net>
---
 esphome/components/ili9341/display.py          | 4 ++++
 esphome/components/ili9341/ili9341_display.cpp | 8 ++++++++
 esphome/components/ili9341/ili9341_display.h   | 8 ++++++++
 3 files changed, 20 insertions(+)

diff --git a/esphome/components/ili9341/display.py b/esphome/components/ili9341/display.py
index 6b18196ef1..3122b45bbe 100644
--- a/esphome/components/ili9341/display.py
+++ b/esphome/components/ili9341/display.py
@@ -24,6 +24,7 @@ ili9341 = ili9341_ns.class_(
 )
 ILI9341M5Stack = ili9341_ns.class_("ILI9341M5Stack", ili9341)
 ILI9341TFT24 = ili9341_ns.class_("ILI9341TFT24", ili9341)
+ILI9341TFT24R = ili9341_ns.class_("ILI9341TFT24R", ili9341)
 
 ILI9341Model = ili9341_ns.enum("ILI9341Model")
 ILI9341ColorMode = ili9341_ns.enum("ILI9341ColorMode")
@@ -31,6 +32,7 @@ ILI9341ColorMode = ili9341_ns.enum("ILI9341ColorMode")
 MODELS = {
     "M5STACK": ILI9341Model.M5STACK,
     "TFT_2.4": ILI9341Model.TFT_24,
+    "TFT_2.4R": ILI9341Model.TFT_24R,
 }
 
 ILI9341_MODEL = cv.enum(MODELS, upper=True, space="_")
@@ -60,6 +62,8 @@ async def to_code(config):
         lcd_type = ILI9341M5Stack
     if config[CONF_MODEL] == "TFT_2.4":
         lcd_type = ILI9341TFT24
+    if config[CONF_MODEL] == "TFT_2.4R":
+        lcd_type = ILI9341TFT24R
     rhs = lcd_type.new()
     var = cg.Pvariable(config[CONF_ID], rhs)
 
diff --git a/esphome/components/ili9341/ili9341_display.cpp b/esphome/components/ili9341/ili9341_display.cpp
index 0ad5446d9a..c4fa5f1b10 100644
--- a/esphome/components/ili9341/ili9341_display.cpp
+++ b/esphome/components/ili9341/ili9341_display.cpp
@@ -263,5 +263,13 @@ void ILI9341TFT24::initialize() {
   this->fill_internal_(Color::BLACK);
 }
 
+//   24_TFT rotated display
+void ILI9341TFT24R::initialize() {
+  this->init_lcd_(INITCMD_TFT);
+  this->width_ = 320;
+  this->height_ = 240;
+  this->fill_internal_(Color::BLACK);
+}
+
 }  // namespace ili9341
 }  // namespace esphome
diff --git a/esphome/components/ili9341/ili9341_display.h b/esphome/components/ili9341/ili9341_display.h
index e568eead40..3fbc144ac2 100644
--- a/esphome/components/ili9341/ili9341_display.h
+++ b/esphome/components/ili9341/ili9341_display.h
@@ -12,6 +12,7 @@ namespace ili9341 {
 enum ILI9341Model {
   M5STACK = 0,
   TFT_24,
+  TFT_24R,
 };
 
 enum ILI9341ColorMode {
@@ -102,5 +103,12 @@ class ILI9341TFT24 : public ILI9341Display {
  public:
   void initialize() override;
 };
+
+//-----------   ILI9341_24_TFT rotated display --------------
+class ILI9341TFT24R : public ILI9341Display {
+ public:
+  void initialize() override;
+};
+
 }  // namespace ili9341
 }  // namespace esphome

From 31c4551890273e902019bab26e17d8ea098cd975 Mon Sep 17 00:00:00 2001
From: Nicholas Peters <npnickster@gmail.com>
Date: Tue, 7 Jun 2022 06:43:46 -0400
Subject: [PATCH 44/60] Fix sdp3x error checking (#3531)

---
 esphome/components/sdp3x/sdp3x.cpp | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/esphome/components/sdp3x/sdp3x.cpp b/esphome/components/sdp3x/sdp3x.cpp
index 251d59607a..7a957e55ac 100644
--- a/esphome/components/sdp3x/sdp3x.cpp
+++ b/esphome/components/sdp3x/sdp3x.cpp
@@ -40,7 +40,7 @@ void SDP3XComponent::setup() {
     }
 
     uint16_t data[6];
-    if (this->read_data(data, 6) != i2c::ERROR_OK) {
+    if (!this->read_data(data, 6)) {
       ESP_LOGE(TAG, "Read ID SDP3X failed!");
       this->mark_failed();
       return;
@@ -78,8 +78,7 @@ void SDP3XComponent::setup() {
       }
     }
 
-    if (this->write_command(measurement_mode_ == DP_AVG ? SDP3X_START_DP_AVG : SDP3X_START_MASS_FLOW_AVG) !=
-        i2c::ERROR_OK) {
+    if (!this->write_command(measurement_mode_ == DP_AVG ? SDP3X_START_DP_AVG : SDP3X_START_MASS_FLOW_AVG)) {
       ESP_LOGE(TAG, "Start Measurements SDP3X failed!");
       this->mark_failed();
       return;
@@ -98,7 +97,7 @@ void SDP3XComponent::dump_config() {
 
 void SDP3XComponent::read_pressure_() {
   uint16_t data[3];
-  if (this->read_data(data, 3) != i2c::ERROR_OK) {
+  if (!this->read_data(data, 3)) {
     ESP_LOGW(TAG, "Couldn't read SDP3X data!");
     this->status_set_warning();
     return;

From ebca936b7e76d846659a7a35380ff04dd4669111 Mon Sep 17 00:00:00 2001
From: Maurice Makaay <account+github@makaay.nl>
Date: Tue, 7 Jun 2022 13:00:27 +0200
Subject: [PATCH 45/60] Fix percentage validation for wrong data type input
 (#3524)

Co-authored-by: Maurice Makaay <mmakaay1@xs4all.net>
---
 esphome/config_validation.py | 25 +++++++++++++++----------
 1 file changed, 15 insertions(+), 10 deletions(-)

diff --git a/esphome/config_validation.py b/esphome/config_validation.py
index 3dc8011a87..dacbcf72ba 100644
--- a/esphome/config_validation.py
+++ b/esphome/config_validation.py
@@ -1086,16 +1086,21 @@ def possibly_negative_percentage(value):
         except ValueError:
             # pylint: disable=raise-missing-from
             raise Invalid("invalid number")
-    if value > 1:
-        msg = "Percentage must not be higher than 100%."
-        if not has_percent_sign:
-            msg += " Please put a percent sign after the number!"
-        raise Invalid(msg)
-    if value < -1:
-        msg = "Percentage must not be smaller than -100%."
-        if not has_percent_sign:
-            msg += " Please put a percent sign after the number!"
-        raise Invalid(msg)
+    try:
+        if value > 1:
+            msg = "Percentage must not be higher than 100%."
+            if not has_percent_sign:
+                msg += " Please put a percent sign after the number!"
+            raise Invalid(msg)
+        if value < -1:
+            msg = "Percentage must not be smaller than -100%."
+            if not has_percent_sign:
+                msg += " Please put a percent sign after the number!"
+            raise Invalid(msg)
+    except TypeError:
+        raise Invalid(  # pylint: disable=raise-missing-from
+            "Expected percentage or float between -1.0 and 1.0"
+        )
     return negative_one_to_one_float(value)
 
 

From 6a85259e4d6d1b0a0f819688b8e555efcb99ecb0 Mon Sep 17 00:00:00 2001
From: VitaliyKurokhtin <Vitaliy.Kurokhtin@gmail.com>
Date: Tue, 7 Jun 2022 04:07:08 -0700
Subject: [PATCH 46/60] Block Tuya light from reacting to dp changes if
 transitioning (#3076)

---
 esphome/components/tuya/light/tuya_light.cpp | 25 ++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/esphome/components/tuya/light/tuya_light.cpp b/esphome/components/tuya/light/tuya_light.cpp
index 7facc52946..4d8bc9e37b 100644
--- a/esphome/components/tuya/light/tuya_light.cpp
+++ b/esphome/components/tuya/light/tuya_light.cpp
@@ -10,6 +10,11 @@ static const char *const TAG = "tuya.light";
 void TuyaLight::setup() {
   if (this->color_temperature_id_.has_value()) {
     this->parent_->register_listener(*this->color_temperature_id_, [this](const TuyaDatapoint &datapoint) {
+      if (this->state_->current_values != this->state_->remote_values) {
+        ESP_LOGD(TAG, "Light is transitioning, datapoint change ignored");
+        return;
+      }
+
       auto datapoint_value = datapoint.value_uint;
       if (this->color_temperature_invert_) {
         datapoint_value = this->color_temperature_max_value_ - datapoint_value;
@@ -23,6 +28,11 @@ void TuyaLight::setup() {
   }
   if (this->dimmer_id_.has_value()) {
     this->parent_->register_listener(*this->dimmer_id_, [this](const TuyaDatapoint &datapoint) {
+      if (this->state_->current_values != this->state_->remote_values) {
+        ESP_LOGD(TAG, "Light is transitioning, datapoint change ignored");
+        return;
+      }
+
       auto call = this->state_->make_call();
       call.set_brightness(float(datapoint.value_uint) / this->max_value_);
       call.perform();
@@ -30,6 +40,11 @@ void TuyaLight::setup() {
   }
   if (switch_id_.has_value()) {
     this->parent_->register_listener(*this->switch_id_, [this](const TuyaDatapoint &datapoint) {
+      if (this->state_->current_values != this->state_->remote_values) {
+        ESP_LOGD(TAG, "Light is transitioning, datapoint change ignored");
+        return;
+      }
+
       auto call = this->state_->make_call();
       call.set_state(datapoint.value_bool);
       call.perform();
@@ -41,6 +56,11 @@ void TuyaLight::setup() {
       auto green = parse_hex<uint8_t>(datapoint.value_string.substr(2, 2));
       auto blue = parse_hex<uint8_t>(datapoint.value_string.substr(4, 2));
       if (red.has_value() && green.has_value() && blue.has_value()) {
+        if (this->state_->current_values != this->state_->remote_values) {
+          ESP_LOGD(TAG, "Light is transitioning, datapoint change ignored");
+          return;
+        }
+
         auto call = this->state_->make_call();
         call.set_rgb(float(*red) / 255, float(*green) / 255, float(*blue) / 255);
         call.perform();
@@ -52,6 +72,11 @@ void TuyaLight::setup() {
       auto saturation = parse_hex<uint16_t>(datapoint.value_string.substr(4, 4));
       auto value = parse_hex<uint16_t>(datapoint.value_string.substr(8, 4));
       if (hue.has_value() && saturation.has_value() && value.has_value()) {
+        if (this->state_->current_values != this->state_->remote_values) {
+          ESP_LOGD(TAG, "Light is transitioning, datapoint change ignored");
+          return;
+        }
+
         float red, green, blue;
         hsv_to_rgb(*hue, float(*saturation) / 1000, float(*value) / 1000, red, green, blue);
         auto call = this->state_->make_call();

From 0d1028be2e3e7a6a639bd5c7029a6a49fb281b99 Mon Sep 17 00:00:00 2001
From: Maurice Makaay <account+github@makaay.nl>
Date: Tue, 7 Jun 2022 23:13:11 +0200
Subject: [PATCH 47/60] Cleanup deprecated EntityBase::hash_base() (#3525)

Co-authored-by: Maurice Makaay <mmakaay1@xs4all.net>
---
 esphome/components/binary_sensor/binary_sensor.cpp            | 1 -
 esphome/components/binary_sensor/binary_sensor.h              | 2 --
 esphome/components/ble_client/sensor/ble_sensor.cpp           | 2 --
 esphome/components/ble_client/sensor/ble_sensor.h             | 1 -
 esphome/components/ble_client/text_sensor/ble_text_sensor.cpp | 2 --
 esphome/components/ble_client/text_sensor/ble_text_sensor.h   | 1 -
 esphome/components/button/button.cpp                          | 1 -
 esphome/components/button/button.h                            | 2 --
 esphome/components/climate/climate.cpp                        | 1 -
 esphome/components/climate/climate.h                          | 1 -
 esphome/components/cover/cover.cpp                            | 2 --
 esphome/components/cover/cover.h                              | 1 -
 esphome/components/esp32_camera/esp32_camera.cpp              | 1 -
 esphome/components/esp32_camera/esp32_camera.h                | 1 -
 esphome/components/fan/fan.cpp                                | 1 -
 esphome/components/fan/fan.h                                  | 1 -
 esphome/components/light/light_state.cpp                      | 1 -
 esphome/components/light/light_state.h                        | 2 --
 esphome/components/lock/lock.cpp                              | 1 -
 esphome/components/lock/lock.h                                | 2 --
 esphome/components/media_player/media_player.cpp              | 1 -
 esphome/components/media_player/media_player.h                | 1 -
 esphome/components/number/number.cpp                          | 2 --
 esphome/components/number/number.h                            | 2 --
 esphome/components/select/select.cpp                          | 2 --
 esphome/components/select/select.h                            | 2 --
 esphome/components/sensor/sensor.cpp                          | 1 -
 esphome/components/sensor/sensor.h                            | 2 --
 esphome/components/switch/switch.cpp                          | 1 -
 esphome/components/switch/switch.h                            | 2 --
 esphome/components/text_sensor/text_sensor.cpp                | 1 -
 esphome/components/text_sensor/text_sensor.h                  | 2 --
 esphome/core/entity_base.h                                    | 4 +++-
 33 files changed, 3 insertions(+), 47 deletions(-)

diff --git a/esphome/components/binary_sensor/binary_sensor.cpp b/esphome/components/binary_sensor/binary_sensor.cpp
index 02735feaae..07217eebed 100644
--- a/esphome/components/binary_sensor/binary_sensor.cpp
+++ b/esphome/components/binary_sensor/binary_sensor.cpp
@@ -69,7 +69,6 @@ void BinarySensor::add_filters(const std::vector<Filter *> &filters) {
   }
 }
 bool BinarySensor::has_state() const { return this->has_state_; }
-uint32_t BinarySensor::hash_base() { return 1210250844UL; }
 bool BinarySensor::is_status_binary_sensor() const { return false; }
 
 }  // namespace binary_sensor
diff --git a/esphome/components/binary_sensor/binary_sensor.h b/esphome/components/binary_sensor/binary_sensor.h
index b5d1244bce..87d87b8eb4 100644
--- a/esphome/components/binary_sensor/binary_sensor.h
+++ b/esphome/components/binary_sensor/binary_sensor.h
@@ -76,8 +76,6 @@ class BinarySensor : public EntityBase {
   virtual std::string device_class();
 
  protected:
-  uint32_t hash_base() override;
-
   CallbackManager<void(bool)> state_callback_{};
   optional<std::string> device_class_{};  ///< Stores the override of the device class
   Filter *filter_list_{nullptr};
diff --git a/esphome/components/ble_client/sensor/ble_sensor.cpp b/esphome/components/ble_client/sensor/ble_sensor.cpp
index f8eee43137..ee5afd3f7b 100644
--- a/esphome/components/ble_client/sensor/ble_sensor.cpp
+++ b/esphome/components/ble_client/sensor/ble_sensor.cpp
@@ -11,8 +11,6 @@ namespace ble_client {
 
 static const char *const TAG = "ble_sensor";
 
-uint32_t BLESensor::hash_base() { return 343459825UL; }
-
 void BLESensor::loop() {}
 
 void BLESensor::dump_config() {
diff --git a/esphome/components/ble_client/sensor/ble_sensor.h b/esphome/components/ble_client/sensor/ble_sensor.h
index d9f310b575..d3d037572a 100644
--- a/esphome/components/ble_client/sensor/ble_sensor.h
+++ b/esphome/components/ble_client/sensor/ble_sensor.h
@@ -37,7 +37,6 @@ class BLESensor : public sensor::Sensor, public PollingComponent, public BLEClie
   uint16_t handle;
 
  protected:
-  uint32_t hash_base() override;
   float parse_data_(uint8_t *value, uint16_t value_len);
   optional<data_to_value_t> data_to_value_func_{};
   bool notify_;
diff --git a/esphome/components/ble_client/text_sensor/ble_text_sensor.cpp b/esphome/components/ble_client/text_sensor/ble_text_sensor.cpp
index c4d175faa4..1a71cd6cd8 100644
--- a/esphome/components/ble_client/text_sensor/ble_text_sensor.cpp
+++ b/esphome/components/ble_client/text_sensor/ble_text_sensor.cpp
@@ -14,8 +14,6 @@ static const char *const TAG = "ble_text_sensor";
 
 static const std::string EMPTY = "";
 
-uint32_t BLETextSensor::hash_base() { return 193967603UL; }
-
 void BLETextSensor::loop() {}
 
 void BLETextSensor::dump_config() {
diff --git a/esphome/components/ble_client/text_sensor/ble_text_sensor.h b/esphome/components/ble_client/text_sensor/ble_text_sensor.h
index 37537307de..cb34043b46 100644
--- a/esphome/components/ble_client/text_sensor/ble_text_sensor.h
+++ b/esphome/components/ble_client/text_sensor/ble_text_sensor.h
@@ -35,7 +35,6 @@ class BLETextSensor : public text_sensor::TextSensor, public PollingComponent, p
   uint16_t handle;
 
  protected:
-  uint32_t hash_base() override;
   bool notify_;
   espbt::ESPBTUUID service_uuid_;
   espbt::ESPBTUUID char_uuid_;
diff --git a/esphome/components/button/button.cpp b/esphome/components/button/button.cpp
index 0a5c6567bc..3d58780d6d 100644
--- a/esphome/components/button/button.cpp
+++ b/esphome/components/button/button.cpp
@@ -15,7 +15,6 @@ void Button::press() {
   this->press_callback_.call();
 }
 void Button::add_on_press_callback(std::function<void()> &&callback) { this->press_callback_.add(std::move(callback)); }
-uint32_t Button::hash_base() { return 1495763804UL; }
 
 void Button::set_device_class(const std::string &device_class) { this->device_class_ = device_class; }
 std::string Button::get_device_class() { return this->device_class_; }
diff --git a/esphome/components/button/button.h b/esphome/components/button/button.h
index f60c2a2bc5..398d398cd9 100644
--- a/esphome/components/button/button.h
+++ b/esphome/components/button/button.h
@@ -47,8 +47,6 @@ class Button : public EntityBase {
    */
   virtual void press_action() = 0;
 
-  uint32_t hash_base() override;
-
   CallbackManager<void()> press_callback_{};
   std::string device_class_{};
 };
diff --git a/esphome/components/climate/climate.cpp b/esphome/components/climate/climate.cpp
index 65b5ef4eb4..776a54f59d 100644
--- a/esphome/components/climate/climate.cpp
+++ b/esphome/components/climate/climate.cpp
@@ -419,7 +419,6 @@ void Climate::publish_state() {
   // Save state
   this->save_state_();
 }
-uint32_t Climate::hash_base() { return 3104134496UL; }
 
 ClimateTraits Climate::get_traits() {
   auto traits = this->traits();
diff --git a/esphome/components/climate/climate.h b/esphome/components/climate/climate.h
index 852b76686c..d508bb31b0 100644
--- a/esphome/components/climate/climate.h
+++ b/esphome/components/climate/climate.h
@@ -282,7 +282,6 @@ class Climate : public EntityBase {
    */
   void save_state_();
 
-  uint32_t hash_base() override;
   void dump_traits_(const char *tag);
 
   CallbackManager<void()> state_callback_{};
diff --git a/esphome/components/cover/cover.cpp b/esphome/components/cover/cover.cpp
index 21f35f14de..3d3abffae2 100644
--- a/esphome/components/cover/cover.cpp
+++ b/esphome/components/cover/cover.cpp
@@ -33,8 +33,6 @@ const char *cover_operation_to_str(CoverOperation op) {
 
 Cover::Cover(const std::string &name) : EntityBase(name), position{COVER_OPEN} {}
 
-uint32_t Cover::hash_base() { return 1727367479UL; }
-
 CoverCall::CoverCall(Cover *parent) : parent_(parent) {}
 CoverCall &CoverCall::set_command(const char *command) {
   if (strcasecmp(command, "OPEN") == 0) {
diff --git a/esphome/components/cover/cover.h b/esphome/components/cover/cover.h
index 1b5d3a8fa1..27a821215a 100644
--- a/esphome/components/cover/cover.h
+++ b/esphome/components/cover/cover.h
@@ -177,7 +177,6 @@ class Cover : public EntityBase {
   virtual std::string device_class();
 
   optional<CoverRestoreState> restore_state_();
-  uint32_t hash_base() override;
 
   CallbackManager<void()> state_callback_{};
   optional<std::string> device_class_override_{};
diff --git a/esphome/components/esp32_camera/esp32_camera.cpp b/esphome/components/esp32_camera/esp32_camera.cpp
index 65b316dc8d..165c00c960 100644
--- a/esphome/components/esp32_camera/esp32_camera.cpp
+++ b/esphome/components/esp32_camera/esp32_camera.cpp
@@ -322,7 +322,6 @@ void ESP32Camera::update_camera_parameters() {
 }
 
 /* ---------------- Internal methods ---------------- */
-uint32_t ESP32Camera::hash_base() { return 3010542557UL; }
 bool ESP32Camera::has_requested_image_() const { return this->single_requesters_ || this->stream_requesters_; }
 bool ESP32Camera::can_return_image_() const { return this->current_image_.use_count() == 1; }
 void ESP32Camera::framebuffer_task(void *pv) {
diff --git a/esphome/components/esp32_camera/esp32_camera.h b/esphome/components/esp32_camera/esp32_camera.h
index 8bf73a0fa6..87c5b0ba4a 100644
--- a/esphome/components/esp32_camera/esp32_camera.h
+++ b/esphome/components/esp32_camera/esp32_camera.h
@@ -151,7 +151,6 @@ class ESP32Camera : public Component, public EntityBase {
 
  protected:
   /* internal methods */
-  uint32_t hash_base() override;
   bool has_requested_image_() const;
   bool can_return_image_() const;
 
diff --git a/esphome/components/fan/fan.cpp b/esphome/components/fan/fan.cpp
index f7c4ab2e11..961ed6142a 100644
--- a/esphome/components/fan/fan.cpp
+++ b/esphome/components/fan/fan.cpp
@@ -152,7 +152,6 @@ void Fan::dump_traits_(const char *tag, const char *prefix) {
   if (this->get_traits().supports_direction())
     ESP_LOGCONFIG(tag, "%s  Direction: YES", prefix);
 }
-uint32_t Fan::hash_base() { return 418001110UL; }
 
 }  // namespace fan
 }  // namespace esphome
diff --git a/esphome/components/fan/fan.h b/esphome/components/fan/fan.h
index ef2ecd0f3f..337bb3935a 100644
--- a/esphome/components/fan/fan.h
+++ b/esphome/components/fan/fan.h
@@ -136,7 +136,6 @@ class Fan : public EntityBase {
   void save_state_();
 
   void dump_traits_(const char *tag, const char *prefix);
-  uint32_t hash_base() override;
 
   CallbackManager<void()> state_callback_{};
   ESPPreferenceObject rtc_;
diff --git a/esphome/components/light/light_state.cpp b/esphome/components/light/light_state.cpp
index dadad38235..00c03eb5f0 100644
--- a/esphome/components/light/light_state.cpp
+++ b/esphome/components/light/light_state.cpp
@@ -145,7 +145,6 @@ void LightState::loop() {
 }
 
 float LightState::get_setup_priority() const { return setup_priority::HARDWARE - 1.0f; }
-uint32_t LightState::hash_base() { return 1114400283; }
 
 void LightState::publish_state() { this->remote_values_callback_.call(); }
 
diff --git a/esphome/components/light/light_state.h b/esphome/components/light/light_state.h
index 2e523eda5c..2834836c0e 100644
--- a/esphome/components/light/light_state.h
+++ b/esphome/components/light/light_state.h
@@ -150,8 +150,6 @@ class LightState : public EntityBase, public Component {
   friend LightCall;
   friend class AddressableLight;
 
-  uint32_t hash_base() override;
-
   /// Internal method to start an effect with the given index
   void start_effect_(uint32_t effect_index);
   /// Internal method to get the currently active effect
diff --git a/esphome/components/lock/lock.cpp b/esphome/components/lock/lock.cpp
index e32ab6d0a6..dbb8a941ad 100644
--- a/esphome/components/lock/lock.cpp
+++ b/esphome/components/lock/lock.cpp
@@ -57,7 +57,6 @@ void Lock::publish_state(LockState state) {
 }
 
 void Lock::add_on_state_callback(std::function<void()> &&callback) { this->state_callback_.add(std::move(callback)); }
-uint32_t Lock::hash_base() { return 856245656UL; }
 
 void LockCall::perform() {
   ESP_LOGD(TAG, "'%s' - Setting", this->parent_->get_name().c_str());
diff --git a/esphome/components/lock/lock.h b/esphome/components/lock/lock.h
index f11035c03e..52256691f6 100644
--- a/esphome/components/lock/lock.h
+++ b/esphome/components/lock/lock.h
@@ -167,8 +167,6 @@ class Lock : public EntityBase {
    */
   virtual void control(const LockCall &call) = 0;
 
-  uint32_t hash_base() override;
-
   CallbackManager<void()> state_callback_{};
   Deduplicator<LockState> publish_dedup_;
   ESPPreferenceObject rtc_;
diff --git a/esphome/components/media_player/media_player.cpp b/esphome/components/media_player/media_player.cpp
index 00ad31ab18..b05423c2bd 100644
--- a/esphome/components/media_player/media_player.cpp
+++ b/esphome/components/media_player/media_player.cpp
@@ -107,7 +107,6 @@ MediaPlayerCall &MediaPlayerCall::set_volume(float volume) {
 void MediaPlayer::add_on_state_callback(std::function<void()> &&callback) {
   this->state_callback_.add(std::move(callback));
 }
-uint32_t MediaPlayer::hash_base() { return 1938496157UL; }
 
 void MediaPlayer::publish_state() { this->state_callback_.call(); }
 
diff --git a/esphome/components/media_player/media_player.h b/esphome/components/media_player/media_player.h
index 9a86874996..12e0b5c17d 100644
--- a/esphome/components/media_player/media_player.h
+++ b/esphome/components/media_player/media_player.h
@@ -82,7 +82,6 @@ class MediaPlayer : public EntityBase {
   friend MediaPlayerCall;
 
   virtual void control(const MediaPlayerCall &call) = 0;
-  uint32_t hash_base() override;
 
   CallbackManager<void()> state_callback_{};
 };
diff --git a/esphome/components/number/number.cpp b/esphome/components/number/number.cpp
index 03a7cc6ce3..fda4f43e34 100644
--- a/esphome/components/number/number.cpp
+++ b/esphome/components/number/number.cpp
@@ -17,7 +17,5 @@ void Number::add_on_state_callback(std::function<void(float)> &&callback) {
   this->state_callback_.add(std::move(callback));
 }
 
-uint32_t Number::hash_base() { return 2282307003UL; }
-
 }  // namespace number
 }  // namespace esphome
diff --git a/esphome/components/number/number.h b/esphome/components/number/number.h
index ad058e3a0e..7f360cad7b 100644
--- a/esphome/components/number/number.h
+++ b/esphome/components/number/number.h
@@ -52,8 +52,6 @@ class Number : public EntityBase {
    */
   virtual void control(float value) = 0;
 
-  uint32_t hash_base() override;
-
   CallbackManager<void(float)> state_callback_;
   bool has_state_{false};
 };
diff --git a/esphome/components/select/select.cpp b/esphome/components/select/select.cpp
index 35f1cfba46..f4583b4e2e 100644
--- a/esphome/components/select/select.cpp
+++ b/esphome/components/select/select.cpp
@@ -58,7 +58,5 @@ optional<std::string> Select::at(size_t index) const {
   }
 }
 
-uint32_t Select::hash_base() { return 2812997003UL; }
-
 }  // namespace select
 }  // namespace esphome
diff --git a/esphome/components/select/select.h b/esphome/components/select/select.h
index b11c6404a0..23258d5785 100644
--- a/esphome/components/select/select.h
+++ b/esphome/components/select/select.h
@@ -65,8 +65,6 @@ class Select : public EntityBase {
    */
   virtual void control(const std::string &value) = 0;
 
-  uint32_t hash_base() override;
-
   CallbackManager<void(std::string, size_t)> state_callback_;
   bool has_state_{false};
 };
diff --git a/esphome/components/sensor/sensor.cpp b/esphome/components/sensor/sensor.cpp
index 73730f6482..c0869631aa 100644
--- a/esphome/components/sensor/sensor.cpp
+++ b/esphome/components/sensor/sensor.cpp
@@ -126,7 +126,6 @@ void Sensor::internal_send_state_to_frontend(float state) {
   this->callback_.call(state);
 }
 bool Sensor::has_state() const { return this->has_state_; }
-uint32_t Sensor::hash_base() { return 2455723294UL; }
 
 }  // namespace sensor
 }  // namespace esphome
diff --git a/esphome/components/sensor/sensor.h b/esphome/components/sensor/sensor.h
index d31fe9d834..f29125ee42 100644
--- a/esphome/components/sensor/sensor.h
+++ b/esphome/components/sensor/sensor.h
@@ -174,8 +174,6 @@ class Sensor : public EntityBase {
    */
   virtual StateClass state_class();  // NOLINT
 
-  uint32_t hash_base() override;
-
   CallbackManager<void(float)> raw_callback_;  ///< Storage for raw state callbacks.
   CallbackManager<void(float)> callback_;      ///< Storage for filtered state callbacks.
 
diff --git a/esphome/components/switch/switch.cpp b/esphome/components/switch/switch.cpp
index ca36e6feb9..099bd4819b 100644
--- a/esphome/components/switch/switch.cpp
+++ b/esphome/components/switch/switch.cpp
@@ -43,7 +43,6 @@ void Switch::add_on_state_callback(std::function<void(bool)> &&callback) {
   this->state_callback_.add(std::move(callback));
 }
 void Switch::set_inverted(bool inverted) { this->inverted_ = inverted; }
-uint32_t Switch::hash_base() { return 3129890955UL; }
 bool Switch::is_inverted() const { return this->inverted_; }
 
 std::string Switch::get_device_class() {
diff --git a/esphome/components/switch/switch.h b/esphome/components/switch/switch.h
index dda24e85fa..c521c4024b 100644
--- a/esphome/components/switch/switch.h
+++ b/esphome/components/switch/switch.h
@@ -107,8 +107,6 @@ class Switch : public EntityBase {
    */
   virtual void write_state(bool state) = 0;
 
-  uint32_t hash_base() override;
-
   CallbackManager<void(bool)> state_callback_{};
   bool inverted_{false};
   Deduplicator<bool> publish_dedup_;
diff --git a/esphome/components/text_sensor/text_sensor.cpp b/esphome/components/text_sensor/text_sensor.cpp
index 5d47e7465a..d76ab7e27d 100644
--- a/esphome/components/text_sensor/text_sensor.cpp
+++ b/esphome/components/text_sensor/text_sensor.cpp
@@ -70,7 +70,6 @@ void TextSensor::internal_send_state_to_frontend(const std::string &state) {
 
 std::string TextSensor::unique_id() { return ""; }
 bool TextSensor::has_state() { return this->has_state_; }
-uint32_t TextSensor::hash_base() { return 334300109UL; }
 
 }  // namespace text_sensor
 }  // namespace esphome
diff --git a/esphome/components/text_sensor/text_sensor.h b/esphome/components/text_sensor/text_sensor.h
index 4bd77131d7..340f7ff9ed 100644
--- a/esphome/components/text_sensor/text_sensor.h
+++ b/esphome/components/text_sensor/text_sensor.h
@@ -59,8 +59,6 @@ class TextSensor : public EntityBase {
   void internal_send_state_to_frontend(const std::string &state);
 
  protected:
-  uint32_t hash_base() override;
-
   CallbackManager<void(std::string)> raw_callback_;  ///< Storage for raw state callbacks.
   CallbackManager<void(std::string)> callback_;      ///< Storage for filtered state callbacks.
 
diff --git a/esphome/core/entity_base.h b/esphome/core/entity_base.h
index c489d71910..a9eedfd07e 100644
--- a/esphome/core/entity_base.h
+++ b/esphome/core/entity_base.h
@@ -46,7 +46,9 @@ class EntityBase {
   void set_icon(const std::string &name);
 
  protected:
-  virtual uint32_t hash_base() = 0;
+  /// The hash_base() function has been deprecated. It is kept in this
+  /// class for now, to prevent external components from not compiling.
+  virtual uint32_t hash_base() { return 0L; }
   void calc_object_id_();
 
   std::string name_;

From 03944e6cd8858f42ab0cf730d8e1dbddd559aa81 Mon Sep 17 00:00:00 2001
From: DAVe3283 <DAVe3283@gmail.com>
Date: Tue, 7 Jun 2022 15:58:32 -0600
Subject: [PATCH 48/60] Fix bogus reading on no communication with MAX31865
 (#3505)

---
 CODEOWNERS                               | 1 +
 esphome/components/max31865/max31865.cpp | 8 ++++++++
 esphome/components/max31865/sensor.py    | 3 +++
 3 files changed, 12 insertions(+)

diff --git a/CODEOWNERS b/CODEOWNERS
index d5ce5e6920..3cb38fce06 100644
--- a/CODEOWNERS
+++ b/CODEOWNERS
@@ -103,6 +103,7 @@ esphome/components/lilygo_t5_47/touchscreen/* @jesserockz
 esphome/components/lock/* @esphome/core
 esphome/components/logger/* @esphome/core
 esphome/components/ltr390/* @sjtrny
+esphome/components/max31865/* @DAVe3283
 esphome/components/max44009/* @berfenger
 esphome/components/max7219digit/* @rspaargaren
 esphome/components/max9611/* @mckaymatthew
diff --git a/esphome/components/max31865/max31865.cpp b/esphome/components/max31865/max31865.cpp
index 126915dc15..152d7b340b 100644
--- a/esphome/components/max31865/max31865.cpp
+++ b/esphome/components/max31865/max31865.cpp
@@ -94,6 +94,14 @@ void MAX31865Sensor::read_data_() {
   const uint16_t rtd_resistance_register = this->read_register_16_(RTD_RESISTANCE_MSB_REG);
   this->write_config_(0b11000000, 0b00000000);
 
+  // Check for bad connection
+  if (rtd_resistance_register == 0b0000000000000000 || rtd_resistance_register == 0b1111111111111111) {
+    ESP_LOGE(TAG, "SPI bus read all 0 or all 1 (0x%04X), check MAX31865 wiring & power.", rtd_resistance_register);
+    this->publish_state(NAN);
+    this->status_set_error();
+    return;
+  }
+
   // Check faults
   const uint8_t faults = this->read_register_(FAULT_STATUS_REG);
   if ((has_fault_ = faults & 0b00111100)) {
diff --git a/esphome/components/max31865/sensor.py b/esphome/components/max31865/sensor.py
index 6eb8bd400d..704f945171 100644
--- a/esphome/components/max31865/sensor.py
+++ b/esphome/components/max31865/sensor.py
@@ -11,6 +11,9 @@ from esphome.const import (
     UNIT_CELSIUS,
 )
 
+CODEOWNERS = ["@DAVe3283"]
+DEPENDENCIES = ["spi"]
+
 max31865_ns = cg.esphome_ns.namespace("max31865")
 MAX31865Sensor = max31865_ns.class_(
     "MAX31865Sensor", sensor.Sensor, cg.PollingComponent, spi.SPIDevice

From d63e14a4b68495f9eb6dccc2f0450553037cc845 Mon Sep 17 00:00:00 2001
From: Jesse Hills <3060199+jesserockz@users.noreply.github.com>
Date: Wed, 8 Jun 2022 22:33:21 +1200
Subject: [PATCH 49/60] Implement the media player actions (#3534)

---
 .../i2s_audio/i2s_audio_media_player.cpp      |  8 +++++
 esphome/components/media_player/__init__.py   |  8 ++++-
 esphome/components/media_player/automation.h  | 35 +++++++++++++++++++
 .../components/media_player/media_player.cpp  |  4 +++
 .../components/media_player/media_player.h    |  3 +-
 5 files changed, 56 insertions(+), 2 deletions(-)
 create mode 100644 esphome/components/media_player/automation.h

diff --git a/esphome/components/i2s_audio/i2s_audio_media_player.cpp b/esphome/components/i2s_audio/i2s_audio_media_player.cpp
index 0ab3237aeb..9ddc8419bf 100644
--- a/esphome/components/i2s_audio/i2s_audio_media_player.cpp
+++ b/esphome/components/i2s_audio/i2s_audio_media_player.cpp
@@ -43,6 +43,14 @@ void I2SAudioMediaPlayer::control(const media_player::MediaPlayerCall &call) {
       case media_player::MEDIA_PLAYER_COMMAND_UNMUTE:
         this->unmute_();
         break;
+      case media_player::MEDIA_PLAYER_COMMAND_TOGGLE:
+        this->audio_->pauseResume();
+        if (this->audio_->isRunning()) {
+          this->state = media_player::MEDIA_PLAYER_STATE_PLAYING;
+        } else {
+          this->state = media_player::MEDIA_PLAYER_STATE_PAUSED;
+        }
+        break;
     }
   }
   this->publish_state();
diff --git a/esphome/components/media_player/__init__.py b/esphome/components/media_player/__init__.py
index 91cf613ed9..98b93a7ee7 100644
--- a/esphome/components/media_player/__init__.py
+++ b/esphome/components/media_player/__init__.py
@@ -20,6 +20,9 @@ MediaPlayer = media_player_ns.class_("MediaPlayer")
 PlayAction = media_player_ns.class_(
     "PlayAction", automation.Action, cg.Parented.template(MediaPlayer)
 )
+ToggleAction = media_player_ns.class_(
+    "ToggleAction", automation.Action, cg.Parented.template(MediaPlayer)
+)
 PauseAction = media_player_ns.class_(
     "PauseAction", automation.Action, cg.Parented.template(MediaPlayer)
 )
@@ -42,12 +45,15 @@ async def register_media_player(var, config):
 MEDIA_PLAYER_SCHEMA = cv.ENTITY_BASE_SCHEMA.extend(cv.Schema({}))
 
 
-MEDIA_PLAYER_ACTION_SCHEMA = maybe_simple_id()(
+MEDIA_PLAYER_ACTION_SCHEMA = maybe_simple_id(
     {cv.Required(CONF_ID): cv.use_id(MediaPlayer)}
 )
 
 
 @automation.register_action("media_player.play", PlayAction, MEDIA_PLAYER_ACTION_SCHEMA)
+@automation.register_action(
+    "media_player.toggle", ToggleAction, MEDIA_PLAYER_ACTION_SCHEMA
+)
 @automation.register_action(
     "media_player.pause", PauseAction, MEDIA_PLAYER_ACTION_SCHEMA
 )
diff --git a/esphome/components/media_player/automation.h b/esphome/components/media_player/automation.h
new file mode 100644
index 0000000000..e2b40d6a00
--- /dev/null
+++ b/esphome/components/media_player/automation.h
@@ -0,0 +1,35 @@
+#pragma once
+
+#include "esphome/core/automation.h"
+#include "media_player.h"
+
+namespace esphome {
+
+namespace media_player {
+
+template<typename... Ts> class PlayAction : public Action<Ts...>, public Parented<MediaPlayer> {
+  void play(Ts... x) override {
+    this->parent_->make_call().set_command(MediaPlayerCommand::MEDIA_PLAYER_COMMAND_PLAY).perform();
+  }
+};
+
+template<typename... Ts> class ToggleAction : public Action<Ts...>, public Parented<MediaPlayer> {
+  void play(Ts... x) override {
+    this->parent_->make_call().set_command(MediaPlayerCommand::MEDIA_PLAYER_COMMAND_TOGGLE).perform();
+  }
+};
+
+template<typename... Ts> class PauseAction : public Action<Ts...>, public Parented<MediaPlayer> {
+  void play(Ts... x) override {
+    this->parent_->make_call().set_command(MediaPlayerCommand::MEDIA_PLAYER_COMMAND_PAUSE).perform();
+  }
+};
+
+template<typename... Ts> class StopAction : public Action<Ts...>, public Parented<MediaPlayer> {
+  void play(Ts... x) override {
+    this->parent_->make_call().set_command(MediaPlayerCommand::MEDIA_PLAYER_COMMAND_STOP).perform();
+  }
+};
+
+}  // namespace media_player
+}  // namespace esphome
diff --git a/esphome/components/media_player/media_player.cpp b/esphome/components/media_player/media_player.cpp
index b05423c2bd..81cb6ca751 100644
--- a/esphome/components/media_player/media_player.cpp
+++ b/esphome/components/media_player/media_player.cpp
@@ -33,6 +33,8 @@ const char *media_player_command_to_string(MediaPlayerCommand command) {
       return "MUTE";
     case MEDIA_PLAYER_COMMAND_UNMUTE:
       return "UNMUTE";
+    case MEDIA_PLAYER_COMMAND_TOGGLE:
+      return "TOGGLE";
     default:
       return "UNKNOWN";
   }
@@ -88,6 +90,8 @@ MediaPlayerCall &MediaPlayerCall::set_command(const std::string &command) {
     this->set_command(MEDIA_PLAYER_COMMAND_MUTE);
   } else if (str_equals_case_insensitive(command, "UNMUTE")) {
     this->set_command(MEDIA_PLAYER_COMMAND_UNMUTE);
+  } else if (str_equals_case_insensitive(command, "TOGGLE")) {
+    this->set_command(MEDIA_PLAYER_COMMAND_TOGGLE);
   } else {
     ESP_LOGW(TAG, "'%s' - Unrecognized command %s", this->parent_->get_name().c_str(), command.c_str());
   }
diff --git a/esphome/components/media_player/media_player.h b/esphome/components/media_player/media_player.h
index 12e0b5c17d..6a2643b713 100644
--- a/esphome/components/media_player/media_player.h
+++ b/esphome/components/media_player/media_player.h
@@ -19,7 +19,8 @@ enum MediaPlayerCommand : uint8_t {
   MEDIA_PLAYER_COMMAND_PAUSE = 1,
   MEDIA_PLAYER_COMMAND_STOP = 2,
   MEDIA_PLAYER_COMMAND_MUTE = 3,
-  MEDIA_PLAYER_COMMAND_UNMUTE = 4
+  MEDIA_PLAYER_COMMAND_UNMUTE = 4,
+  MEDIA_PLAYER_COMMAND_TOGGLE = 5
 };
 const char *media_player_command_to_string(MediaPlayerCommand command);
 

From a3d73d1e23f8cedff20a9e9ce803dace1fb311b3 Mon Sep 17 00:00:00 2001
From: Wolfgang Tremmel <wtremmel@users.noreply.github.com>
Date: Wed, 8 Jun 2022 12:34:50 +0200
Subject: [PATCH 50/60] RG15 data is float/double, not int (#3512)

Co-authored-by: Jesse Hills <3060199+jesserockz@users.noreply.github.com>
---
 esphome/components/hydreon_rgxx/hydreon_rgxx.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/esphome/components/hydreon_rgxx/hydreon_rgxx.cpp b/esphome/components/hydreon_rgxx/hydreon_rgxx.cpp
index 3ed65831ae..25d2617677 100644
--- a/esphome/components/hydreon_rgxx/hydreon_rgxx.cpp
+++ b/esphome/components/hydreon_rgxx/hydreon_rgxx.cpp
@@ -195,7 +195,7 @@ void HydreonRGxxComponent::process_line_() {
       if (n == std::string::npos) {
         continue;
       }
-      int data = strtol(this->buffer_.substr(n + strlen(PROTOCOL_NAMES[i])).c_str(), nullptr, 10);
+      float data = strtof(this->buffer_.substr(n + strlen(PROTOCOL_NAMES[i])).c_str(), nullptr);
       this->sensors_[i]->publish_state(data);
       ESP_LOGD(TAG, "Received %s: %f", PROTOCOL_NAMES[i], this->sensors_[i]->get_raw_state());
       this->sensors_received_ |= (1 << i);

From 746fd1122fa9f337e787fde79bc203d21b16ea53 Mon Sep 17 00:00:00 2001
From: Jesse Hills <3060199+jesserockz@users.noreply.github.com>
Date: Wed, 8 Jun 2022 22:46:20 +1200
Subject: [PATCH 51/60] Bump version to 2022.6.0b1

---
 esphome/const.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/esphome/const.py b/esphome/const.py
index b73d7e33bd..035c46f860 100644
--- a/esphome/const.py
+++ b/esphome/const.py
@@ -1,6 +1,6 @@
 """Constants used by esphome."""
 
-__version__ = "2022.6.0-dev"
+__version__ = "2022.6.0b1"
 
 ALLOWED_NAME_CHARS = "abcdefghijklmnopqrstuvwxyz0123456789-_"
 

From 93421f0fa71e09f173f8e8e15b29abe67e9f578a Mon Sep 17 00:00:00 2001
From: Samuel Sieb <samuel-github@sieb.net>
Date: Wed, 8 Jun 2022 20:27:04 -0700
Subject: [PATCH 52/60] publish fan speed count for discovery (#3537)

Co-authored-by: Samuel Sieb <samuel@sieb.net>
---
 esphome/components/mqtt/mqtt_fan.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/esphome/components/mqtt/mqtt_fan.cpp b/esphome/components/mqtt/mqtt_fan.cpp
index 6433ead6b2..32892199fe 100644
--- a/esphome/components/mqtt/mqtt_fan.cpp
+++ b/esphome/components/mqtt/mqtt_fan.cpp
@@ -114,6 +114,7 @@ void MQTTFanComponent::send_discovery(JsonObject root, mqtt::SendDiscoveryConfig
   if (this->state_->get_traits().supports_speed()) {
     root[MQTT_PERCENTAGE_COMMAND_TOPIC] = this->get_speed_level_command_topic();
     root[MQTT_PERCENTAGE_STATE_TOPIC] = this->get_speed_level_state_topic();
+    root[MQTT_SPEED_RANGE_MAX] = this->state_->get_traits().supported_speed_count();
   }
 }
 bool MQTTFanComponent::publish_state() {

From 5942a3898c70b6ecc52ecf7617f45a90b585471f Mon Sep 17 00:00:00 2001
From: Viktor Nagy <126671+nagyv@users.noreply.github.com>
Date: Thu, 9 Jun 2022 06:20:05 +0200
Subject: [PATCH 53/60] Nextion brightness setting requires an assignment
 (#3533)

---
 esphome/components/nextion/nextion_commands.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/esphome/components/nextion/nextion_commands.cpp b/esphome/components/nextion/nextion_commands.cpp
index f83aafc595..308e02bce8 100644
--- a/esphome/components/nextion/nextion_commands.cpp
+++ b/esphome/components/nextion/nextion_commands.cpp
@@ -115,7 +115,7 @@ void Nextion::set_backlight_brightness(float brightness) {
     ESP_LOGD(TAG, "Brightness out of bounds, percentage range 0-1.0");
     return;
   }
-  this->add_no_result_to_queue_with_set("backlight_brightness", "dim", static_cast<int>(brightness * 100));
+  this->add_no_result_to_queue_with_printf_("backlight_brightness", "dim=%d", static_cast<int>(brightness * 100));
 }
 
 void Nextion::set_auto_wake_on_touch(bool auto_wake) {

From d2d4eb4eae93ff7aa09e7edaa9fc4d59b8f637ab Mon Sep 17 00:00:00 2001
From: Jesse Hills <3060199+jesserockz@users.noreply.github.com>
Date: Thu, 9 Jun 2022 20:27:22 +1200
Subject: [PATCH 54/60] Bump version to 2022.6.0b2

---
 esphome/const.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/esphome/const.py b/esphome/const.py
index 035c46f860..80842f83be 100644
--- a/esphome/const.py
+++ b/esphome/const.py
@@ -1,6 +1,6 @@
 """Constants used by esphome."""
 
-__version__ = "2022.6.0b1"
+__version__ = "2022.6.0b2"
 
 ALLOWED_NAME_CHARS = "abcdefghijklmnopqrstuvwxyz0123456789-_"
 

From 041bef8bcda8683d9284962f7762550c05c3f002 Mon Sep 17 00:00:00 2001
From: Jesse Hills <3060199+jesserockz@users.noreply.github.com>
Date: Mon, 13 Jun 2022 13:28:55 +1200
Subject: [PATCH 55/60] Implement media player volume actions (#3551)

---
 .../i2s_audio/i2s_audio_media_player.cpp      | 16 ++++++++
 esphome/components/media_player/__init__.py   | 40 +++++++++++++++++--
 esphome/components/media_player/automation.h  | 35 +++++++---------
 .../components/media_player/media_player.h    |  4 +-
 tests/test4.yaml                              |  8 ++++
 5 files changed, 79 insertions(+), 24 deletions(-)

diff --git a/esphome/components/i2s_audio/i2s_audio_media_player.cpp b/esphome/components/i2s_audio/i2s_audio_media_player.cpp
index 9ddc8419bf..2b624a3917 100644
--- a/esphome/components/i2s_audio/i2s_audio_media_player.cpp
+++ b/esphome/components/i2s_audio/i2s_audio_media_player.cpp
@@ -51,6 +51,22 @@ void I2SAudioMediaPlayer::control(const media_player::MediaPlayerCall &call) {
           this->state = media_player::MEDIA_PLAYER_STATE_PAUSED;
         }
         break;
+      case media_player::MEDIA_PLAYER_COMMAND_VOLUME_UP: {
+        float new_volume = this->volume + 0.1f;
+        if (new_volume > 1.0f)
+          new_volume = 1.0f;
+        this->set_volume_(new_volume);
+        this->unmute_();
+        break;
+      }
+      case media_player::MEDIA_PLAYER_COMMAND_VOLUME_DOWN: {
+        float new_volume = this->volume - 0.1f;
+        if (new_volume < 0.0f)
+          new_volume = 0.0f;
+        this->set_volume_(new_volume);
+        this->unmute_();
+        break;
+      }
     }
   }
   this->publish_state();
diff --git a/esphome/components/media_player/__init__.py b/esphome/components/media_player/__init__.py
index 98b93a7ee7..877dd693e3 100644
--- a/esphome/components/media_player/__init__.py
+++ b/esphome/components/media_player/__init__.py
@@ -29,6 +29,17 @@ PauseAction = media_player_ns.class_(
 StopAction = media_player_ns.class_(
     "StopAction", automation.Action, cg.Parented.template(MediaPlayer)
 )
+VolumeUpAction = media_player_ns.class_(
+    "VolumeUpAction", automation.Action, cg.Parented.template(MediaPlayer)
+)
+VolumeDownAction = media_player_ns.class_(
+    "VolumeDownAction", automation.Action, cg.Parented.template(MediaPlayer)
+)
+VolumeSetAction = media_player_ns.class_(
+    "VolumeSetAction", automation.Action, cg.Parented.template(MediaPlayer)
+)
+
+CONF_VOLUME = "volume"
 
 
 async def setup_media_player_core_(var, config):
@@ -45,9 +56,7 @@ async def register_media_player(var, config):
 MEDIA_PLAYER_SCHEMA = cv.ENTITY_BASE_SCHEMA.extend(cv.Schema({}))
 
 
-MEDIA_PLAYER_ACTION_SCHEMA = maybe_simple_id(
-    {cv.Required(CONF_ID): cv.use_id(MediaPlayer)}
-)
+MEDIA_PLAYER_ACTION_SCHEMA = maybe_simple_id({cv.GenerateID(): cv.use_id(MediaPlayer)})
 
 
 @automation.register_action("media_player.play", PlayAction, MEDIA_PLAYER_ACTION_SCHEMA)
@@ -58,12 +67,37 @@ MEDIA_PLAYER_ACTION_SCHEMA = maybe_simple_id(
     "media_player.pause", PauseAction, MEDIA_PLAYER_ACTION_SCHEMA
 )
 @automation.register_action("media_player.stop", StopAction, MEDIA_PLAYER_ACTION_SCHEMA)
+@automation.register_action(
+    "media_player.volume_up", VolumeUpAction, MEDIA_PLAYER_ACTION_SCHEMA
+)
+@automation.register_action(
+    "media_player.volume_down", VolumeDownAction, MEDIA_PLAYER_ACTION_SCHEMA
+)
 async def media_player_action(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
     await cg.register_parented(var, config[CONF_ID])
     return var
 
 
+@automation.register_action(
+    "media_player.volume_set",
+    VolumeSetAction,
+    cv.maybe_simple_value(
+        {
+            cv.GenerateID(): cv.use_id(MediaPlayer),
+            cv.Required(CONF_VOLUME): cv.templatable(cv.percentage),
+        },
+        key=CONF_VOLUME,
+    ),
+)
+async def media_player_volume_set_action(config, action_id, template_arg, args):
+    var = cg.new_Pvariable(action_id, template_arg)
+    await cg.register_parented(var, config[CONF_ID])
+    volume = await cg.templatable(config[CONF_VOLUME], args, float)
+    cg.add(var.set_volume(volume))
+    return var
+
+
 @coroutine_with_priority(100.0)
 async def to_code(config):
     cg.add_global(media_player_ns.using)
diff --git a/esphome/components/media_player/automation.h b/esphome/components/media_player/automation.h
index e2b40d6a00..4dc324eb9c 100644
--- a/esphome/components/media_player/automation.h
+++ b/esphome/components/media_player/automation.h
@@ -7,28 +7,23 @@ namespace esphome {
 
 namespace media_player {
 
-template<typename... Ts> class PlayAction : public Action<Ts...>, public Parented<MediaPlayer> {
-  void play(Ts... x) override {
-    this->parent_->make_call().set_command(MediaPlayerCommand::MEDIA_PLAYER_COMMAND_PLAY).perform();
-  }
-};
+#define MEDIA_PLAYER_SIMPLE_COMMAND_ACTION(ACTION_CLASS, ACTION_COMMAND) \
+  template<typename... Ts> class ACTION_CLASS : public Action<Ts...>, public Parented<MediaPlayer> { \
+    void play(Ts... x) override { \
+      this->parent_->make_call().set_command(MediaPlayerCommand::MEDIA_PLAYER_COMMAND_##ACTION_COMMAND).perform(); \
+    } \
+  };
 
-template<typename... Ts> class ToggleAction : public Action<Ts...>, public Parented<MediaPlayer> {
-  void play(Ts... x) override {
-    this->parent_->make_call().set_command(MediaPlayerCommand::MEDIA_PLAYER_COMMAND_TOGGLE).perform();
-  }
-};
+MEDIA_PLAYER_SIMPLE_COMMAND_ACTION(PlayAction, PLAY)
+MEDIA_PLAYER_SIMPLE_COMMAND_ACTION(PauseAction, PAUSE)
+MEDIA_PLAYER_SIMPLE_COMMAND_ACTION(StopAction, STOP)
+MEDIA_PLAYER_SIMPLE_COMMAND_ACTION(ToggleAction, TOGGLE)
+MEDIA_PLAYER_SIMPLE_COMMAND_ACTION(VolumeUpAction, VOLUME_UP)
+MEDIA_PLAYER_SIMPLE_COMMAND_ACTION(VolumeDownAction, VOLUME_DOWN)
 
-template<typename... Ts> class PauseAction : public Action<Ts...>, public Parented<MediaPlayer> {
-  void play(Ts... x) override {
-    this->parent_->make_call().set_command(MediaPlayerCommand::MEDIA_PLAYER_COMMAND_PAUSE).perform();
-  }
-};
-
-template<typename... Ts> class StopAction : public Action<Ts...>, public Parented<MediaPlayer> {
-  void play(Ts... x) override {
-    this->parent_->make_call().set_command(MediaPlayerCommand::MEDIA_PLAYER_COMMAND_STOP).perform();
-  }
+template<typename... Ts> class VolumeSetAction : public Action<Ts...>, public Parented<MediaPlayer> {
+  TEMPLATABLE_VALUE(float, volume)
+  void play(Ts... x) override { this->parent_->make_call().set_volume(this->volume_.value(x...)).perform(); }
 };
 
 }  // namespace media_player
diff --git a/esphome/components/media_player/media_player.h b/esphome/components/media_player/media_player.h
index 6a2643b713..88114d5337 100644
--- a/esphome/components/media_player/media_player.h
+++ b/esphome/components/media_player/media_player.h
@@ -20,7 +20,9 @@ enum MediaPlayerCommand : uint8_t {
   MEDIA_PLAYER_COMMAND_STOP = 2,
   MEDIA_PLAYER_COMMAND_MUTE = 3,
   MEDIA_PLAYER_COMMAND_UNMUTE = 4,
-  MEDIA_PLAYER_COMMAND_TOGGLE = 5
+  MEDIA_PLAYER_COMMAND_TOGGLE = 5,
+  MEDIA_PLAYER_COMMAND_VOLUME_UP = 6,
+  MEDIA_PLAYER_COMMAND_VOLUME_DOWN = 7,
 };
 const char *media_player_command_to_string(MediaPlayerCommand command);
 
diff --git a/tests/test4.yaml b/tests/test4.yaml
index ce7a87411e..6b633fbe9b 100644
--- a/tests/test4.yaml
+++ b/tests/test4.yaml
@@ -604,6 +604,14 @@ touchscreen:
       - logger.log:
           format: Touch at (%d, %d)
           args: ["touch.x", "touch.y"]
+      - media_player.play:
+      - media_player.pause:
+      - media_player.stop:
+      - media_player.toggle:
+      - media_player.volume_up:
+      - media_player.volume_down:
+      - media_player.volume_set: 50%
+
 
 media_player:
   - platform: i2s_audio

From f3a25de11d549c7cd2b73fedca18d0e7816dcbd4 Mon Sep 17 00:00:00 2001
From: Jesse Hills <3060199+jesserockz@users.noreply.github.com>
Date: Mon, 13 Jun 2022 13:32:43 +1200
Subject: [PATCH 56/60] Bump version to 2022.6.0b3

---
 esphome/const.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/esphome/const.py b/esphome/const.py
index 80842f83be..126909f1e7 100644
--- a/esphome/const.py
+++ b/esphome/const.py
@@ -1,6 +1,6 @@
 """Constants used by esphome."""
 
-__version__ = "2022.6.0b2"
+__version__ = "2022.6.0b3"
 
 ALLOWED_NAME_CHARS = "abcdefghijklmnopqrstuvwxyz0123456789-_"
 

From 7fceb070e54281b4ad18bc4439cd7d115b865bc3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Andr=C3=A9=20Klitzing?= <aklitzing@gmail.com>
Date: Tue, 14 Jun 2022 10:36:38 +0200
Subject: [PATCH 57/60] Fix compilation with ESP32-S3 (#3543)

Co-authored-by: Jesse Hills <3060199+jesserockz@users.noreply.github.com>
---
 esphome/components/logger/logger.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/esphome/components/logger/logger.cpp b/esphome/components/logger/logger.cpp
index 08c83035b6..c97677c887 100644
--- a/esphome/components/logger/logger.cpp
+++ b/esphome/components/logger/logger.cpp
@@ -178,7 +178,8 @@ void Logger::pre_setup() {
         Serial1.setDebugOutput(ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE);
 #endif
         break;
-#if defined(USE_ESP32) && !defined(USE_ESP32_VARIANT_ESP32C3) && !defined(USE_ESP32_VARIANT_ESP32S2)
+#if defined(USE_ESP32) && !defined(USE_ESP32_VARIANT_ESP32C3) && !defined(USE_ESP32_VARIANT_ESP32S2) && \
+    !defined(USE_ESP32_VARIANT_ESP32S3)
       case UART_SELECTION_UART2:
         this->hw_serial_ = &Serial2;
         Serial2.begin(this->baud_rate_);

From b1d614e6c46d68d9bc4603303390bcd1695c6d56 Mon Sep 17 00:00:00 2001
From: Martin <25747549+martgras@users.noreply.github.com>
Date: Tue, 14 Jun 2022 10:38:09 +0200
Subject: [PATCH 58/60] Bm3xx: Fix typo (#3559)

---
 esphome/components/bmp3xx/sensor.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/esphome/components/bmp3xx/sensor.py b/esphome/components/bmp3xx/sensor.py
index 736e6df3d8..f0da1c3c24 100644
--- a/esphome/components/bmp3xx/sensor.py
+++ b/esphome/components/bmp3xx/sensor.py
@@ -25,7 +25,7 @@ OVERSAMPLING_OPTIONS = {
     "4X": Oversampling.OVERSAMPLING_X4,
     "8X": Oversampling.OVERSAMPLING_X8,
     "16X": Oversampling.OVERSAMPLING_X16,
-    "32x": Oversampling.OVERSAMPLING_X32,
+    "32X": Oversampling.OVERSAMPLING_X32,
 }
 
 IIRFilter = bmp3xx_ns.enum("IIRFilter")

From 94f6c6861a277bc9d36e0a116efbf2ed16d52dcb Mon Sep 17 00:00:00 2001
From: Jesse Hills <3060199+jesserockz@users.noreply.github.com>
Date: Tue, 14 Jun 2022 20:41:46 +1200
Subject: [PATCH 59/60] Bump version to 2022.6.0b4

---
 esphome/const.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/esphome/const.py b/esphome/const.py
index 126909f1e7..5098658958 100644
--- a/esphome/const.py
+++ b/esphome/const.py
@@ -1,6 +1,6 @@
 """Constants used by esphome."""
 
-__version__ = "2022.6.0b3"
+__version__ = "2022.6.0b4"
 
 ALLOWED_NAME_CHARS = "abcdefghijklmnopqrstuvwxyz0123456789-_"
 

From 2d1abaa68e43b7d7615d7a303e5cd377d5317c8a Mon Sep 17 00:00:00 2001
From: Jesse Hills <3060199+jesserockz@users.noreply.github.com>
Date: Thu, 16 Jun 2022 11:31:38 +1200
Subject: [PATCH 60/60] Bump version to 2022.6.0

---
 esphome/const.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/esphome/const.py b/esphome/const.py
index 5098658958..32bb27b35e 100644
--- a/esphome/const.py
+++ b/esphome/const.py
@@ -1,6 +1,6 @@
 """Constants used by esphome."""
 
-__version__ = "2022.6.0b4"
+__version__ = "2022.6.0"
 
 ALLOWED_NAME_CHARS = "abcdefghijklmnopqrstuvwxyz0123456789-_"