diff --git a/esphome/components/dfplayer/dfplayer.cpp b/esphome/components/dfplayer/dfplayer.cpp
index aa2dc260e0..98c3e91e46 100644
--- a/esphome/components/dfplayer/dfplayer.cpp
+++ b/esphome/components/dfplayer/dfplayer.cpp
@@ -6,7 +6,104 @@ namespace dfplayer {
 
 static const char *const TAG = "dfplayer";
 
+void DFPlayer::next() {
+  this->ack_set_is_playing_ = true;
+  ESP_LOGD(TAG, "Playing next track");
+  this->send_cmd_(0x01);
+}
+
+void DFPlayer::previous() {
+  this->ack_set_is_playing_ = true;
+  ESP_LOGD(TAG, "Playing previous track");
+  this->send_cmd_(0x02);
+}
+void DFPlayer::play_mp3(uint16_t file) {
+  this->ack_set_is_playing_ = true;
+  ESP_LOGD(TAG, "Playing file %d in mp3 folder", file);
+  this->send_cmd_(0x12, file);
+}
+
+void DFPlayer::play_file(uint16_t file) {
+  this->ack_set_is_playing_ = true;
+  ESP_LOGD(TAG, "Playing file %d", file);
+  this->send_cmd_(0x03, file);
+}
+
+void DFPlayer::play_file_loop(uint16_t file) {
+  this->ack_set_is_playing_ = true;
+  ESP_LOGD(TAG, "Playing file %d in loop", file);
+  this->send_cmd_(0x08, file);
+}
+
+void DFPlayer::play_folder_loop(uint16_t folder) {
+  this->ack_set_is_playing_ = true;
+  ESP_LOGD(TAG, "Playing folder %d in loop", folder);
+  this->send_cmd_(0x17, folder);
+}
+
+void DFPlayer::volume_up() {
+  ESP_LOGD(TAG, "Increasing volume");
+  this->send_cmd_(0x04);
+}
+
+void DFPlayer::volume_down() {
+  ESP_LOGD(TAG, "Decreasing volume");
+  this->send_cmd_(0x05);
+}
+
+void DFPlayer::set_device(Device device) {
+  ESP_LOGD(TAG, "Setting device to %d", device);
+  this->send_cmd_(0x09, device);
+}
+
+void DFPlayer::set_volume(uint8_t volume) {
+  ESP_LOGD(TAG, "Setting volume to %d", volume);
+  this->send_cmd_(0x06, volume);
+}
+
+void DFPlayer::set_eq(EqPreset preset) {
+  ESP_LOGD(TAG, "Setting EQ to %d", preset);
+  this->send_cmd_(0x07, preset);
+}
+
+void DFPlayer::sleep() {
+  this->ack_reset_is_playing_ = true;
+  ESP_LOGD(TAG, "Putting DFPlayer to sleep");
+  this->send_cmd_(0x0A);
+}
+
+void DFPlayer::reset() {
+  this->ack_reset_is_playing_ = true;
+  ESP_LOGD(TAG, "Resetting DFPlayer");
+  this->send_cmd_(0x0C);
+}
+
+void DFPlayer::start() {
+  this->ack_set_is_playing_ = true;
+  ESP_LOGD(TAG, "Starting playback");
+  this->send_cmd_(0x0D);
+}
+
+void DFPlayer::pause() {
+  this->ack_reset_is_playing_ = true;
+  ESP_LOGD(TAG, "Pausing playback");
+  this->send_cmd_(0x0E);
+}
+
+void DFPlayer::stop() {
+  this->ack_reset_is_playing_ = true;
+  ESP_LOGD(TAG, "Stopping playback");
+  this->send_cmd_(0x16);
+}
+
+void DFPlayer::random() {
+  this->ack_set_is_playing_ = true;
+  ESP_LOGD(TAG, "Playing random file");
+  this->send_cmd_(0x18);
+}
+
 void DFPlayer::play_folder(uint16_t folder, uint16_t file) {
+  ESP_LOGD(TAG, "Playing file %d in folder %d", file, folder);
   if (folder < 100 && file < 256) {
     this->ack_set_is_playing_ = true;
     this->send_cmd_(0x0F, (uint8_t) folder, (uint8_t) file);
@@ -29,7 +126,7 @@ void DFPlayer::send_cmd_(uint8_t cmd, uint16_t argument) {
 
   this->sent_cmd_ = cmd;
 
-  ESP_LOGD(TAG, "Send Command %#02x arg %#04x", cmd, argument);
+  ESP_LOGV(TAG, "Send Command %#02x arg %#04x", cmd, argument);
   this->write_array(buffer, 10);
 }
 
@@ -101,9 +198,37 @@ void DFPlayer::loop() {
             ESP_LOGV(TAG, "Nack");
             this->ack_set_is_playing_ = false;
             this->ack_reset_is_playing_ = false;
-            if (argument == 6) {
-              ESP_LOGV(TAG, "File not found");
-              this->is_playing_ = false;
+            switch (argument) {
+              case 0x01:
+                ESP_LOGE(TAG, "Module is busy or uninitialized");
+                break;
+              case 0x02:
+                ESP_LOGE(TAG, "Module is in sleep mode");
+                break;
+              case 0x03:
+                ESP_LOGE(TAG, "Serial receive error");
+                break;
+              case 0x04:
+                ESP_LOGE(TAG, "Checksum incorrect");
+                break;
+              case 0x05:
+                ESP_LOGE(TAG, "Specified track is out of current track scope");
+                this->is_playing_ = false;
+                break;
+              case 0x06:
+                ESP_LOGE(TAG, "Specified track is not found");
+                this->is_playing_ = false;
+                break;
+              case 0x07:
+                ESP_LOGE(TAG, "Insertion error (an inserting operation only can be done when a track is being played)");
+                break;
+              case 0x08:
+                ESP_LOGE(TAG, "SD card reading failed (SD card pulled out or damaged)");
+                break;
+              case 0x09:
+                ESP_LOGE(TAG, "Entered into sleep mode");
+                this->is_playing_ = false;
+                break;
             }
             break;
           case 0x41:
@@ -113,12 +238,13 @@ void DFPlayer::loop() {
             this->ack_set_is_playing_ = false;
             this->ack_reset_is_playing_ = false;
             break;
-          case 0x3D:  // Playback finished
+          case 0x3D:
+            ESP_LOGV(TAG, "Playback finished");
             this->is_playing_ = false;
             this->on_finished_playback_callback_.call();
             break;
           default:
-            ESP_LOGD(TAG, "Command %#02x arg %#04x", cmd, argument);
+            ESP_LOGV(TAG, "Received unknown cmd %#02x arg %#04x", cmd, argument);
         }
         this->sent_cmd_ = 0;
         this->read_pos_ = 0;
diff --git a/esphome/components/dfplayer/dfplayer.h b/esphome/components/dfplayer/dfplayer.h
index 26e90fd410..d2ec0a2310 100644
--- a/esphome/components/dfplayer/dfplayer.h
+++ b/esphome/components/dfplayer/dfplayer.h
@@ -23,64 +23,30 @@ enum Device {
   TF_CARD = 2,
 };
 
+// See the datasheet here:
+// https://github.com/DFRobot/DFRobotDFPlayerMini/blob/master/doc/FN-M16P%2BEmbedded%2BMP3%2BAudio%2BModule%2BDatasheet.pdf
 class DFPlayer : public uart::UARTDevice, public Component {
  public:
   void loop() override;
 
-  void next() {
-    this->ack_set_is_playing_ = true;
-    this->send_cmd_(0x01);
-  }
-  void previous() {
-    this->ack_set_is_playing_ = true;
-    this->send_cmd_(0x02);
-  }
-  void play_mp3(uint16_t file) {
-    this->ack_set_is_playing_ = true;
-    this->send_cmd_(0x12, file);
-  }
-  void play_file(uint16_t file) {
-    this->ack_set_is_playing_ = true;
-    this->send_cmd_(0x03, file);
-  }
-  void play_file_loop(uint16_t file) {
-    this->ack_set_is_playing_ = true;
-    this->send_cmd_(0x08, file);
-  }
+  void next();
+  void previous();
+  void play_mp3(uint16_t file);
+  void play_file(uint16_t file);
+  void play_file_loop(uint16_t file);
   void play_folder(uint16_t folder, uint16_t file);
-  void play_folder_loop(uint16_t folder) {
-    this->ack_set_is_playing_ = true;
-    this->send_cmd_(0x17, folder);
-  }
-  void volume_up() { this->send_cmd_(0x04); }
-  void volume_down() { this->send_cmd_(0x05); }
-  void set_device(Device device) { this->send_cmd_(0x09, device); }
-  void set_volume(uint8_t volume) { this->send_cmd_(0x06, volume); }
-  void set_eq(EqPreset preset) { this->send_cmd_(0x07, preset); }
-  void sleep() {
-    this->ack_reset_is_playing_ = true;
-    this->send_cmd_(0x0A);
-  }
-  void reset() {
-    this->ack_reset_is_playing_ = true;
-    this->send_cmd_(0x0C);
-  }
-  void start() {
-    this->ack_set_is_playing_ = true;
-    this->send_cmd_(0x0D);
-  }
-  void pause() {
-    this->ack_reset_is_playing_ = true;
-    this->send_cmd_(0x0E);
-  }
-  void stop() {
-    this->ack_reset_is_playing_ = true;
-    this->send_cmd_(0x16);
-  }
-  void random() {
-    this->ack_set_is_playing_ = true;
-    this->send_cmd_(0x18);
-  }
+  void play_folder_loop(uint16_t folder);
+  void volume_up();
+  void volume_down();
+  void set_device(Device device);
+  void set_volume(uint8_t volume);
+  void set_eq(EqPreset preset);
+  void sleep();
+  void reset();
+  void start();
+  void pause();
+  void stop();
+  void random();
 
   bool is_playing() { return is_playing_; }
   void dump_config() override;
diff --git a/esphome/components/i2s_audio/speaker/__init__.py b/esphome/components/i2s_audio/speaker/__init__.py
index dd43d6cb39..0355c16321 100644
--- a/esphome/components/i2s_audio/speaker/__init__.py
+++ b/esphome/components/i2s_audio/speaker/__init__.py
@@ -24,9 +24,10 @@ I2SAudioSpeaker = i2s_audio_ns.class_(
     "I2SAudioSpeaker", cg.Component, speaker.Speaker, I2SAudioOut
 )
 
-
+CONF_BUFFER_DURATION = "buffer_duration"
 CONF_DAC_TYPE = "dac_type"
 CONF_I2S_COMM_FMT = "i2s_comm_fmt"
+CONF_NEVER = "never"
 
 i2s_dac_mode_t = cg.global_ns.enum("i2s_dac_mode_t")
 INTERNAL_DAC_OPTIONS = {
@@ -73,8 +74,12 @@ BASE_SCHEMA = (
     .extend(
         {
             cv.Optional(
-                CONF_TIMEOUT, default="500ms"
+                CONF_BUFFER_DURATION, default="500ms"
             ): cv.positive_time_period_milliseconds,
+            cv.Optional(CONF_TIMEOUT, default="500ms"): cv.Any(
+                cv.positive_time_period_milliseconds,
+                cv.one_of(CONF_NEVER, lower=True),
+            ),
         }
     )
     .extend(cv.COMPONENT_SCHEMA)
@@ -116,4 +121,6 @@ async def to_code(config):
     else:
         cg.add(var.set_dout_pin(config[CONF_I2S_DOUT_PIN]))
         cg.add(var.set_i2s_comm_fmt(config[CONF_I2S_COMM_FMT]))
-    cg.add(var.set_timeout(config[CONF_TIMEOUT]))
+    if config[CONF_TIMEOUT] != CONF_NEVER:
+        cg.add(var.set_timeout(config[CONF_TIMEOUT]))
+    cg.add(var.set_buffer_duration(config[CONF_BUFFER_DURATION]))
diff --git a/esphome/components/i2s_audio/speaker/i2s_audio_speaker.cpp b/esphome/components/i2s_audio/speaker/i2s_audio_speaker.cpp
index cf6c3bbbba..c3f4566411 100644
--- a/esphome/components/i2s_audio/speaker/i2s_audio_speaker.cpp
+++ b/esphome/components/i2s_audio/speaker/i2s_audio_speaker.cpp
@@ -13,21 +13,22 @@
 namespace esphome {
 namespace i2s_audio {
 
-static const size_t DMA_BUFFER_SIZE = 512;
+static const uint8_t DMA_BUFFER_DURATION_MS = 15;
 static const size_t DMA_BUFFERS_COUNT = 4;
-static const size_t FRAMES_IN_ALL_DMA_BUFFERS = DMA_BUFFER_SIZE * DMA_BUFFERS_COUNT;
-static const size_t RING_BUFFER_SAMPLES = 8192;
-static const size_t TASK_DELAY_MS = 10;
+
+static const size_t TASK_DELAY_MS = DMA_BUFFER_DURATION_MS * DMA_BUFFERS_COUNT / 2;
+
 static const size_t TASK_STACK_SIZE = 4096;
 static const ssize_t TASK_PRIORITY = 23;
 
+static const size_t I2S_EVENT_QUEUE_COUNT = DMA_BUFFERS_COUNT + 1;
+
 static const char *const TAG = "i2s_audio.speaker";
 
 enum SpeakerEventGroupBits : uint32_t {
-  COMMAND_START = (1 << 0),                           // Starts the main task purpose
-  COMMAND_STOP = (1 << 1),                            // stops the main task
-  COMMAND_STOP_GRACEFULLY = (1 << 2),                 // Stops the task once all data has been written
-  MESSAGE_RING_BUFFER_AVAILABLE_TO_WRITE = (1 << 5),  // Locks the ring buffer when not set
+  COMMAND_START = (1 << 0),            // starts the speaker task
+  COMMAND_STOP = (1 << 1),             // stops the speaker task
+  COMMAND_STOP_GRACEFULLY = (1 << 2),  // Stops the speaker task once all data has been written
   STATE_STARTING = (1 << 10),
   STATE_RUNNING = (1 << 11),
   STATE_STOPPING = (1 << 12),
@@ -91,15 +92,21 @@ static const std::vector<int16_t> Q15_VOLUME_SCALING_FACTORS = {
 void I2SAudioSpeaker::setup() {
   ESP_LOGCONFIG(TAG, "Setting up I2S Audio Speaker...");
 
-  if (this->event_group_ == nullptr) {
-    this->event_group_ = xEventGroupCreate();
-  }
+  this->event_group_ = xEventGroupCreate();
 
   if (this->event_group_ == nullptr) {
     ESP_LOGE(TAG, "Failed to create event group");
     this->mark_failed();
     return;
   }
+
+  this->i2s_event_queue_ = xQueueCreate(I2S_EVENT_QUEUE_COUNT, sizeof(i2s_event_t));
+
+  if (this->i2s_event_queue_ == nullptr) {
+    ESP_LOGE(TAG, "Failed to create I2S event queue");
+    this->mark_failed();
+    return;
+  }
 }
 
 void I2SAudioSpeaker::loop() {
@@ -199,23 +206,17 @@ size_t I2SAudioSpeaker::play(const uint8_t *data, size_t length, TickType_t tick
     this->start();
   }
 
-  // Wait for the ring buffer to be available
-  uint32_t event_bits =
-      xEventGroupWaitBits(this->event_group_, SpeakerEventGroupBits::MESSAGE_RING_BUFFER_AVAILABLE_TO_WRITE, pdFALSE,
-                          pdFALSE, pdMS_TO_TICKS(TASK_DELAY_MS));
+  size_t bytes_written = 0;
+  if ((this->state_ == speaker::STATE_RUNNING) && (this->audio_ring_buffer_.use_count() == 1)) {
+    // Only one owner of the ring buffer (the speaker task), so the ring buffer is allocated and no other components are
+    // attempting to write to it.
 
-  if (event_bits & SpeakerEventGroupBits::MESSAGE_RING_BUFFER_AVAILABLE_TO_WRITE) {
-    // Ring buffer is available to write
-
-    // Lock the ring buffer, write to it, then unlock it
-    xEventGroupClearBits(this->event_group_, SpeakerEventGroupBits::MESSAGE_RING_BUFFER_AVAILABLE_TO_WRITE);
-    size_t bytes_written = this->audio_ring_buffer_->write_without_replacement((void *) data, length, ticks_to_wait);
-    xEventGroupSetBits(this->event_group_, SpeakerEventGroupBits::MESSAGE_RING_BUFFER_AVAILABLE_TO_WRITE);
-
-    return bytes_written;
+    // Temporarily share ownership of the ring buffer so it won't be deallocated while writing
+    std::shared_ptr<RingBuffer> temp_ring_buffer = this->audio_ring_buffer_;
+    bytes_written = temp_ring_buffer->write_without_replacement((void *) data, length, ticks_to_wait);
   }
 
-  return 0;
+  return bytes_written;
 }
 
 bool I2SAudioSpeaker::has_buffered_data() const {
@@ -246,10 +247,12 @@ void I2SAudioSpeaker::speaker_task(void *params) {
   const ssize_t bytes_per_sample = audio_stream_info.get_bytes_per_sample();
   const uint8_t number_of_channels = audio_stream_info.channels;
 
-  const size_t dma_buffers_size = FRAMES_IN_ALL_DMA_BUFFERS * bytes_per_sample * number_of_channels;
+  const size_t dma_buffers_size = DMA_BUFFERS_COUNT * DMA_BUFFER_DURATION_MS * this_speaker->sample_rate_ / 1000 *
+                                  bytes_per_sample * number_of_channels;
+  const size_t ring_buffer_size =
+      this_speaker->buffer_duration_ms_ * this_speaker->sample_rate_ / 1000 * bytes_per_sample * number_of_channels;
 
-  if (this_speaker->send_esp_err_to_event_group_(
-          this_speaker->allocate_buffers_(dma_buffers_size, RING_BUFFER_SAMPLES * bytes_per_sample))) {
+  if (this_speaker->send_esp_err_to_event_group_(this_speaker->allocate_buffers_(dma_buffers_size, ring_buffer_size))) {
     // Failed to allocate buffers
     xEventGroupSetBits(this_speaker->event_group_, SpeakerEventGroupBits::ERR_ESP_NO_MEM);
     this_speaker->delete_task_(dma_buffers_size);
@@ -258,9 +261,6 @@ void I2SAudioSpeaker::speaker_task(void *params) {
   if (this_speaker->send_esp_err_to_event_group_(this_speaker->start_i2s_driver_())) {
     // Failed to start I2S driver
     this_speaker->delete_task_(dma_buffers_size);
-  } else {
-    // Ring buffer is allocated, so indicate its can be written to
-    xEventGroupSetBits(this_speaker->event_group_, SpeakerEventGroupBits::MESSAGE_RING_BUFFER_AVAILABLE_TO_WRITE);
   }
 
   if (!this_speaker->send_esp_err_to_event_group_(this_speaker->reconfigure_i2s_stream_info_(audio_stream_info))) {
@@ -270,8 +270,10 @@ void I2SAudioSpeaker::speaker_task(void *params) {
 
     bool stop_gracefully = false;
     uint32_t last_data_received_time = millis();
+    bool tx_dma_underflow = false;
 
-    while ((millis() - last_data_received_time) <= this_speaker->timeout_) {
+    while (!this_speaker->timeout_.has_value() ||
+           (millis() - last_data_received_time) <= this_speaker->timeout_.value()) {
       event_group_bits = xEventGroupGetBits(this_speaker->event_group_);
 
       if (event_group_bits & SpeakerEventGroupBits::COMMAND_STOP) {
@@ -281,12 +283,18 @@ void I2SAudioSpeaker::speaker_task(void *params) {
         stop_gracefully = true;
       }
 
+      i2s_event_t i2s_event;
+      while (xQueueReceive(this_speaker->i2s_event_queue_, &i2s_event, 0)) {
+        if (i2s_event.type == I2S_EVENT_TX_Q_OVF) {
+          tx_dma_underflow = true;
+        }
+      }
+
       size_t bytes_to_read = dma_buffers_size;
       size_t bytes_read = this_speaker->audio_ring_buffer_->read((void *) this_speaker->data_buffer_, bytes_to_read,
                                                                  pdMS_TO_TICKS(TASK_DELAY_MS));
 
       if (bytes_read > 0) {
-        last_data_received_time = millis();
         size_t bytes_written = 0;
 
         if ((audio_stream_info.bits_per_sample == 16) && (this_speaker->q15_volume_factor_ < INT16_MAX)) {
@@ -307,15 +315,13 @@ void I2SAudioSpeaker::speaker_task(void *params) {
         if (bytes_written != bytes_read) {
           xEventGroupSetBits(this_speaker->event_group_, SpeakerEventGroupBits::ERR_ESP_INVALID_SIZE);
         }
-
+        tx_dma_underflow = false;
+        last_data_received_time = millis();
       } else {
         // No data received
-
-        if (stop_gracefully) {
+        if (stop_gracefully && tx_dma_underflow) {
           break;
         }
-
-        i2s_zero_dma_buffer(this_speaker->parent_->get_port());
       }
     }
   } else {
@@ -326,7 +332,6 @@ void I2SAudioSpeaker::speaker_task(void *params) {
 
   xEventGroupSetBits(this_speaker->event_group_, SpeakerEventGroupBits::STATE_STOPPING);
 
-  i2s_stop(this_speaker->parent_->get_port());
   i2s_driver_uninstall(this_speaker->parent_->get_port());
 
   this_speaker->parent_->unlock();
@@ -402,8 +407,8 @@ esp_err_t I2SAudioSpeaker::allocate_buffers_(size_t data_buffer_size, size_t rin
     return ESP_ERR_NO_MEM;
   }
 
-  if (this->audio_ring_buffer_ == nullptr) {
-    // Allocate ring buffer
+  if (this->audio_ring_buffer_.use_count() == 0) {
+    // Allocate ring buffer. Uses a shared_ptr to ensure it isn't improperly deallocated.
     this->audio_ring_buffer_ = RingBuffer::create(ring_buffer_size);
   }
 
@@ -419,6 +424,8 @@ esp_err_t I2SAudioSpeaker::start_i2s_driver_() {
     return ESP_ERR_INVALID_STATE;
   }
 
+  int dma_buffer_length = DMA_BUFFER_DURATION_MS * this->sample_rate_ / 1000;
+
   i2s_driver_config_t config = {
     .mode = (i2s_mode_t) (this->i2s_mode_ | I2S_MODE_TX),
     .sample_rate = this->sample_rate_,
@@ -427,7 +434,7 @@ esp_err_t I2SAudioSpeaker::start_i2s_driver_() {
     .communication_format = this->i2s_comm_fmt_,
     .intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
     .dma_buf_count = DMA_BUFFERS_COUNT,
-    .dma_buf_len = DMA_BUFFER_SIZE,
+    .dma_buf_len = dma_buffer_length,
     .use_apll = this->use_apll_,
     .tx_desc_auto_clear = true,
     .fixed_mclk = I2S_PIN_NO_CHANGE,
@@ -448,7 +455,8 @@ esp_err_t I2SAudioSpeaker::start_i2s_driver_() {
   }
 #endif
 
-  esp_err_t err = i2s_driver_install(this->parent_->get_port(), &config, 0, nullptr);
+  esp_err_t err =
+      i2s_driver_install(this->parent_->get_port(), &config, I2S_EVENT_QUEUE_COUNT, &this->i2s_event_queue_);
   if (err != ESP_OK) {
     // Failed to install the driver, so unlock the I2S port
     this->parent_->unlock();
@@ -502,16 +510,7 @@ esp_err_t I2SAudioSpeaker::reconfigure_i2s_stream_info_(audio::AudioStreamInfo &
 }
 
 void I2SAudioSpeaker::delete_task_(size_t buffer_size) {
-  if (this->audio_ring_buffer_ != nullptr) {
-    xEventGroupWaitBits(this->event_group_,
-                        MESSAGE_RING_BUFFER_AVAILABLE_TO_WRITE,  // Bit message to read
-                        pdFALSE,                                 // Don't clear the bits on exit
-                        pdTRUE,                                  // Don't wait for all the bits,
-                        portMAX_DELAY);                          // Block indefinitely until a command bit is set
-
-    this->audio_ring_buffer_.reset();  // Deallocates the ring buffer stored in the unique_ptr
-    this->audio_ring_buffer_ = nullptr;
-  }
+  this->audio_ring_buffer_.reset();  // Releases onwership of the shared_ptr
 
   if (this->data_buffer_ != nullptr) {
     ExternalRAMAllocator<uint8_t> allocator(ExternalRAMAllocator<uint8_t>::ALLOW_FAILURE);
@@ -520,6 +519,7 @@ void I2SAudioSpeaker::delete_task_(size_t buffer_size) {
   }
 
   xEventGroupSetBits(this->event_group_, SpeakerEventGroupBits::STATE_STOPPED);
+  xQueueReset(this->i2s_event_queue_);
 
   this->task_created_ = false;
   vTaskDelete(nullptr);
diff --git a/esphome/components/i2s_audio/speaker/i2s_audio_speaker.h b/esphome/components/i2s_audio/speaker/i2s_audio_speaker.h
index 3c512d4d4d..8b7386ba58 100644
--- a/esphome/components/i2s_audio/speaker/i2s_audio_speaker.h
+++ b/esphome/components/i2s_audio/speaker/i2s_audio_speaker.h
@@ -7,6 +7,7 @@
 #include <driver/i2s.h>
 
 #include <freertos/event_groups.h>
+#include <freertos/queue.h>
 #include <freertos/FreeRTOS.h>
 
 #include "esphome/components/audio/audio.h"
@@ -27,6 +28,7 @@ class I2SAudioSpeaker : public I2SAudioOut, public speaker::Speaker, public Comp
   void setup() override;
   void loop() override;
 
+  void set_buffer_duration(uint32_t buffer_duration_ms) { this->buffer_duration_ms_ = buffer_duration_ms; }
   void set_timeout(uint32_t ms) { this->timeout_ = ms; }
   void set_dout_pin(uint8_t pin) { this->dout_pin_ = pin; }
 #if SOC_I2S_SUPPORTS_DAC
@@ -117,10 +119,14 @@ class I2SAudioSpeaker : public I2SAudioOut, public speaker::Speaker, public Comp
   TaskHandle_t speaker_task_handle_{nullptr};
   EventGroupHandle_t event_group_{nullptr};
 
-  uint8_t *data_buffer_;
-  std::unique_ptr<RingBuffer> audio_ring_buffer_;
+  QueueHandle_t i2s_event_queue_;
 
-  uint32_t timeout_;
+  uint8_t *data_buffer_;
+  std::shared_ptr<RingBuffer> audio_ring_buffer_;
+
+  uint32_t buffer_duration_ms_;
+
+  optional<uint32_t> timeout_;
   uint8_t dout_pin_;
 
   bool task_created_{false};
diff --git a/esphome/components/modbus_controller/__init__.py b/esphome/components/modbus_controller/__init__.py
index 488baa245a..5c407d6fff 100644
--- a/esphome/components/modbus_controller/__init__.py
+++ b/esphome/components/modbus_controller/__init__.py
@@ -25,6 +25,8 @@ from .const import (
     CONF_MODBUS_CONTROLLER_ID,
     CONF_OFFLINE_SKIP_UPDATES,
     CONF_ON_COMMAND_SENT,
+    CONF_ON_ONLINE,
+    CONF_ON_OFFLINE,
     CONF_REGISTER_COUNT,
     CONF_REGISTER_TYPE,
     CONF_RESPONSE_SIZE,
@@ -114,6 +116,14 @@ ModbusCommandSentTrigger = modbus_controller_ns.class_(
     "ModbusCommandSentTrigger", automation.Trigger.template(cg.int_, cg.int_)
 )
 
+ModbusOnlineTrigger = modbus_controller_ns.class_(
+    "ModbusOnlineTrigger", automation.Trigger.template(cg.int_, cg.int_)
+)
+
+ModbusOfflineTrigger = modbus_controller_ns.class_(
+    "ModbusOfflineTrigger", automation.Trigger.template(cg.int_, cg.int_)
+)
+
 _LOGGER = logging.getLogger(__name__)
 
 ModbusServerRegisterSchema = cv.Schema(
@@ -146,6 +156,16 @@ CONFIG_SCHEMA = cv.All(
                     ),
                 }
             ),
+            cv.Optional(CONF_ON_ONLINE): automation.validate_automation(
+                {
+                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(ModbusOnlineTrigger),
+                }
+            ),
+            cv.Optional(CONF_ON_OFFLINE): automation.validate_automation(
+                {
+                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(ModbusOnlineTrigger),
+                }
+            ),
         }
     )
     .extend(cv.polling_component_schema("60s"))
@@ -284,7 +304,17 @@ async def to_code(config):
     for conf in config.get(CONF_ON_COMMAND_SENT, []):
         trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
         await automation.build_automation(
-            trigger, [(int, "function_code"), (int, "address")], conf
+            trigger, [(cg.int_, "function_code"), (cg.int_, "address")], conf
+        )
+    for conf in config.get(CONF_ON_ONLINE, []):
+        trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
+        await automation.build_automation(
+            trigger, [(cg.int_, "function_code"), (cg.int_, "address")], conf
+        )
+    for conf in config.get(CONF_ON_OFFLINE, []):
+        trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
+        await automation.build_automation(
+            trigger, [(cg.int_, "function_code"), (cg.int_, "address")], conf
         )
 
 
diff --git a/esphome/components/modbus_controller/automation.h b/esphome/components/modbus_controller/automation.h
index ad8de4b05d..b3338192cc 100644
--- a/esphome/components/modbus_controller/automation.h
+++ b/esphome/components/modbus_controller/automation.h
@@ -15,5 +15,21 @@ class ModbusCommandSentTrigger : public Trigger<int, int> {
   }
 };
 
+class ModbusOnlineTrigger : public Trigger<int, int> {
+ public:
+  ModbusOnlineTrigger(ModbusController *a_modbuscontroller) {
+    a_modbuscontroller->add_on_online_callback(
+        [this](int function_code, int address) { this->trigger(function_code, address); });
+  }
+};
+
+class ModbusOfflineTrigger : public Trigger<int, int> {
+ public:
+  ModbusOfflineTrigger(ModbusController *a_modbuscontroller) {
+    a_modbuscontroller->add_on_offline_callback(
+        [this](int function_code, int address) { this->trigger(function_code, address); });
+  }
+};
+
 }  // namespace modbus_controller
 }  // namespace esphome
diff --git a/esphome/components/modbus_controller/const.py b/esphome/components/modbus_controller/const.py
index 5cf7d230f1..4d39e48dcd 100644
--- a/esphome/components/modbus_controller/const.py
+++ b/esphome/components/modbus_controller/const.py
@@ -9,6 +9,8 @@ CONF_MAX_CMD_RETRIES = "max_cmd_retries"
 CONF_MODBUS_CONTROLLER_ID = "modbus_controller_id"
 CONF_MODBUS_FUNCTIONCODE = "modbus_functioncode"
 CONF_ON_COMMAND_SENT = "on_command_sent"
+CONF_ON_ONLINE = "on_online"
+CONF_ON_OFFLINE = "on_offline"
 CONF_RAW_ENCODE = "raw_encode"
 CONF_REGISTER_COUNT = "register_count"
 CONF_REGISTER_TYPE = "register_type"
diff --git a/esphome/components/modbus_controller/modbus_controller.cpp b/esphome/components/modbus_controller/modbus_controller.cpp
index 1dcb533629..e1102516ca 100644
--- a/esphome/components/modbus_controller/modbus_controller.cpp
+++ b/esphome/components/modbus_controller/modbus_controller.cpp
@@ -32,8 +32,10 @@ bool ModbusController::send_next_command_() {
             r.skip_updates_counter = this->offline_skip_updates_;
           }
         }
+
+        this->module_offline_ = true;
+        this->offline_callback_.call((int) command->function_code, command->register_address);
       }
-      this->module_offline_ = true;
       ESP_LOGD(TAG, "Modbus command to device=%d register=0x%02X no response received - removed from send queue",
                this->address_, command->register_address);
       this->command_queue_.pop_front();
@@ -68,8 +70,10 @@ void ModbusController::on_modbus_data(const std::vector<uint8_t> &data) {
           r.skip_updates_counter = 0;
         }
       }
+      // Restore module online state
+      this->module_offline_ = false;
+      this->online_callback_.call((int) current_command->function_code, current_command->register_address);
     }
-    this->module_offline_ = false;
 
     // Move the commandItem to the response queue
     current_command->payload = data;
@@ -670,5 +674,13 @@ void ModbusController::add_on_command_sent_callback(std::function<void(int, int)
   this->command_sent_callback_.add(std::move(callback));
 }
 
+void ModbusController::add_on_online_callback(std::function<void(int, int)> &&callback) {
+  this->online_callback_.add(std::move(callback));
+}
+
+void ModbusController::add_on_offline_callback(std::function<void(int, int)> &&callback) {
+  this->offline_callback_.add(std::move(callback));
+}
+
 }  // namespace modbus_controller
 }  // namespace esphome
diff --git a/esphome/components/modbus_controller/modbus_controller.h b/esphome/components/modbus_controller/modbus_controller.h
index 1fa35e1535..2a0b936bf5 100644
--- a/esphome/components/modbus_controller/modbus_controller.h
+++ b/esphome/components/modbus_controller/modbus_controller.h
@@ -468,6 +468,10 @@ class ModbusController : public PollingComponent, public modbus::ModbusDevice {
   bool get_module_offline() { return module_offline_; }
   /// Set callback for commands
   void add_on_command_sent_callback(std::function<void(int, int)> &&callback);
+  /// Set callback for online changes
+  void add_on_online_callback(std::function<void(int, int)> &&callback);
+  /// Set callback for offline changes
+  void add_on_offline_callback(std::function<void(int, int)> &&callback);
   /// called by esphome generated code to set the max_cmd_retries.
   void set_max_cmd_retries(uint8_t max_cmd_retries) { this->max_cmd_retries_ = max_cmd_retries; }
   /// get how many times a command will be (re)sent if no response is received
@@ -508,7 +512,12 @@ class ModbusController : public PollingComponent, public modbus::ModbusDevice {
   uint16_t offline_skip_updates_;
   /// How many times we will retry a command if we get no response
   uint8_t max_cmd_retries_{4};
+  /// Command sent callback
   CallbackManager<void(int, int)> command_sent_callback_{};
+  /// Server online callback
+  CallbackManager<void(int, int)> online_callback_{};
+  /// Server offline callback
+  CallbackManager<void(int, int)> offline_callback_{};
 };
 
 /** Convert vector<uint8_t> response payload to float.
diff --git a/esphome/components/opentherm/__init__.py b/esphome/components/opentherm/__init__.py
index ee19818a29..81cd78af08 100644
--- a/esphome/components/opentherm/__init__.py
+++ b/esphome/components/opentherm/__init__.py
@@ -3,8 +3,9 @@ from typing import Any
 import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome import pins
+from esphome.components import sensor
 from esphome.const import CONF_ID, PLATFORM_ESP32, PLATFORM_ESP8266
-from . import generate
+from . import const, schema, validate, generate
 
 CODEOWNERS = ["@olegtarasov"]
 MULTI_CONF = True
@@ -19,6 +20,7 @@ CONF_CH2_ACTIVE = "ch2_active"
 CONF_SUMMER_MODE_ACTIVE = "summer_mode_active"
 CONF_DHW_BLOCK = "dhw_block"
 CONF_SYNC_MODE = "sync_mode"
+CONF_OPENTHERM_VERSION = "opentherm_version"
 
 CONFIG_SCHEMA = cv.All(
     cv.Schema(
@@ -34,8 +36,15 @@ CONFIG_SCHEMA = cv.All(
             cv.Optional(CONF_SUMMER_MODE_ACTIVE, False): cv.boolean,
             cv.Optional(CONF_DHW_BLOCK, False): cv.boolean,
             cv.Optional(CONF_SYNC_MODE, False): cv.boolean,
+            cv.Optional(CONF_OPENTHERM_VERSION): cv.positive_float,
         }
-    ).extend(cv.COMPONENT_SCHEMA),
+    )
+    .extend(
+        validate.create_entities_schema(
+            schema.INPUTS, (lambda _: cv.use_id(sensor.Sensor))
+        )
+    )
+    .extend(cv.COMPONENT_SCHEMA),
     cv.only_on([PLATFORM_ESP32, PLATFORM_ESP8266]),
 )
 
@@ -52,8 +61,23 @@ async def to_code(config: dict[str, Any]) -> None:
     cg.add(var.set_out_pin(out_pin))
 
     non_sensors = {CONF_ID, CONF_IN_PIN, CONF_OUT_PIN}
+    input_sensors = []
     for key, value in config.items():
         if key in non_sensors:
             continue
+        if key in schema.INPUTS:
+            input_sensor = await cg.get_variable(value)
+            cg.add(
+                getattr(var, f"set_{key}_{const.INPUT_SENSOR.lower()}")(input_sensor)
+            )
+            input_sensors.append(key)
+        else:
+            cg.add(getattr(var, f"set_{key}")(value))
 
-        cg.add(getattr(var, f"set_{key}")(value))
+    if len(input_sensors) > 0:
+        generate.define_has_component(const.INPUT_SENSOR, input_sensors)
+        generate.define_message_handler(
+            const.INPUT_SENSOR, input_sensors, schema.INPUTS
+        )
+        generate.define_readers(const.INPUT_SENSOR, input_sensors)
+        generate.add_messages(var, input_sensors, schema.INPUTS)
diff --git a/esphome/components/opentherm/binary_sensor/__init__.py b/esphome/components/opentherm/binary_sensor/__init__.py
new file mode 100644
index 0000000000..643734f90c
--- /dev/null
+++ b/esphome/components/opentherm/binary_sensor/__init__.py
@@ -0,0 +1,33 @@
+from typing import Any
+
+import esphome.config_validation as cv
+from esphome.components import binary_sensor
+from .. import const, schema, validate, generate
+
+DEPENDENCIES = [const.OPENTHERM]
+COMPONENT_TYPE = const.BINARY_SENSOR
+
+
+def get_entity_validation_schema(entity: schema.BinarySensorSchema) -> cv.Schema:
+    return binary_sensor.binary_sensor_schema(
+        device_class=(
+            entity.device_class
+            or binary_sensor._UNDEF  # pylint: disable=protected-access
+        ),
+        icon=(entity.icon or binary_sensor._UNDEF),  # pylint: disable=protected-access
+    )
+
+
+CONFIG_SCHEMA = validate.create_component_schema(
+    schema.BINARY_SENSORS, get_entity_validation_schema
+)
+
+
+async def to_code(config: dict[str, Any]) -> None:
+    await generate.component_to_code(
+        COMPONENT_TYPE,
+        schema.BINARY_SENSORS,
+        binary_sensor.BinarySensor,
+        generate.create_only_conf(binary_sensor.new_binary_sensor),
+        config,
+    )
diff --git a/esphome/components/opentherm/const.py b/esphome/components/opentherm/const.py
index 1f997c5d9c..a113331585 100644
--- a/esphome/components/opentherm/const.py
+++ b/esphome/components/opentherm/const.py
@@ -1,5 +1,11 @@
 OPENTHERM = "opentherm"
 
 CONF_OPENTHERM_ID = "opentherm_id"
+CONF_DATA_TYPE = "data_type"
 
 SENSOR = "sensor"
+BINARY_SENSOR = "binary_sensor"
+SWITCH = "switch"
+NUMBER = "number"
+OUTPUT = "output"
+INPUT_SENSOR = "input_sensor"
diff --git a/esphome/components/opentherm/generate.py b/esphome/components/opentherm/generate.py
index 6a97835a57..9716cab093 100644
--- a/esphome/components/opentherm/generate.py
+++ b/esphome/components/opentherm/generate.py
@@ -130,6 +130,8 @@ async def component_to_code(
         id = conf[CONF_ID]
         if id and id.type == type:
             entity = await create(conf, key, hub)
+            if const.CONF_DATA_TYPE in conf:
+                schemas[key].message_data = conf[const.CONF_DATA_TYPE]
             cg.add(getattr(hub, f"set_{key}_{component_type.lower()}")(entity))
             keys.append(key)
 
diff --git a/esphome/components/opentherm/hub.cpp b/esphome/components/opentherm/hub.cpp
index 770bbd82b7..dfa8ea95c5 100644
--- a/esphome/components/opentherm/hub.cpp
+++ b/esphome/components/opentherm/hub.cpp
@@ -29,6 +29,8 @@ uint8_t parse_u8_hb(OpenthermData &data) { return data.valueHB; }
 int8_t parse_s8_lb(OpenthermData &data) { return (int8_t) data.valueLB; }
 int8_t parse_s8_hb(OpenthermData &data) { return (int8_t) data.valueHB; }
 uint16_t parse_u16(OpenthermData &data) { return data.u16(); }
+uint16_t parse_u8_lb_60(OpenthermData &data) { return data.valueLB * 60; }
+uint16_t parse_u8_hb_60(OpenthermData &data) { return data.valueHB * 60; }
 int16_t parse_s16(OpenthermData &data) { return data.s16(); }
 float parse_f88(OpenthermData &data) { return data.f88(); }
 
@@ -87,13 +89,40 @@ OpenthermData OpenthermHub::build_request_(MessageId request_id) const {
     return data;
   }
 
+  // Another special case is OpenTherm version number which is configured at hub level as a constant
+  if (request_id == MessageId::OT_VERSION_CONTROLLER) {
+    data.type = MessageType::WRITE_DATA;
+    data.id = MessageId::OT_VERSION_CONTROLLER;
+    data.f88(this->opentherm_version_);
+
+    return data;
+  }
+
 // Disable incomplete switch statement warnings, because the cases in each
 // switch are generated based on the configured sensors and inputs.
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wswitch"
 
-  switch (request_id) { OPENTHERM_SENSOR_MESSAGE_HANDLERS(OPENTHERM_MESSAGE_READ_MESSAGE, OPENTHERM_IGNORE, , , ) }
+  // Next, we start with the write requests from switches and other inputs,
+  // because we would want to write that data if it is available, rather than
+  // request a read for that type (in the case that both read and write are
+  // supported).
+  switch (request_id) {
+    OPENTHERM_SWITCH_MESSAGE_HANDLERS(OPENTHERM_MESSAGE_WRITE_MESSAGE, OPENTHERM_MESSAGE_WRITE_ENTITY, ,
+                                      OPENTHERM_MESSAGE_WRITE_POSTSCRIPT, )
+    OPENTHERM_NUMBER_MESSAGE_HANDLERS(OPENTHERM_MESSAGE_WRITE_MESSAGE, OPENTHERM_MESSAGE_WRITE_ENTITY, ,
+                                      OPENTHERM_MESSAGE_WRITE_POSTSCRIPT, )
+    OPENTHERM_OUTPUT_MESSAGE_HANDLERS(OPENTHERM_MESSAGE_WRITE_MESSAGE, OPENTHERM_MESSAGE_WRITE_ENTITY, ,
+                                      OPENTHERM_MESSAGE_WRITE_POSTSCRIPT, )
+    OPENTHERM_INPUT_SENSOR_MESSAGE_HANDLERS(OPENTHERM_MESSAGE_WRITE_MESSAGE, OPENTHERM_MESSAGE_WRITE_ENTITY, ,
+                                            OPENTHERM_MESSAGE_WRITE_POSTSCRIPT, )
+  }
 
+  // Finally, handle the simple read requests, which only change with the message id.
+  switch (request_id) { OPENTHERM_SENSOR_MESSAGE_HANDLERS(OPENTHERM_MESSAGE_READ_MESSAGE, OPENTHERM_IGNORE, , , ) }
+  switch (request_id) {
+    OPENTHERM_BINARY_SENSOR_MESSAGE_HANDLERS(OPENTHERM_MESSAGE_READ_MESSAGE, OPENTHERM_IGNORE, , , )
+  }
 #pragma GCC diagnostic pop
 
   // And if we get here, a message was requested which somehow wasn't handled.
@@ -115,6 +144,10 @@ void OpenthermHub::process_response(OpenthermData &data) {
     OPENTHERM_SENSOR_MESSAGE_HANDLERS(OPENTHERM_MESSAGE_RESPONSE_MESSAGE, OPENTHERM_MESSAGE_RESPONSE_ENTITY, ,
                                       OPENTHERM_MESSAGE_RESPONSE_POSTSCRIPT, )
   }
+  switch (data.id) {
+    OPENTHERM_BINARY_SENSOR_MESSAGE_HANDLERS(OPENTHERM_MESSAGE_RESPONSE_MESSAGE, OPENTHERM_MESSAGE_RESPONSE_ENTITY, ,
+                                             OPENTHERM_MESSAGE_RESPONSE_POSTSCRIPT, )
+  }
 }
 
 void OpenthermHub::setup() {
@@ -131,6 +164,13 @@ void OpenthermHub::setup() {
   // good practice anyway.
   this->add_repeating_message(MessageId::STATUS);
 
+  // Also ensure that we start communication with the STATUS message
+  this->initial_messages_.insert(this->initial_messages_.begin(), MessageId::STATUS);
+
+  if (this->opentherm_version_ > 0.0f) {
+    this->initial_messages_.insert(this->initial_messages_.begin(), MessageId::OT_VERSION_CONTROLLER);
+  }
+
   this->current_message_iterator_ = this->initial_messages_.begin();
 }
 
@@ -331,11 +371,11 @@ void OpenthermHub::dump_config() {
   ESP_LOGCONFIG(TAG, "  Numbers: %s", SHOW(OPENTHERM_NUMBER_LIST(ID, )));
   ESP_LOGCONFIG(TAG, "  Initial requests:");
   for (auto type : this->initial_messages_) {
-    ESP_LOGCONFIG(TAG, "  - %d", type);
+    ESP_LOGCONFIG(TAG, "  - %d (%s)", type, this->opentherm_->message_id_to_str((type)));
   }
   ESP_LOGCONFIG(TAG, "  Repeating requests:");
   for (auto type : this->repeating_messages_) {
-    ESP_LOGCONFIG(TAG, "  - %d", type);
+    ESP_LOGCONFIG(TAG, "  - %d (%s)", type, this->opentherm_->message_id_to_str((type)));
   }
 }
 
diff --git a/esphome/components/opentherm/hub.h b/esphome/components/opentherm/hub.h
index 3b90cdf427..1f536653e8 100644
--- a/esphome/components/opentherm/hub.h
+++ b/esphome/components/opentherm/hub.h
@@ -4,6 +4,7 @@
 #include "esphome/core/hal.h"
 #include "esphome/core/component.h"
 #include "esphome/core/log.h"
+#include <vector>
 
 #include "opentherm.h"
 
@@ -11,6 +12,22 @@
 #include "esphome/components/sensor/sensor.h"
 #endif
 
+#ifdef OPENTHERM_USE_BINARY_SENSOR
+#include "esphome/components/binary_sensor/binary_sensor.h"
+#endif
+
+#ifdef OPENTHERM_USE_SWITCH
+#include "esphome/components/opentherm/switch/switch.h"
+#endif
+
+#ifdef OPENTHERM_USE_OUTPUT
+#include "esphome/components/opentherm/output/output.h"
+#endif
+
+#ifdef OPENTHERM_USE_NUMBER
+#include "esphome/components/opentherm/number/number.h"
+#endif
+
 #include <memory>
 #include <unordered_map>
 #include <unordered_set>
@@ -31,15 +48,25 @@ class OpenthermHub : public Component {
 
   OPENTHERM_SENSOR_LIST(OPENTHERM_DECLARE_SENSOR, )
 
+  OPENTHERM_BINARY_SENSOR_LIST(OPENTHERM_DECLARE_BINARY_SENSOR, )
+
+  OPENTHERM_SWITCH_LIST(OPENTHERM_DECLARE_SWITCH, )
+
+  OPENTHERM_NUMBER_LIST(OPENTHERM_DECLARE_NUMBER, )
+
+  OPENTHERM_OUTPUT_LIST(OPENTHERM_DECLARE_OUTPUT, )
+
+  OPENTHERM_INPUT_SENSOR_LIST(OPENTHERM_DECLARE_INPUT_SENSOR, )
+
   // The set of initial messages to send on starting communication with the boiler
-  std::unordered_set<MessageId> initial_messages_;
+  std::vector<MessageId> initial_messages_;
   // and the repeating messages which are sent repeatedly to update various sensors
   // and boiler parameters (like the setpoint).
-  std::unordered_set<MessageId> repeating_messages_;
+  std::vector<MessageId> repeating_messages_;
   // Indicates if we are still working on the initial requests or not
   bool sending_initial_ = true;
   // Index for the current request in one of the _requests sets.
-  std::unordered_set<MessageId>::const_iterator current_message_iterator_;
+  std::vector<MessageId>::const_iterator current_message_iterator_;
 
   uint32_t last_conversation_start_ = 0;
   uint32_t last_conversation_end_ = 0;
@@ -51,6 +78,8 @@ class OpenthermHub : public Component {
   // Very likely to happen while using Dallas temperature sensors.
   bool sync_mode_ = false;
 
+  float opentherm_version_ = 0.0f;
+
   // Create OpenTherm messages based on the message id
   OpenthermData build_request_(MessageId request_id) const;
   void handle_protocol_write_error_();
@@ -88,13 +117,23 @@ class OpenthermHub : public Component {
 
   OPENTHERM_SENSOR_LIST(OPENTHERM_SET_SENSOR, )
 
-  // Add a request to the set of initial requests
-  void add_initial_message(MessageId message_id) { this->initial_messages_.insert(message_id); }
+  OPENTHERM_BINARY_SENSOR_LIST(OPENTHERM_SET_BINARY_SENSOR, )
+
+  OPENTHERM_SWITCH_LIST(OPENTHERM_SET_SWITCH, )
+
+  OPENTHERM_NUMBER_LIST(OPENTHERM_SET_NUMBER, )
+
+  OPENTHERM_OUTPUT_LIST(OPENTHERM_SET_OUTPUT, )
+
+  OPENTHERM_INPUT_SENSOR_LIST(OPENTHERM_SET_INPUT_SENSOR, )
+
+  // Add a request to the vector of initial requests
+  void add_initial_message(MessageId message_id) { this->initial_messages_.push_back(message_id); }
   // Add a request to the set of repeating requests. Note that a large number of repeating
   // requests will slow down communication with the boiler. Each request may take up to 1 second,
   // so with all sensors enabled, it may take about half a minute before a change in setpoint
   // will be processed.
-  void add_repeating_message(MessageId message_id) { this->repeating_messages_.insert(message_id); }
+  void add_repeating_message(MessageId message_id) { this->repeating_messages_.push_back(message_id); }
 
   // There are seven status variables, which can either be set as a simple variable,
   // or using a switch. ch_enable and dhw_enable default to true, the others to false.
@@ -110,6 +149,7 @@ class OpenthermHub : public Component {
   void set_summer_mode_active(bool value) { this->summer_mode_active = value; }
   void set_dhw_block(bool value) { this->dhw_block = value; }
   void set_sync_mode(bool sync_mode) { this->sync_mode_ = sync_mode; }
+  void set_opentherm_version(float value) { this->opentherm_version_ = value; }
 
   float get_setup_priority() const override { return setup_priority::HARDWARE; }
 
diff --git a/esphome/components/opentherm/input.h b/esphome/components/opentherm/input.h
new file mode 100644
index 0000000000..3567138792
--- /dev/null
+++ b/esphome/components/opentherm/input.h
@@ -0,0 +1,18 @@
+#pragma once
+
+namespace esphome {
+namespace opentherm {
+
+class OpenthermInput {
+ public:
+  bool auto_min_value, auto_max_value;
+
+  virtual void set_min_value(float min_value) = 0;
+  virtual void set_max_value(float max_value) = 0;
+
+  virtual void set_auto_min_value(bool auto_min_value) { this->auto_min_value = auto_min_value; }
+  virtual void set_auto_max_value(bool auto_max_value) { this->auto_max_value = auto_max_value; }
+};
+
+}  // namespace opentherm
+}  // namespace esphome
diff --git a/esphome/components/opentherm/input.py b/esphome/components/opentherm/input.py
new file mode 100644
index 0000000000..7897747be1
--- /dev/null
+++ b/esphome/components/opentherm/input.py
@@ -0,0 +1,51 @@
+from typing import Any
+
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from . import schema, generate
+
+CONF_min_value = "min_value"
+CONF_max_value = "max_value"
+CONF_auto_min_value = "auto_min_value"
+CONF_auto_max_value = "auto_max_value"
+CONF_step = "step"
+
+OpenthermInput = generate.opentherm_ns.class_("OpenthermInput")
+
+
+def validate_min_value_less_than_max_value(conf):
+    if (
+        CONF_min_value in conf
+        and CONF_max_value in conf
+        and conf[CONF_min_value] > conf[CONF_max_value]
+    ):
+        raise cv.Invalid(f"{CONF_min_value} must be less than {CONF_max_value}")
+    return conf
+
+
+def input_schema(entity: schema.InputSchema) -> cv.Schema:
+    result = cv.Schema(
+        {
+            cv.Optional(CONF_min_value, entity.range[0]): cv.float_range(
+                entity.range[0], entity.range[1]
+            ),
+            cv.Optional(CONF_max_value, entity.range[1]): cv.float_range(
+                entity.range[0], entity.range[1]
+            ),
+        }
+    )
+    result = result.add_extra(validate_min_value_less_than_max_value)
+    result = result.extend({cv.Optional(CONF_step, False): cv.float_})
+    if entity.auto_min_value is not None:
+        result = result.extend({cv.Optional(CONF_auto_min_value, False): cv.boolean})
+    if entity.auto_max_value is not None:
+        result = result.extend({cv.Optional(CONF_auto_max_value, False): cv.boolean})
+
+    return result
+
+
+def generate_setters(entity: cg.MockObj, conf: dict[str, Any]) -> None:
+    generate.add_property_set(entity, CONF_min_value, conf)
+    generate.add_property_set(entity, CONF_max_value, conf)
+    generate.add_property_set(entity, CONF_auto_min_value, conf)
+    generate.add_property_set(entity, CONF_auto_max_value, conf)
diff --git a/esphome/components/opentherm/number/__init__.py b/esphome/components/opentherm/number/__init__.py
new file mode 100644
index 0000000000..bbf3e87586
--- /dev/null
+++ b/esphome/components/opentherm/number/__init__.py
@@ -0,0 +1,74 @@
+from typing import Any
+
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import number
+from esphome.const import (
+    CONF_ID,
+    CONF_UNIT_OF_MEASUREMENT,
+    CONF_STEP,
+    CONF_INITIAL_VALUE,
+    CONF_RESTORE_VALUE,
+)
+from .. import const, schema, validate, input, generate
+
+DEPENDENCIES = [const.OPENTHERM]
+COMPONENT_TYPE = const.NUMBER
+
+OpenthermNumber = generate.opentherm_ns.class_(
+    "OpenthermNumber", number.Number, cg.Component, input.OpenthermInput
+)
+
+
+async def new_openthermnumber(config: dict[str, Any]) -> cg.Pvariable:
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+    await number.register_number(
+        var,
+        config,
+        min_value=config[input.CONF_min_value],
+        max_value=config[input.CONF_max_value],
+        step=config[input.CONF_step],
+    )
+    input.generate_setters(var, config)
+
+    if CONF_INITIAL_VALUE in config:
+        cg.add(var.set_initial_value(config[CONF_INITIAL_VALUE]))
+    if CONF_RESTORE_VALUE in config:
+        cg.add(var.set_restore_value(config[CONF_RESTORE_VALUE]))
+
+    return var
+
+
+def get_entity_validation_schema(entity: schema.InputSchema) -> cv.Schema:
+    return (
+        number.NUMBER_SCHEMA.extend(
+            {
+                cv.GenerateID(): cv.declare_id(OpenthermNumber),
+                cv.Optional(
+                    CONF_UNIT_OF_MEASUREMENT, entity.unit_of_measurement
+                ): cv.string_strict,
+                cv.Optional(CONF_STEP, entity.step): cv.float_,
+                cv.Optional(CONF_INITIAL_VALUE): cv.float_,
+                cv.Optional(CONF_RESTORE_VALUE): cv.boolean,
+            }
+        )
+        .extend(input.input_schema(entity))
+        .extend(cv.COMPONENT_SCHEMA)
+    )
+
+
+CONFIG_SCHEMA = validate.create_component_schema(
+    schema.INPUTS, get_entity_validation_schema
+)
+
+
+async def to_code(config: dict[str, Any]) -> None:
+    keys = await generate.component_to_code(
+        COMPONENT_TYPE,
+        schema.INPUTS,
+        OpenthermNumber,
+        generate.create_only_conf(new_openthermnumber),
+        config,
+    )
+    generate.define_readers(COMPONENT_TYPE, keys)
diff --git a/esphome/components/opentherm/number/number.cpp b/esphome/components/opentherm/number/number.cpp
new file mode 100644
index 0000000000..d02b99ee9c
--- /dev/null
+++ b/esphome/components/opentherm/number/number.cpp
@@ -0,0 +1,40 @@
+#include "number.h"
+
+namespace esphome {
+namespace opentherm {
+
+static const char *const TAG = "opentherm.number";
+
+void OpenthermNumber::control(float value) {
+  this->publish_state(value);
+
+  if (this->restore_value_)
+    this->pref_.save(&value);
+}
+
+void OpenthermNumber::setup() {
+  float value;
+  if (!this->restore_value_) {
+    value = this->initial_value_;
+  } else {
+    this->pref_ = global_preferences->make_preference<float>(this->get_object_id_hash());
+    if (!this->pref_.load(&value)) {
+      if (!std::isnan(this->initial_value_)) {
+        value = this->initial_value_;
+      } else {
+        value = this->traits.get_min_value();
+      }
+    }
+  }
+  this->publish_state(value);
+}
+
+void OpenthermNumber::dump_config() {
+  LOG_NUMBER("", "OpenTherm Number", this);
+  ESP_LOGCONFIG(TAG, "  Restore value: %d", this->restore_value_);
+  ESP_LOGCONFIG(TAG, "  Initial value: %.2f", this->initial_value_);
+  ESP_LOGCONFIG(TAG, "  Current value: %.2f", this->state);
+}
+
+}  // namespace opentherm
+}  // namespace esphome
diff --git a/esphome/components/opentherm/number/number.h b/esphome/components/opentherm/number/number.h
new file mode 100644
index 0000000000..6f86072754
--- /dev/null
+++ b/esphome/components/opentherm/number/number.h
@@ -0,0 +1,31 @@
+#pragma once
+
+#include "esphome/components/number/number.h"
+#include "esphome/core/preferences.h"
+#include "esphome/core/log.h"
+#include "esphome/components/opentherm/input.h"
+
+namespace esphome {
+namespace opentherm {
+
+// Just a simple number, which stores the number
+class OpenthermNumber : public number::Number, public Component, public OpenthermInput {
+ protected:
+  void control(float value) override;
+  void setup() override;
+  void dump_config() override;
+
+  float initial_value_{NAN};
+  bool restore_value_{false};
+
+  ESPPreferenceObject pref_;
+
+ public:
+  void set_min_value(float min_value) override { this->traits.set_min_value(min_value); }
+  void set_max_value(float max_value) override { this->traits.set_max_value(max_value); }
+  void set_initial_value(float initial_value) { initial_value_ = initial_value; }
+  void set_restore_value(bool restore_value) { this->restore_value_ = restore_value; }
+};
+
+}  // namespace opentherm
+}  // namespace esphome
diff --git a/esphome/components/opentherm/opentherm.cpp b/esphome/components/opentherm/opentherm.cpp
index 4a23bb94cf..26c707f9a0 100644
--- a/esphome/components/opentherm/opentherm.cpp
+++ b/esphome/components/opentherm/opentherm.cpp
@@ -483,6 +483,8 @@ const char *OpenTherm::message_id_to_str(MessageId id) {
     TO_STRING_MEMBER(EXHAUST_TEMP)
     TO_STRING_MEMBER(FAN_SPEED)
     TO_STRING_MEMBER(FLAME_CURRENT)
+    TO_STRING_MEMBER(ROOM_TEMP_CH2)
+    TO_STRING_MEMBER(REL_HUMIDITY)
     TO_STRING_MEMBER(DHW_BOUNDS)
     TO_STRING_MEMBER(CH_BOUNDS)
     TO_STRING_MEMBER(OTC_CURVE_BOUNDS)
@@ -492,14 +494,39 @@ const char *OpenTherm::message_id_to_str(MessageId id) {
     TO_STRING_MEMBER(HVAC_STATUS)
     TO_STRING_MEMBER(REL_VENT_SETPOINT)
     TO_STRING_MEMBER(DEVICE_VENT)
+    TO_STRING_MEMBER(HVAC_VER_ID)
     TO_STRING_MEMBER(REL_VENTILATION)
     TO_STRING_MEMBER(REL_HUMID_EXHAUST)
+    TO_STRING_MEMBER(EXHAUST_CO2)
     TO_STRING_MEMBER(SUPPLY_INLET_TEMP)
     TO_STRING_MEMBER(SUPPLY_OUTLET_TEMP)
     TO_STRING_MEMBER(EXHAUST_INLET_TEMP)
     TO_STRING_MEMBER(EXHAUST_OUTLET_TEMP)
+    TO_STRING_MEMBER(EXHAUST_FAN_SPEED)
+    TO_STRING_MEMBER(SUPPLY_FAN_SPEED)
+    TO_STRING_MEMBER(REMOTE_VENTILATION_PARAM)
     TO_STRING_MEMBER(NOM_REL_VENTILATION)
+    TO_STRING_MEMBER(HVAC_NUM_TSP)
+    TO_STRING_MEMBER(HVAC_IDX_TSP)
+    TO_STRING_MEMBER(HVAC_FHB_SIZE)
+    TO_STRING_MEMBER(HVAC_FHB_IDX)
+    TO_STRING_MEMBER(RF_SIGNAL)
+    TO_STRING_MEMBER(DHW_MODE)
     TO_STRING_MEMBER(OVERRIDE_FUNC)
+    TO_STRING_MEMBER(SOLAR_MODE_FLAGS)
+    TO_STRING_MEMBER(SOLAR_ASF)
+    TO_STRING_MEMBER(SOLAR_VERSION_ID)
+    TO_STRING_MEMBER(SOLAR_PRODUCT_ID)
+    TO_STRING_MEMBER(SOLAR_NUM_TSP)
+    TO_STRING_MEMBER(SOLAR_IDX_TSP)
+    TO_STRING_MEMBER(SOLAR_FHB_SIZE)
+    TO_STRING_MEMBER(SOLAR_FHB_IDX)
+    TO_STRING_MEMBER(SOLAR_STARTS)
+    TO_STRING_MEMBER(SOLAR_HOURS)
+    TO_STRING_MEMBER(SOLAR_ENERGY)
+    TO_STRING_MEMBER(SOLAR_TOTAL_ENERGY)
+    TO_STRING_MEMBER(FAILED_BURNER_STARTS)
+    TO_STRING_MEMBER(BURNER_FLAME_LOW)
     TO_STRING_MEMBER(OEM_DIAGNOSTIC)
     TO_STRING_MEMBER(BURNER_STARTS)
     TO_STRING_MEMBER(CH_PUMP_STARTS)
diff --git a/esphome/components/opentherm/opentherm.h b/esphome/components/opentherm/opentherm.h
index 23f4b39a1a..85f4611125 100644
--- a/esphome/components/opentherm/opentherm.h
+++ b/esphome/components/opentherm/opentherm.h
@@ -99,6 +99,8 @@ enum MessageId {
   EXHAUST_TEMP = 33,
   FAN_SPEED = 35,
   FLAME_CURRENT = 36,
+  ROOM_TEMP_CH2 = 37,
+  REL_HUMIDITY = 38,
   DHW_BOUNDS = 48,
   CH_BOUNDS = 49,
   OTC_CURVE_BOUNDS = 50,
@@ -110,15 +112,46 @@ enum MessageId {
   HVAC_STATUS = 70,
   REL_VENT_SETPOINT = 71,
   DEVICE_VENT = 74,
+  HVAC_VER_ID = 75,
   REL_VENTILATION = 77,
   REL_HUMID_EXHAUST = 78,
+  EXHAUST_CO2 = 79,
   SUPPLY_INLET_TEMP = 80,
   SUPPLY_OUTLET_TEMP = 81,
   EXHAUST_INLET_TEMP = 82,
   EXHAUST_OUTLET_TEMP = 83,
+  EXHAUST_FAN_SPEED = 84,
+  SUPPLY_FAN_SPEED = 85,
+  REMOTE_VENTILATION_PARAM = 86,
   NOM_REL_VENTILATION = 87,
+  HVAC_NUM_TSP = 88,
+  HVAC_IDX_TSP = 89,
+  HVAC_FHB_SIZE = 90,
+  HVAC_FHB_IDX = 91,
 
+  RF_SIGNAL = 98,
+  DHW_MODE = 99,
   OVERRIDE_FUNC = 100,
+
+  // Solar Specific Message IDs
+  SOLAR_MODE_FLAGS = 101,  // hb0-2 Controller storage mode
+                           // lb0   Device fault
+                           // lb1-3 Device mode status
+                           // lb4-5 Device status
+  SOLAR_ASF = 102,
+  SOLAR_VERSION_ID = 103,
+  SOLAR_PRODUCT_ID = 104,
+  SOLAR_NUM_TSP = 105,
+  SOLAR_IDX_TSP = 106,
+  SOLAR_FHB_SIZE = 107,
+  SOLAR_FHB_IDX = 108,
+  SOLAR_STARTS = 109,
+  SOLAR_HOURS = 110,
+  SOLAR_ENERGY = 111,
+  SOLAR_TOTAL_ENERGY = 112,
+
+  FAILED_BURNER_STARTS = 113,
+  BURNER_FLAME_LOW = 114,
   OEM_DIAGNOSTIC = 115,
   BURNER_STARTS = 116,
   CH_PUMP_STARTS = 117,
diff --git a/esphome/components/opentherm/opentherm_macros.h b/esphome/components/opentherm/opentherm_macros.h
index 0389e975ff..8aaec0b48a 100644
--- a/esphome/components/opentherm/opentherm_macros.h
+++ b/esphome/components/opentherm/opentherm_macros.h
@@ -13,14 +13,49 @@ namespace opentherm {
 #ifndef OPENTHERM_SENSOR_LIST
 #define OPENTHERM_SENSOR_LIST(F, sep)
 #endif
+#ifndef OPENTHERM_BINARY_SENSOR_LIST
+#define OPENTHERM_BINARY_SENSOR_LIST(F, sep)
+#endif
+#ifndef OPENTHERM_SWITCH_LIST
+#define OPENTHERM_SWITCH_LIST(F, sep)
+#endif
+#ifndef OPENTHERM_NUMBER_LIST
+#define OPENTHERM_NUMBER_LIST(F, sep)
+#endif
+#ifndef OPENTHERM_OUTPUT_LIST
+#define OPENTHERM_OUTPUT_LIST(F, sep)
+#endif
+#ifndef OPENTHERM_INPUT_SENSOR_LIST
+#define OPENTHERM_INPUT_SENSOR_LIST(F, sep)
+#endif
 
 // Use macros to create fields for every entity specified in the ESPHome configuration
 #define OPENTHERM_DECLARE_SENSOR(entity) sensor::Sensor *entity;
+#define OPENTHERM_DECLARE_BINARY_SENSOR(entity) binary_sensor::BinarySensor *entity;
+#define OPENTHERM_DECLARE_SWITCH(entity) OpenthermSwitch *entity;
+#define OPENTHERM_DECLARE_NUMBER(entity) OpenthermNumber *entity;
+#define OPENTHERM_DECLARE_OUTPUT(entity) OpenthermOutput *entity;
+#define OPENTHERM_DECLARE_INPUT_SENSOR(entity) sensor::Sensor *entity;
 
 // Setter macros
 #define OPENTHERM_SET_SENSOR(entity) \
   void set_##entity(sensor::Sensor *sensor) { this->entity = sensor; }
 
+#define OPENTHERM_SET_BINARY_SENSOR(entity) \
+  void set_##entity(binary_sensor::BinarySensor *binary_sensor) { this->entity = binary_sensor; }
+
+#define OPENTHERM_SET_SWITCH(entity) \
+  void set_##entity(OpenthermSwitch *sw) { this->entity = sw; }
+
+#define OPENTHERM_SET_NUMBER(entity) \
+  void set_##entity(OpenthermNumber *number) { this->entity = number; }
+
+#define OPENTHERM_SET_OUTPUT(entity) \
+  void set_##entity(OpenthermOutput *output) { this->entity = output; }
+
+#define OPENTHERM_SET_INPUT_SENSOR(entity) \
+  void set_##entity(sensor::Sensor *sensor) { this->entity = sensor; }
+
 // ===== hub.cpp macros =====
 
 // *_MESSAGE_HANDLERS are generated in defines.h and look like this:
@@ -35,6 +70,31 @@ namespace opentherm {
 #ifndef OPENTHERM_SENSOR_MESSAGE_HANDLERS
 #define OPENTHERM_SENSOR_MESSAGE_HANDLERS(MESSAGE, ENTITY, entity_sep, postscript, msg_sep)
 #endif
+#ifndef OPENTHERM_BINARY_SENSOR_MESSAGE_HANDLERS
+#define OPENTHERM_BINARY_SENSOR_MESSAGE_HANDLERS(MESSAGE, ENTITY, entity_sep, postscript, msg_sep)
+#endif
+#ifndef OPENTHERM_SWITCH_MESSAGE_HANDLERS
+#define OPENTHERM_SWITCH_MESSAGE_HANDLERS(MESSAGE, ENTITY, entity_sep, postscript, msg_sep)
+#endif
+#ifndef OPENTHERM_NUMBER_MESSAGE_HANDLERS
+#define OPENTHERM_NUMBER_MESSAGE_HANDLERS(MESSAGE, ENTITY, entity_sep, postscript, msg_sep)
+#endif
+#ifndef OPENTHERM_OUTPUT_MESSAGE_HANDLERS
+#define OPENTHERM_OUTPUT_MESSAGE_HANDLERS(MESSAGE, ENTITY, entity_sep, postscript, msg_sep)
+#endif
+#ifndef OPENTHERM_INPUT_SENSOR_MESSAGE_HANDLERS
+#define OPENTHERM_INPUT_SENSOR_MESSAGE_HANDLERS(MESSAGE, ENTITY, entity_sep, postscript, msg_sep)
+#endif
+
+// Write data request builders
+#define OPENTHERM_MESSAGE_WRITE_MESSAGE(msg) \
+  case MessageId::msg: { \
+    data.type = MessageType::WRITE_DATA; \
+    data.id = request_id;
+#define OPENTHERM_MESSAGE_WRITE_ENTITY(key, msg_data) message_data::write_##msg_data(this->key->state, data);
+#define OPENTHERM_MESSAGE_WRITE_POSTSCRIPT \
+  return data; \
+  }
 
 // Read data request builder
 #define OPENTHERM_MESSAGE_READ_MESSAGE(msg) \
diff --git a/esphome/components/opentherm/output/__init__.py b/esphome/components/opentherm/output/__init__.py
new file mode 100644
index 0000000000..3a53c9d4f4
--- /dev/null
+++ b/esphome/components/opentherm/output/__init__.py
@@ -0,0 +1,47 @@
+from typing import Any
+
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import output
+from esphome.const import CONF_ID
+from .. import const, schema, validate, input, generate
+
+DEPENDENCIES = [const.OPENTHERM]
+COMPONENT_TYPE = const.OUTPUT
+
+OpenthermOutput = generate.opentherm_ns.class_(
+    "OpenthermOutput", output.FloatOutput, cg.Component, input.OpenthermInput
+)
+
+
+async def new_openthermoutput(
+    config: dict[str, Any], key: str, _hub: cg.MockObj
+) -> cg.Pvariable:
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+    await output.register_output(var, config)
+    cg.add(getattr(var, "set_id")(cg.RawExpression(f'"{key}_{config[CONF_ID]}"')))
+    input.generate_setters(var, config)
+    return var
+
+
+def get_entity_validation_schema(entity: schema.InputSchema) -> cv.Schema:
+    return (
+        output.FLOAT_OUTPUT_SCHEMA.extend(
+            {cv.GenerateID(): cv.declare_id(OpenthermOutput)}
+        )
+        .extend(input.input_schema(entity))
+        .extend(cv.COMPONENT_SCHEMA)
+    )
+
+
+CONFIG_SCHEMA = validate.create_component_schema(
+    schema.INPUTS, get_entity_validation_schema
+)
+
+
+async def to_code(config: dict[str, Any]) -> None:
+    keys = await generate.component_to_code(
+        COMPONENT_TYPE, schema.INPUTS, OpenthermOutput, new_openthermoutput, config
+    )
+    generate.define_readers(COMPONENT_TYPE, keys)
diff --git a/esphome/components/opentherm/output/output.cpp b/esphome/components/opentherm/output/output.cpp
new file mode 100644
index 0000000000..f820dc76f1
--- /dev/null
+++ b/esphome/components/opentherm/output/output.cpp
@@ -0,0 +1,18 @@
+#include "esphome/core/helpers.h"  // for clamp() and lerp()
+#include "output.h"
+
+namespace esphome {
+namespace opentherm {
+
+static const char *const TAG = "opentherm.output";
+
+void opentherm::OpenthermOutput::write_state(float state) {
+  ESP_LOGD(TAG, "Received state: %.2f. Min value: %.2f, max value: %.2f", state, min_value_, max_value_);
+  this->state = state < 0.003 && this->zero_means_zero_
+                    ? 0.0
+                    : clamp(lerp(state, min_value_, max_value_), min_value_, max_value_);
+  this->has_state_ = true;
+  ESP_LOGD(TAG, "Output %s set to %.2f", this->id_, this->state);
+}
+}  // namespace opentherm
+}  // namespace esphome
diff --git a/esphome/components/opentherm/output/output.h b/esphome/components/opentherm/output/output.h
new file mode 100644
index 0000000000..8d6a0ee4ba
--- /dev/null
+++ b/esphome/components/opentherm/output/output.h
@@ -0,0 +1,33 @@
+#pragma once
+
+#include "esphome/components/output/float_output.h"
+#include "esphome/components/opentherm/input.h"
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace opentherm {
+
+class OpenthermOutput : public output::FloatOutput, public Component, public OpenthermInput {
+ protected:
+  bool has_state_ = false;
+  const char *id_ = nullptr;
+
+  float min_value_, max_value_;
+
+ public:
+  float state;
+
+  void set_id(const char *id) { this->id_ = id; }
+
+  void write_state(float state) override;
+
+  bool has_state() { return this->has_state_; };
+
+  void set_min_value(float min_value) override { this->min_value_ = min_value; }
+  void set_max_value(float max_value) override { this->max_value_ = max_value; }
+  float get_min_value() { return this->min_value_; }
+  float get_max_value() { return this->max_value_; }
+};
+
+}  // namespace opentherm
+}  // namespace esphome
diff --git a/esphome/components/opentherm/schema.py b/esphome/components/opentherm/schema.py
index 6ed0029437..fe0f2a77a3 100644
--- a/esphome/components/opentherm/schema.py
+++ b/esphome/components/opentherm/schema.py
@@ -11,9 +11,12 @@ from esphome.const import (
     UNIT_MICROAMP,
     UNIT_PERCENT,
     UNIT_REVOLUTIONS_PER_MINUTE,
+    DEVICE_CLASS_COLD,
     DEVICE_CLASS_CURRENT,
     DEVICE_CLASS_EMPTY,
+    DEVICE_CLASS_HEAT,
     DEVICE_CLASS_PRESSURE,
+    DEVICE_CLASS_PROBLEM,
     DEVICE_CLASS_TEMPERATURE,
     STATE_CLASS_MEASUREMENT,
     STATE_CLASS_NONE,
@@ -188,11 +191,23 @@ SENSORS: dict[str, SensorSchema] = {
         description="Boiler fan speed",
         unit_of_measurement=UNIT_REVOLUTIONS_PER_MINUTE,
         accuracy_decimals=0,
+        icon="mdi:fan",
         device_class=DEVICE_CLASS_EMPTY,
         state_class=STATE_CLASS_MEASUREMENT,
         message="FAN_SPEED",
         keep_updated=True,
-        message_data="u16",
+        message_data="u8_lb_60",
+    ),
+    "fan_speed_setpoint": SensorSchema(
+        description="Boiler fan speed setpoint",
+        unit_of_measurement=UNIT_REVOLUTIONS_PER_MINUTE,
+        accuracy_decimals=0,
+        icon="mdi:fan",
+        device_class=DEVICE_CLASS_EMPTY,
+        state_class=STATE_CLASS_MEASUREMENT,
+        message="FAN_SPEED",
+        keep_updated=True,
+        message_data="u8_hb_60",
     ),
     "flame_current": SensorSchema(
         description="Boiler flame current",
@@ -436,3 +451,364 @@ SENSORS: dict[str, SensorSchema] = {
         message_data="u8_lb",
     ),
 }
+
+
+@dataclass
+class BinarySensorSchema(EntitySchema):
+    icon: Optional[str] = None
+    device_class: Optional[str] = None
+
+
+BINARY_SENSORS: dict[str, BinarySensorSchema] = {
+    "fault_indication": BinarySensorSchema(
+        description="Status: Fault indication",
+        device_class=DEVICE_CLASS_PROBLEM,
+        message="STATUS",
+        keep_updated=True,
+        message_data="flag8_lb_0",
+    ),
+    "ch_active": BinarySensorSchema(
+        description="Status: Central Heating active",
+        device_class=DEVICE_CLASS_HEAT,
+        icon="mdi:radiator",
+        message="STATUS",
+        keep_updated=True,
+        message_data="flag8_lb_1",
+    ),
+    "dhw_active": BinarySensorSchema(
+        description="Status: Domestic Hot Water active",
+        device_class=DEVICE_CLASS_HEAT,
+        icon="mdi:faucet",
+        message="STATUS",
+        keep_updated=True,
+        message_data="flag8_lb_2",
+    ),
+    "flame_on": BinarySensorSchema(
+        description="Status: Flame on",
+        device_class=DEVICE_CLASS_HEAT,
+        icon="mdi:fire",
+        message="STATUS",
+        keep_updated=True,
+        message_data="flag8_lb_3",
+    ),
+    "cooling_active": BinarySensorSchema(
+        description="Status: Cooling active",
+        device_class=DEVICE_CLASS_COLD,
+        message="STATUS",
+        keep_updated=True,
+        message_data="flag8_lb_4",
+    ),
+    "ch2_active": BinarySensorSchema(
+        description="Status: Central Heating 2 active",
+        device_class=DEVICE_CLASS_HEAT,
+        icon="mdi:radiator",
+        message="STATUS",
+        keep_updated=True,
+        message_data="flag8_lb_5",
+    ),
+    "diagnostic_indication": BinarySensorSchema(
+        description="Status: Diagnostic event",
+        device_class=DEVICE_CLASS_PROBLEM,
+        message="STATUS",
+        keep_updated=True,
+        message_data="flag8_lb_6",
+    ),
+    "electricity_production": BinarySensorSchema(
+        description="Status: Electricity production",
+        device_class=DEVICE_CLASS_PROBLEM,
+        message="STATUS",
+        keep_updated=True,
+        message_data="flag8_lb_7",
+    ),
+    "dhw_present": BinarySensorSchema(
+        description="Configuration: DHW present",
+        message="DEVICE_CONFIG",
+        keep_updated=False,
+        message_data="flag8_hb_0",
+    ),
+    "control_type_on_off": BinarySensorSchema(
+        description="Configuration: Control type is on/off",
+        message="DEVICE_CONFIG",
+        keep_updated=False,
+        message_data="flag8_hb_1",
+    ),
+    "cooling_supported": BinarySensorSchema(
+        description="Configuration: Cooling supported",
+        message="DEVICE_CONFIG",
+        keep_updated=False,
+        message_data="flag8_hb_2",
+    ),
+    "dhw_storage_tank": BinarySensorSchema(
+        description="Configuration: DHW storage tank",
+        message="DEVICE_CONFIG",
+        keep_updated=False,
+        message_data="flag8_hb_3",
+    ),
+    "controller_pump_control_allowed": BinarySensorSchema(
+        description="Configuration: Controller pump control allowed",
+        message="DEVICE_CONFIG",
+        keep_updated=False,
+        message_data="flag8_hb_4",
+    ),
+    "ch2_present": BinarySensorSchema(
+        description="Configuration: CH2 present",
+        message="DEVICE_CONFIG",
+        keep_updated=False,
+        message_data="flag8_hb_5",
+    ),
+    "water_filling": BinarySensorSchema(
+        description="Configuration: Remote water filling",
+        message="DEVICE_CONFIG",
+        keep_updated=False,
+        message_data="flag8_hb_6",
+    ),
+    "heat_mode": BinarySensorSchema(
+        description="Configuration: Heating or cooling",
+        message="DEVICE_CONFIG",
+        keep_updated=False,
+        message_data="flag8_hb_7",
+    ),
+    "dhw_setpoint_transfer_enabled": BinarySensorSchema(
+        description="Remote boiler parameters: DHW setpoint transfer enabled",
+        message="REMOTE",
+        keep_updated=False,
+        message_data="flag8_hb_0",
+    ),
+    "max_ch_setpoint_transfer_enabled": BinarySensorSchema(
+        description="Remote boiler parameters: CH maximum setpoint transfer enabled",
+        message="REMOTE",
+        keep_updated=False,
+        message_data="flag8_hb_1",
+    ),
+    "dhw_setpoint_rw": BinarySensorSchema(
+        description="Remote boiler parameters: DHW setpoint read/write",
+        message="REMOTE",
+        keep_updated=False,
+        message_data="flag8_lb_0",
+    ),
+    "max_ch_setpoint_rw": BinarySensorSchema(
+        description="Remote boiler parameters: CH maximum setpoint read/write",
+        message="REMOTE",
+        keep_updated=False,
+        message_data="flag8_lb_1",
+    ),
+    "service_request": BinarySensorSchema(
+        description="Service required",
+        device_class=DEVICE_CLASS_PROBLEM,
+        message="FAULT_FLAGS",
+        keep_updated=True,
+        message_data="flag8_hb_0",
+    ),
+    "lockout_reset": BinarySensorSchema(
+        description="Lockout Reset",
+        device_class=DEVICE_CLASS_PROBLEM,
+        message="FAULT_FLAGS",
+        keep_updated=True,
+        message_data="flag8_hb_1",
+    ),
+    "low_water_pressure": BinarySensorSchema(
+        description="Low water pressure fault",
+        device_class=DEVICE_CLASS_PROBLEM,
+        message="FAULT_FLAGS",
+        keep_updated=True,
+        message_data="flag8_hb_2",
+    ),
+    "flame_fault": BinarySensorSchema(
+        description="Flame fault",
+        device_class=DEVICE_CLASS_PROBLEM,
+        message="FAULT_FLAGS",
+        keep_updated=True,
+        message_data="flag8_hb_3",
+    ),
+    "air_pressure_fault": BinarySensorSchema(
+        description="Air pressure fault",
+        device_class=DEVICE_CLASS_PROBLEM,
+        message="FAULT_FLAGS",
+        keep_updated=True,
+        message_data="flag8_hb_4",
+    ),
+    "water_over_temp": BinarySensorSchema(
+        description="Water overtemperature",
+        device_class=DEVICE_CLASS_PROBLEM,
+        message="FAULT_FLAGS",
+        keep_updated=True,
+        message_data="flag8_hb_5",
+    ),
+}
+
+
+@dataclass
+class SwitchSchema(EntitySchema):
+    default_mode: Optional[str] = None
+
+
+SWITCHES: dict[str, SwitchSchema] = {
+    "ch_enable": SwitchSchema(
+        description="Central Heating enabled",
+        message="STATUS",
+        keep_updated=True,
+        message_data="flag8_hb_0",
+        default_mode="restore_default_off",
+    ),
+    "dhw_enable": SwitchSchema(
+        description="Domestic Hot Water enabled",
+        message="STATUS",
+        keep_updated=True,
+        message_data="flag8_hb_1",
+        default_mode="restore_default_off",
+    ),
+    "cooling_enable": SwitchSchema(
+        description="Cooling enabled",
+        message="STATUS",
+        keep_updated=True,
+        message_data="flag8_hb_2",
+        default_mode="restore_default_off",
+    ),
+    "otc_active": SwitchSchema(
+        description="Outside temperature compensation active",
+        message="STATUS",
+        keep_updated=True,
+        message_data="flag8_hb_3",
+        default_mode="restore_default_off",
+    ),
+    "ch2_active": SwitchSchema(
+        description="Central Heating 2 active",
+        message="STATUS",
+        keep_updated=True,
+        message_data="flag8_hb_4",
+        default_mode="restore_default_off",
+    ),
+    "summer_mode_active": SwitchSchema(
+        description="Summer mode active",
+        message="STATUS",
+        keep_updated=True,
+        message_data="flag8_hb_5",
+        default_mode="restore_default_off",
+    ),
+    "dhw_block": SwitchSchema(
+        description="DHW blocked",
+        message="STATUS",
+        keep_updated=True,
+        message_data="flag8_hb_6",
+        default_mode="restore_default_off",
+    ),
+}
+
+
+@dataclass
+class AutoConfigure:
+    message: str
+    message_data: str
+
+
+@dataclass
+class InputSchema(EntitySchema):
+    unit_of_measurement: str
+    step: float
+    range: tuple[int, int]
+    icon: Optional[str] = None
+    auto_max_value: Optional[AutoConfigure] = None
+    auto_min_value: Optional[AutoConfigure] = None
+
+
+INPUTS: dict[str, InputSchema] = {
+    "t_set": InputSchema(
+        description="Control setpoint: temperature setpoint for the boiler's supply water",
+        unit_of_measurement=UNIT_CELSIUS,
+        step=0.1,
+        message="CH_SETPOINT",
+        keep_updated=True,
+        message_data="f88",
+        range=(0, 100),
+        auto_max_value=AutoConfigure(message="MAX_CH_SETPOINT", message_data="f88"),
+    ),
+    "t_set_ch2": InputSchema(
+        description="Control setpoint 2: temperature setpoint for the boiler's supply water on the second heating circuit",
+        unit_of_measurement=UNIT_CELSIUS,
+        step=0.1,
+        message="CH2_SETPOINT",
+        keep_updated=True,
+        message_data="f88",
+        range=(0, 100),
+        auto_max_value=AutoConfigure(message="MAX_CH_SETPOINT", message_data="f88"),
+    ),
+    "cooling_control": InputSchema(
+        description="Cooling control signal",
+        unit_of_measurement=UNIT_PERCENT,
+        step=1.0,
+        message="COOLING_CONTROL",
+        keep_updated=True,
+        message_data="f88",
+        range=(0, 100),
+    ),
+    "t_dhw_set": InputSchema(
+        description="Domestic hot water temperature setpoint",
+        unit_of_measurement=UNIT_CELSIUS,
+        step=0.1,
+        message="DHW_SETPOINT",
+        keep_updated=True,
+        message_data="f88",
+        range=(0, 127),
+        auto_min_value=AutoConfigure(message="DHW_BOUNDS", message_data="s8_lb"),
+        auto_max_value=AutoConfigure(message="DHW_BOUNDS", message_data="s8_hb"),
+    ),
+    "max_t_set": InputSchema(
+        description="Maximum allowable CH water setpoint",
+        unit_of_measurement=UNIT_CELSIUS,
+        step=0.1,
+        message="MAX_CH_SETPOINT",
+        keep_updated=True,
+        message_data="f88",
+        range=(0, 127),
+        auto_min_value=AutoConfigure(message="CH_BOUNDS", message_data="s8_lb"),
+        auto_max_value=AutoConfigure(message="CH_BOUNDS", message_data="s8_hb"),
+    ),
+    "t_room_set": InputSchema(
+        description="Current room temperature setpoint (informational)",
+        unit_of_measurement=UNIT_CELSIUS,
+        step=0.1,
+        message="ROOM_SETPOINT",
+        keep_updated=True,
+        message_data="f88",
+        range=(-40, 127),
+    ),
+    "t_room_set_ch2": InputSchema(
+        description="Current room temperature setpoint on CH2 (informational)",
+        unit_of_measurement=UNIT_CELSIUS,
+        step=0.1,
+        message="ROOM_SETPOINT_CH2",
+        keep_updated=True,
+        message_data="f88",
+        range=(-40, 127),
+    ),
+    "t_room": InputSchema(
+        description="Current sensed room temperature (informational)",
+        unit_of_measurement=UNIT_CELSIUS,
+        step=0.1,
+        message="ROOM_TEMP",
+        keep_updated=True,
+        message_data="f88",
+        range=(-40, 127),
+    ),
+    "max_rel_mod_level": InputSchema(
+        description="Maximum relative modulation level",
+        unit_of_measurement=UNIT_PERCENT,
+        step=1,
+        icon="mdi:percent",
+        message="MAX_MODULATION_LEVEL",
+        keep_updated=True,
+        message_data="f88",
+        range=(0, 100),
+    ),
+    "otc_hc_ratio": InputSchema(
+        description="OTC heat curve ratio",
+        unit_of_measurement=UNIT_CELSIUS,
+        step=0.1,
+        message="OTC_CURVE_RATIO",
+        keep_updated=True,
+        message_data="f88",
+        range=(0, 127),
+        auto_min_value=AutoConfigure(message="OTC_CURVE_BOUNDS", message_data="u8_lb"),
+        auto_max_value=AutoConfigure(message="OTC_CURVE_BOUNDS", message_data="u8_hb"),
+    ),
+}
diff --git a/esphome/components/opentherm/sensor/__init__.py b/esphome/components/opentherm/sensor/__init__.py
index 20224e0eda..546a79054b 100644
--- a/esphome/components/opentherm/sensor/__init__.py
+++ b/esphome/components/opentherm/sensor/__init__.py
@@ -7,6 +7,18 @@ from .. import const, schema, validate, generate
 DEPENDENCIES = [const.OPENTHERM]
 COMPONENT_TYPE = const.SENSOR
 
+MSG_DATA_TYPES = {
+    "u8_lb",
+    "u8_hb",
+    "s8_lb",
+    "s8_hb",
+    "u8_lb_60",
+    "u8_hb_60",
+    "u16",
+    "s16",
+    "f88",
+}
+
 
 def get_entity_validation_schema(entity: schema.SensorSchema) -> cv.Schema:
     return sensor.sensor_schema(
@@ -17,6 +29,10 @@ def get_entity_validation_schema(entity: schema.SensorSchema) -> cv.Schema:
         or sensor._UNDEF,  # pylint: disable=protected-access
         icon=entity.icon or sensor._UNDEF,  # pylint: disable=protected-access
         state_class=entity.state_class,
+    ).extend(
+        {
+            cv.Optional(const.CONF_DATA_TYPE): cv.one_of(*MSG_DATA_TYPES),
+        }
     )
 
 
diff --git a/esphome/components/opentherm/switch/__init__.py b/esphome/components/opentherm/switch/__init__.py
new file mode 100644
index 0000000000..94ec25e36c
--- /dev/null
+++ b/esphome/components/opentherm/switch/__init__.py
@@ -0,0 +1,43 @@
+from typing import Any
+
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import switch
+from esphome.const import CONF_ID
+from .. import const, schema, validate, generate
+
+DEPENDENCIES = [const.OPENTHERM]
+COMPONENT_TYPE = const.SWITCH
+
+OpenthermSwitch = generate.opentherm_ns.class_(
+    "OpenthermSwitch", switch.Switch, cg.Component
+)
+
+
+async def new_openthermswitch(config: dict[str, Any]) -> cg.Pvariable:
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+    await switch.register_switch(var, config)
+    return var
+
+
+def get_entity_validation_schema(entity: schema.SwitchSchema) -> cv.Schema:
+    return switch.SWITCH_SCHEMA.extend(
+        {cv.GenerateID(): cv.declare_id(OpenthermSwitch)}
+    ).extend(cv.COMPONENT_SCHEMA)
+
+
+CONFIG_SCHEMA = validate.create_component_schema(
+    schema.SWITCHES, get_entity_validation_schema
+)
+
+
+async def to_code(config: dict[str, Any]) -> None:
+    keys = await generate.component_to_code(
+        COMPONENT_TYPE,
+        schema.SWITCHES,
+        OpenthermSwitch,
+        generate.create_only_conf(new_openthermswitch),
+        config,
+    )
+    generate.define_readers(COMPONENT_TYPE, keys)
diff --git a/esphome/components/opentherm/switch/switch.cpp b/esphome/components/opentherm/switch/switch.cpp
new file mode 100644
index 0000000000..228d9ac8f3
--- /dev/null
+++ b/esphome/components/opentherm/switch/switch.cpp
@@ -0,0 +1,28 @@
+#include "switch.h"
+
+namespace esphome {
+namespace opentherm {
+
+static const char *const TAG = "opentherm.switch";
+
+void OpenthermSwitch::write_state(bool state) { this->publish_state(state); }
+
+void OpenthermSwitch::setup() {
+  auto restored = this->get_initial_state_with_restore_mode();
+  bool state = false;
+  if (!restored.has_value()) {
+    ESP_LOGD(TAG, "Couldn't restore state for OpenTherm switch '%s'", this->get_name().c_str());
+  } else {
+    ESP_LOGD(TAG, "Restored state for OpenTherm switch '%s': %d", this->get_name().c_str(), restored.value());
+    state = restored.value();
+  }
+  this->write_state(state);
+}
+
+void OpenthermSwitch::dump_config() {
+  LOG_SWITCH("", "OpenTherm Switch", this);
+  ESP_LOGCONFIG(TAG, "  Current state: %d", this->state);
+}
+
+}  // namespace opentherm
+}  // namespace esphome
diff --git a/esphome/components/opentherm/switch/switch.h b/esphome/components/opentherm/switch/switch.h
new file mode 100644
index 0000000000..0c20a0d9ed
--- /dev/null
+++ b/esphome/components/opentherm/switch/switch.h
@@ -0,0 +1,20 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/components/switch/switch.h"
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace opentherm {
+
+class OpenthermSwitch : public switch_::Switch, public Component {
+ protected:
+  void write_state(bool state) override;
+
+ public:
+  void setup() override;
+  void dump_config() override;
+};
+
+}  // namespace opentherm
+}  // namespace esphome
diff --git a/esphome/components/sun/sun.h b/esphome/components/sun/sun.h
index de4801a655..77d62d34c3 100644
--- a/esphome/components/sun/sun.h
+++ b/esphome/components/sun/sun.h
@@ -59,6 +59,9 @@ class Sun {
   void set_latitude(double latitude) { location_.latitude = latitude; }
   void set_longitude(double longitude) { location_.longitude = longitude; }
 
+  // Check if the sun is above the horizon, with a default elevation angle of -0.83333 (standard for sunrise/set).
+  bool is_above_horizon(double elevation = -0.83333) { return this->elevation() > elevation; }
+
   optional<ESPTime> sunrise(double elevation);
   optional<ESPTime> sunset(double elevation);
   optional<ESPTime> sunrise(ESPTime date, double elevation);
diff --git a/esphome/core/ring_buffer.cpp b/esphome/core/ring_buffer.cpp
index f97c686684..6152ada314 100644
--- a/esphome/core/ring_buffer.cpp
+++ b/esphome/core/ring_buffer.cpp
@@ -46,7 +46,7 @@ size_t RingBuffer::read(void *data, size_t len, TickType_t ticks_to_wait) {
   return bytes_read;
 }
 
-size_t RingBuffer::write(void *data, size_t len) {
+size_t RingBuffer::write(const void *data, size_t len) {
   size_t free = this->free();
   if (free < len) {
     size_t needed = len - free;
@@ -56,7 +56,7 @@ size_t RingBuffer::write(void *data, size_t len) {
   return xStreamBufferSend(this->handle_, data, len, 0);
 }
 
-size_t RingBuffer::write_without_replacement(void *data, size_t len, TickType_t ticks_to_wait) {
+size_t RingBuffer::write_without_replacement(const void *data, size_t len, TickType_t ticks_to_wait) {
   return xStreamBufferSend(this->handle_, data, len, ticks_to_wait);
 }
 
diff --git a/esphome/core/ring_buffer.h b/esphome/core/ring_buffer.h
index c0511fb52e..aade1b5f49 100644
--- a/esphome/core/ring_buffer.h
+++ b/esphome/core/ring_buffer.h
@@ -37,7 +37,7 @@ class RingBuffer {
    * @param len Number of bytes to write
    * @return Number of bytes written
    */
-  size_t write(void *data, size_t len);
+  size_t write(const void *data, size_t len);
 
   /**
    * @brief Writes to the ring buffer without overwriting oldest data.
@@ -50,7 +50,7 @@ class RingBuffer {
    * @param ticks_to_wait Maximum number of FreeRTOS ticks to wait (default: 0)
    * @return Number of bytes written
    */
-  size_t write_without_replacement(void *data, size_t len, TickType_t ticks_to_wait = 0);
+  size_t write_without_replacement(const void *data, size_t len, TickType_t ticks_to_wait = 0);
 
   /**
    * @brief Returns the number of available bytes in the ring buffer.
diff --git a/tests/components/modbus_controller/test.esp32-ard.yaml b/tests/components/modbus_controller/test.esp32-ard.yaml
index cd95d149cb..f5c5c10125 100644
--- a/tests/components/modbus_controller/test.esp32-ard.yaml
+++ b/tests/components/modbus_controller/test.esp32-ard.yaml
@@ -21,6 +21,9 @@ modbus_controller:
     address: 0x2
     modbus_id: mod_bus1
     allow_duplicate_commands: false
+    on_online:
+      then:
+        logger.log: "Module Online"
   - id: modbus_controller2
     address: 0x2
     modbus_id: mod_bus2
diff --git a/tests/components/modbus_controller/test.esp32-idf.yaml b/tests/components/modbus_controller/test.esp32-idf.yaml
index ba28e94d73..0e1849dd88 100644
--- a/tests/components/modbus_controller/test.esp32-idf.yaml
+++ b/tests/components/modbus_controller/test.esp32-idf.yaml
@@ -13,4 +13,7 @@ modbus_controller:
     address: 0x2
     modbus_id: mod_bus1
     allow_duplicate_commands: true
+    on_offline:
+      then:
+        logger.log: "Module Offline"
     max_cmd_retries: 10
diff --git a/tests/components/opentherm/common.yaml b/tests/components/opentherm/common.yaml
index 27cbae280a..744580f18b 100644
--- a/tests/components/opentherm/common.yaml
+++ b/tests/components/opentherm/common.yaml
@@ -12,10 +12,41 @@ opentherm:
   cooling_enable: false
   otc_active: false
   ch2_active: true
+  t_room: boiler_sensor
   summer_mode_active: true
   dhw_block: true
   sync_mode: true
 
+output:
+  - platform: opentherm
+    t_set:
+      id: t_set
+      min_value: 20
+      auto_max_value: true
+      zero_means_zero: true
+    t_set_ch2:
+      id: t_set_ch2
+      min_value: 20
+      max_value: 40
+      zero_means_zero: true
+
+number:
+  - platform: opentherm
+    cooling_control:
+      name: "Boiler Cooling control signal"
+    t_dhw_set:
+      name: "Boiler DHW Setpoint"
+    max_t_set:
+      name: "Boiler Max Setpoint"
+    t_room_set:
+      name: "Boiler Room Setpoint"
+    t_room_set_ch2:
+      name: "Boiler Room Setpoint CH2"
+    max_rel_mod_level:
+      name: "Maximum relative modulation level"
+    otc_hc_ratio:
+      name: "OTC heat curve ratio"
+
 sensor:
   - platform: opentherm
     rel_mod_level:
@@ -25,6 +56,7 @@ sensor:
     dhw_flow_rate:
       name: "Boiler Water flow rate in DHW circuit"
     t_boiler:
+      id: "boiler_sensor"
       name: "Boiler water temperature"
     t_dhw:
       name: "Boiler DHW temperature"
@@ -74,3 +106,55 @@ sensor:
       name: "OTC heat curve ratio upper bound"
     otc_hc_ratio_lb:
       name: "OTC heat curve ratio lower bound"
+
+binary_sensor:
+  - platform: opentherm
+    fault_indication:
+      name: "Boiler Fault indication"
+    ch_active:
+      name: "Boiler Central Heating active"
+    dhw_active:
+      name: "Boiler Domestic Hot Water active"
+    flame_on:
+      name: "Boiler Flame on"
+    cooling_active:
+      name: "Boiler Cooling active"
+    ch2_active:
+      name: "Boiler Central Heating 2 active"
+    diagnostic_indication:
+      name: "Boiler Diagnostic event"
+    dhw_present:
+      name: "Boiler DHW present"
+    control_type_on_off:
+      name: "Boiler Control type is on/off"
+    cooling_supported:
+      name: "Boiler Cooling supported"
+    dhw_storage_tank:
+      name: "Boiler DHW storage tank"
+    controller_pump_control_allowed:
+      name: "Boiler Controller pump control allowed"
+    ch2_present:
+      name: "Boiler CH2 present"
+    dhw_setpoint_transfer_enabled:
+      name: "Boiler DHW setpoint transfer enabled"
+    max_ch_setpoint_transfer_enabled:
+      name: "Boiler CH maximum setpoint transfer enabled"
+    dhw_setpoint_rw:
+      name: "Boiler DHW setpoint read/write"
+    max_ch_setpoint_rw:
+      name: "Boiler CH maximum setpoint read/write"
+
+switch:
+  - platform: opentherm
+    ch_enable:
+      name: "Boiler Central Heating enabled"
+      restore_mode: RESTORE_DEFAULT_ON
+    dhw_enable:
+      name: "Boiler Domestic Hot Water enabled"
+    cooling_enable:
+      name: "Boiler Cooling enabled"
+      restore_mode: ALWAYS_OFF
+    otc_active:
+      name: "Boiler Outside temperature compensation active"
+    ch2_active:
+      name: "Boiler Central Heating 2 active"