esphome 2025.4.1__py3-none-any.whl → 2025.5.0b2__py3-none-any.whl

esphome/components/mlx90393/sensor_mlx90393.cpp

@@ -6,13 +6,41 @@ namespace mlx90393 {
 
 static const char *const TAG = "mlx90393";
 
+const LogString *settings_to_string(MLX90393Setting setting) {
+  switch (setting) {
+    case MLX90393_GAIN_SEL:
+      return LOG_STR("gain");
+    case MLX90393_RESOLUTION:
+      return LOG_STR("resolution");
+    case MLX90393_OVER_SAMPLING:
+      return LOG_STR("oversampling");
+    case MLX90393_DIGITAL_FILTERING:
+      return LOG_STR("digital filtering");
+    case MLX90393_TEMPERATURE_OVER_SAMPLING:
+      return LOG_STR("temperature oversampling");
+    case MLX90393_TEMPERATURE_COMPENSATION:
+      return LOG_STR("temperature compensation");
+    case MLX90393_HALLCONF:
+      return LOG_STR("hallconf");
+    case MLX90393_LAST:
+      return LOG_STR("error");
+    default:
+      return LOG_STR("unknown");
+  }
+};
+
 bool MLX90393Cls::transceive(const uint8_t *request, size_t request_size, uint8_t *response, size_t response_size) {
   i2c::ErrorCode e = this->write(request, request_size);
   if (e != i2c::ErrorCode::ERROR_OK) {
+    ESP_LOGV(TAG, "i2c failed to write %u", e);
     return false;
   }
   e = this->read(response, response_size);
-  return e == i2c::ErrorCode::ERROR_OK;
+  if (e != i2c::ErrorCode::ERROR_OK) {
+    ESP_LOGV(TAG, "i2c failed to read %u", e);
+    return false;
+  }
+  return true;
 }
 
 bool MLX90393Cls::has_drdy_pin() { return this->drdy_pin_ != nullptr; }
@@ -27,6 +55,53 @@ bool MLX90393Cls::read_drdy_pin() {
 void MLX90393Cls::sleep_millis(uint32_t millis) { delay(millis); }
 void MLX90393Cls::sleep_micros(uint32_t micros) { delayMicroseconds(micros); }
 
+uint8_t MLX90393Cls::apply_setting_(MLX90393Setting which) {
+  uint8_t ret = -1;
+  switch (which) {
+    case MLX90393_GAIN_SEL:
+      ret = this->mlx_.setGainSel(this->gain_);
+      break;
+    case MLX90393_RESOLUTION:
+      ret = this->mlx_.setResolution(this->resolutions_[0], this->resolutions_[1], this->resolutions_[2]);
+      break;
+    case MLX90393_OVER_SAMPLING:
+      ret = this->mlx_.setOverSampling(this->oversampling_);
+      break;
+    case MLX90393_DIGITAL_FILTERING:
+      ret = this->mlx_.setDigitalFiltering(this->filter_);
+      break;
+    case MLX90393_TEMPERATURE_OVER_SAMPLING:
+      ret = this->mlx_.setTemperatureOverSampling(this->temperature_oversampling_);
+      break;
+    case MLX90393_TEMPERATURE_COMPENSATION:
+      ret = this->mlx_.setTemperatureCompensation(this->temperature_compensation_);
+      break;
+    case MLX90393_HALLCONF:
+      ret = this->mlx_.setHallConf(this->hallconf_);
+      break;
+    default:
+      break;
+  }
+  if (ret != MLX90393::STATUS_OK) {
+    ESP_LOGE(TAG, "failed to apply %s", LOG_STR_ARG(settings_to_string(which)));
+  }
+  return ret;
+}
+
+bool MLX90393Cls::apply_all_settings_() {
+  // perform dummy read after reset
+  // first one always gets NAK even tough everything is fine
+  uint8_t ignore = 0;
+  this->mlx_.getGainSel(ignore);
+
+  uint8_t result = MLX90393::STATUS_OK;
+  for (int i = MLX90393_GAIN_SEL; i != MLX90393_LAST; i++) {
+    MLX90393Setting stage = static_cast<MLX90393Setting>(i);
+    result |= this->apply_setting_(stage);
+  }
+  return result == MLX90393::STATUS_OK;
+}
+
 void MLX90393Cls::setup() {
   ESP_LOGCONFIG(TAG, "Setting up MLX90393...");
   // note the two arguments A0 and A1 which are used to construct an i2c address
@@ -34,19 +109,12 @@ void MLX90393Cls::setup() {
   // see the transceive function above, which uses the address from I2CComponent
   this->mlx_.begin_with_hal(this, 0, 0);
 
-  this->mlx_.setGainSel(this->gain_);
-
-  this->mlx_.setResolution(this->resolutions_[0], this->resolutions_[1], this->resolutions_[2]);
-
-  this->mlx_.setOverSampling(this->oversampling_);
-
-  this->mlx_.setDigitalFiltering(this->filter_);
-
-  this->mlx_.setTemperatureOverSampling(this->temperature_oversampling_);
-
-  this->mlx_.setTemperatureCompensation(this->temperature_compensation_);
+  if (!this->apply_all_settings_()) {
+    this->mark_failed();
+  }
 
-  this->mlx_.setHallConf(this->hallconf_);
+  // start verify settings process
+  this->set_timeout("verify settings", 3000, [this]() { this->verify_settings_timeout_(MLX90393_GAIN_SEL); });
 }
 
 void MLX90393Cls::dump_config() {
@@ -91,5 +159,119 @@ void MLX90393Cls::update() {
   }
 }
 
+bool MLX90393Cls::verify_setting_(MLX90393Setting which) {
+  uint8_t read_value = 0xFF;
+  uint8_t expected_value = 0xFF;
+  uint8_t read_status = -1;
+  char read_back_str[25] = {0};
+
+  switch (which) {
+    case MLX90393_GAIN_SEL: {
+      read_status = this->mlx_.getGainSel(read_value);
+      expected_value = this->gain_;
+      break;
+    }
+
+    case MLX90393_RESOLUTION: {
+      uint8_t read_resolutions[3] = {0xFF};
+      read_status = this->mlx_.getResolution(read_resolutions[0], read_resolutions[1], read_resolutions[2]);
+      snprintf(read_back_str, sizeof(read_back_str), "%u %u %u expected %u %u %u", read_resolutions[0],
+               read_resolutions[1], read_resolutions[2], this->resolutions_[0], this->resolutions_[1],
+               this->resolutions_[2]);
+      bool is_correct = true;
+      for (int i = 0; i < 3; i++) {
+        is_correct &= read_resolutions[i] == this->resolutions_[i];
+      }
+      if (is_correct) {
+        // set read_value and expected_value to same number, so the code blow recognizes it is correct
+        read_value = 0;
+        expected_value = 0;
+      } else {
+        // set to different numbers, to show incorrect
+        read_value = 1;
+        expected_value = 0;
+      }
+      break;
+    }
+    case MLX90393_OVER_SAMPLING: {
+      read_status = this->mlx_.getOverSampling(read_value);
+      expected_value = this->oversampling_;
+      break;
+    }
+    case MLX90393_DIGITAL_FILTERING: {
+      read_status = this->mlx_.getDigitalFiltering(read_value);
+      expected_value = this->filter_;
+      break;
+    }
+    case MLX90393_TEMPERATURE_OVER_SAMPLING: {
+      read_status = this->mlx_.getTemperatureOverSampling(read_value);
+      expected_value = this->temperature_oversampling_;
+      break;
+    }
+    case MLX90393_TEMPERATURE_COMPENSATION: {
+      read_status = this->mlx_.getTemperatureCompensation(read_value);
+      expected_value = (bool) this->temperature_compensation_;
+      break;
+    }
+    case MLX90393_HALLCONF: {
+      read_status = this->mlx_.getHallConf(read_value);
+      expected_value = this->hallconf_;
+      break;
+    }
+    default: {
+      return false;
+    }
+  }
+  if (read_status != MLX90393::STATUS_OK) {
+    ESP_LOGE(TAG, "verify error: failed to read %s", LOG_STR_ARG(settings_to_string(which)));
+    return false;
+  }
+  if (read_back_str[0] == 0x0) {
+    snprintf(read_back_str, sizeof(read_back_str), "%u expected %u", read_value, expected_value);
+  }
+  bool is_correct = read_value == expected_value;
+  if (!is_correct) {
+    ESP_LOGW(TAG, "verify failed: read back wrong %s: got %s", LOG_STR_ARG(settings_to_string(which)), read_back_str);
+    return false;
+  }
+  ESP_LOGD(TAG, "verify succeeded for %s. got %s", LOG_STR_ARG(settings_to_string(which)), read_back_str);
+  return true;
+}
+
+/**
+ * Regularly checks that our settings are still applied.
+ * Used to catch spurious chip resets.
+ *
+ * returns true if everything is fine.
+ * false if not
+ */
+void MLX90393Cls::verify_settings_timeout_(MLX90393Setting stage) {
+  bool is_setting_ok = this->verify_setting_(stage);
+
+  if (!is_setting_ok) {
+    if (this->mlx_.checkStatus(this->mlx_.reset()) != MLX90393::STATUS_OK) {
+      ESP_LOGE(TAG, "failed to reset device");
+      this->status_set_error();
+      this->mark_failed();
+      return;
+    }
+
+    if (!this->apply_all_settings_()) {
+      ESP_LOGE(TAG, "failed to re-apply settings");
+      this->status_set_error();
+      this->mark_failed();
+    } else {
+      ESP_LOGI(TAG, "reset and re-apply settings completed");
+    }
+  }
+
+  MLX90393Setting next_stage = static_cast<MLX90393Setting>(static_cast<int>(stage) + 1);
+  if (next_stage == MLX90393_LAST) {
+    next_stage = static_cast<MLX90393Setting>(0);
+  }
+
+  this->set_timeout("verify settings", 3000, [this, next_stage]() { this->verify_settings_timeout_(next_stage); });
+}
+
 }  // namespace mlx90393
 }  // namespace esphome

esphome/components/mlx90393/sensor_mlx90393.h

@@ -1,15 +1,26 @@
 #pragma once
 
-#include "esphome/core/component.h"
-#include "esphome/components/sensor/sensor.h"
-#include "esphome/components/i2c/i2c.h"
-#include "esphome/core/hal.h"
 #include <MLX90393.h>
 #include <MLX90393Hal.h>
+#include "esphome/components/i2c/i2c.h"
+#include "esphome/components/sensor/sensor.h"
+#include "esphome/core/component.h"
+#include "esphome/core/hal.h"
 
 namespace esphome {
 namespace mlx90393 {
 
+enum MLX90393Setting {
+  MLX90393_GAIN_SEL = 0,
+  MLX90393_RESOLUTION,
+  MLX90393_OVER_SAMPLING,
+  MLX90393_DIGITAL_FILTERING,
+  MLX90393_TEMPERATURE_OVER_SAMPLING,
+  MLX90393_TEMPERATURE_COMPENSATION,
+  MLX90393_HALLCONF,
+  MLX90393_LAST,
+};
+
 class MLX90393Cls : public PollingComponent, public i2c::I2CDevice, public MLX90393Hal {
  public:
   void setup() override;
@@ -58,6 +69,12 @@ class MLX90393Cls : public PollingComponent, public i2c::I2CDevice, public MLX90
   bool temperature_compensation_{false};
   uint8_t hallconf_{0xC};
   GPIOPin *drdy_pin_{nullptr};
+
+  bool apply_all_settings_();
+  uint8_t apply_setting_(MLX90393Setting which);
+
+  bool verify_setting_(MLX90393Setting which);
+  void verify_settings_timeout_(MLX90393Setting stage);
 };
 
 }  // namespace mlx90393

esphome/components/mqtt/__init__.py

@@ -41,6 +41,7 @@ from esphome.const import (
     CONF_REBOOT_TIMEOUT,
     CONF_RETAIN,
     CONF_SHUTDOWN_MESSAGE,
+    CONF_SKIP_CERT_CN_CHECK,
     CONF_SSL_FINGERPRINTS,
     CONF_STATE_TOPIC,
     CONF_SUBSCRIBE_QOS,
@@ -67,7 +68,6 @@ def AUTO_LOAD():
 
 CONF_DISCOVER_IP = "discover_ip"
 CONF_IDF_SEND_ASYNC = "idf_send_async"
-CONF_SKIP_CERT_CN_CHECK = "skip_cert_cn_check"
 
 
 def validate_message_just_topic(value):

esphome/components/mqtt/mqtt_client.cpp

@@ -138,7 +138,11 @@ void MQTTClientComponent::send_device_info_() {
 #endif
 
 #ifdef USE_API_NOISE
-        root["api_encryption"] = "Noise_NNpsk0_25519_ChaChaPoly_SHA256";
+        if (api::global_api_server->get_noise_ctx()->has_psk()) {
+          root["api_encryption"] = "Noise_NNpsk0_25519_ChaChaPoly_SHA256";
+        } else {
+          root["api_encryption_supported"] = "Noise_NNpsk0_25519_ChaChaPoly_SHA256";
+        }
 #endif
       },
       2, this->discovery_info_.retain);

esphome/components/mqtt/mqtt_const.h

@@ -64,6 +64,8 @@ constexpr const char *const MQTT_DEVICE_NAME = "name";
 constexpr const char *const MQTT_DEVICE_SUGGESTED_AREA = "sa";
 constexpr const char *const MQTT_DEVICE_SW_VERSION = "sw";
 constexpr const char *const MQTT_DEVICE_HW_VERSION = "hw";
+constexpr const char *const MQTT_DIRECTION_COMMAND_TOPIC = "dir_cmd_t";
+constexpr const char *const MQTT_DIRECTION_STATE_TOPIC = "dir_stat_t";
 constexpr const char *const MQTT_DOCKED_TEMPLATE = "dock_tpl";
 constexpr const char *const MQTT_DOCKED_TOPIC = "dock_t";
 constexpr const char *const MQTT_EFFECT_COMMAND_TOPIC = "fx_cmd_t";
@@ -328,6 +330,8 @@ constexpr const char *const MQTT_DEVICE_NAME = "name";
 constexpr const char *const MQTT_DEVICE_SUGGESTED_AREA = "suggested_area";
 constexpr const char *const MQTT_DEVICE_SW_VERSION = "sw_version";
 constexpr const char *const MQTT_DEVICE_HW_VERSION = "hw_version";
+constexpr const char *const MQTT_DIRECTION_COMMAND_TOPIC = "direction_command_topic";
+constexpr const char *const MQTT_DIRECTION_STATE_TOPIC = "direction_state_topic";
 constexpr const char *const MQTT_DOCKED_TEMPLATE = "docked_template";
 constexpr const char *const MQTT_DOCKED_TOPIC = "docked_topic";
 constexpr const char *const MQTT_EFFECT_COMMAND_TOPIC = "effect_command_topic";

esphome/components/mqtt/mqtt_fan.cpp

@@ -43,6 +43,32 @@ void MQTTFanComponent::setup() {
     }
   });
 
+  if (this->state_->get_traits().supports_direction()) {
+    this->subscribe(this->get_direction_command_topic(), [this](const std::string &topic, const std::string &payload) {
+      auto val = parse_on_off(payload.c_str(), "forward", "reverse");
+      switch (val) {
+        case PARSE_ON:
+          ESP_LOGD(TAG, "'%s': Setting direction FORWARD", this->friendly_name().c_str());
+          this->state_->make_call().set_direction(fan::FanDirection::FORWARD).perform();
+          break;
+        case PARSE_OFF:
+          ESP_LOGD(TAG, "'%s': Setting direction REVERSE", this->friendly_name().c_str());
+          this->state_->make_call().set_direction(fan::FanDirection::REVERSE).perform();
+          break;
+        case PARSE_TOGGLE:
+          this->state_->make_call()
+              .set_direction(this->state_->direction == fan::FanDirection::FORWARD ? fan::FanDirection::REVERSE
+                                                                                   : fan::FanDirection::FORWARD)
+              .perform();
+          break;
+        case PARSE_NONE:
+          ESP_LOGW(TAG, "Unknown direction Payload %s", payload.c_str());
+          this->status_momentary_warning("direction", 5000);
+          break;
+      }
+    });
+  }
+
   if (this->state_->get_traits().supports_oscillation()) {
     this->subscribe(this->get_oscillation_command_topic(),
                     [this](const std::string &topic, const std::string &payload) {
@@ -94,6 +120,10 @@ void MQTTFanComponent::setup() {
 void MQTTFanComponent::dump_config() {
   ESP_LOGCONFIG(TAG, "MQTT Fan '%s': ", this->state_->get_name().c_str());
   LOG_MQTT_COMPONENT(true, true);
+  if (this->state_->get_traits().supports_direction()) {
+    ESP_LOGCONFIG(TAG, "  Direction State Topic: '%s'", this->get_direction_state_topic().c_str());
+    ESP_LOGCONFIG(TAG, "  Direction Command Topic: '%s'", this->get_direction_command_topic().c_str());
+  }
   if (this->state_->get_traits().supports_oscillation()) {
     ESP_LOGCONFIG(TAG, "  Oscillation State Topic: '%s'", this->get_oscillation_state_topic().c_str());
     ESP_LOGCONFIG(TAG, "  Oscillation Command Topic: '%s'", this->get_oscillation_command_topic().c_str());
@@ -107,6 +137,10 @@ void MQTTFanComponent::dump_config() {
 bool MQTTFanComponent::send_initial_state() { return this->publish_state(); }
 
 void MQTTFanComponent::send_discovery(JsonObject root, mqtt::SendDiscoveryConfig &config) {
+  if (this->state_->get_traits().supports_direction()) {
+    root[MQTT_DIRECTION_COMMAND_TOPIC] = this->get_direction_command_topic();
+    root[MQTT_DIRECTION_STATE_TOPIC] = this->get_direction_state_topic();
+  }
   if (this->state_->get_traits().supports_oscillation()) {
     root[MQTT_OSCILLATION_COMMAND_TOPIC] = this->get_oscillation_command_topic();
     root[MQTT_OSCILLATION_STATE_TOPIC] = this->get_oscillation_state_topic();
@@ -122,6 +156,11 @@ bool MQTTFanComponent::publish_state() {
   ESP_LOGD(TAG, "'%s' Sending state %s.", this->state_->get_name().c_str(), state_s);
   this->publish(this->get_state_topic_(), state_s);
   bool failed = false;
+  if (this->state_->get_traits().supports_direction()) {
+    bool success = this->publish(this->get_direction_state_topic(),
+                                 this->state_->direction == fan::FanDirection::FORWARD ? "forward" : "reverse");
+    failed = failed || !success;
+  }
   if (this->state_->get_traits().supports_oscillation()) {
     bool success = this->publish(this->get_oscillation_state_topic(),
                                  this->state_->oscillating ? "oscillate_on" : "oscillate_off");

esphome/components/mqtt/mqtt_fan.h

@@ -15,6 +15,8 @@ class MQTTFanComponent : public mqtt::MQTTComponent {
  public:
   explicit MQTTFanComponent(fan::Fan *state);
 
+  MQTT_COMPONENT_CUSTOM_TOPIC(direction, command)
+  MQTT_COMPONENT_CUSTOM_TOPIC(direction, state)
   MQTT_COMPONENT_CUSTOM_TOPIC(oscillation, command)
   MQTT_COMPONENT_CUSTOM_TOPIC(oscillation, state)
   MQTT_COMPONENT_CUSTOM_TOPIC(speed_level, command)

esphome/components/network/__init__.py

@@ -26,7 +26,7 @@ CONFIG_SCHEMA = cv.Schema(
                     esp32_arduino=cv.Version(0, 0, 0),
                     esp8266_arduino=cv.Version(0, 0, 0),
                     rp2040_arduino=cv.Version(0, 0, 0),
-                    bk72xx_libretiny=cv.Version(1, 7, 0),
+                    bk72xx_arduino=cv.Version(1, 7, 0),
                 ),
                 cv.boolean_false,
             ),

esphome/components/nextion/base_component.py

@@ -7,28 +7,29 @@ from esphome.const import CONF_BACKGROUND_COLOR, CONF_FOREGROUND_COLOR, CONF_VIS
 
 from . import CONF_NEXTION_ID, Nextion
 
-CONF_VARIABLE_NAME = "variable_name"
+CONF_AUTO_WAKE_ON_TOUCH = "auto_wake_on_touch"
+CONF_BACKGROUND_PRESSED_COLOR = "background_pressed_color"
+CONF_COMMAND_SPACING = "command_spacing"
 CONF_COMPONENT_NAME = "component_name"
-CONF_WAVE_CHANNEL_ID = "wave_channel_id"
-CONF_WAVE_MAX_VALUE = "wave_max_value"
-CONF_PRECISION = "precision"
-CONF_WAVEFORM_SEND_LAST_VALUE = "waveform_send_last_value"
-CONF_TFT_URL = "tft_url"
+CONF_EXIT_REPARSE_ON_START = "exit_reparse_on_start"
+CONF_FONT_ID = "font_id"
+CONF_FOREGROUND_PRESSED_COLOR = "foreground_pressed_color"
+CONF_ON_BUFFER_OVERFLOW = "on_buffer_overflow"
+CONF_ON_PAGE = "on_page"
+CONF_ON_SETUP = "on_setup"
 CONF_ON_SLEEP = "on_sleep"
 CONF_ON_WAKE = "on_wake"
-CONF_ON_SETUP = "on_setup"
-CONF_ON_PAGE = "on_page"
-CONF_ON_BUFFER_OVERFLOW = "on_buffer_overflow"
+CONF_PRECISION = "precision"
+CONF_SKIP_CONNECTION_HANDSHAKE = "skip_connection_handshake"
+CONF_START_UP_PAGE = "start_up_page"
+CONF_TFT_URL = "tft_url"
 CONF_TOUCH_SLEEP_TIMEOUT = "touch_sleep_timeout"
+CONF_VARIABLE_NAME = "variable_name"
 CONF_WAKE_UP_PAGE = "wake_up_page"
-CONF_START_UP_PAGE = "start_up_page"
-CONF_AUTO_WAKE_ON_TOUCH = "auto_wake_on_touch"
+CONF_WAVE_CHANNEL_ID = "wave_channel_id"
 CONF_WAVE_MAX_LENGTH = "wave_max_length"
-CONF_BACKGROUND_PRESSED_COLOR = "background_pressed_color"
-CONF_FOREGROUND_PRESSED_COLOR = "foreground_pressed_color"
-CONF_FONT_ID = "font_id"
-CONF_EXIT_REPARSE_ON_START = "exit_reparse_on_start"
-CONF_SKIP_CONNECTION_HANDSHAKE = "skip_connection_handshake"
+CONF_WAVE_MAX_VALUE = "wave_max_value"
+CONF_WAVEFORM_SEND_LAST_VALUE = "waveform_send_last_value"
 
 
 def NextionName(value):

esphome/components/nextion/display.py

@@ -9,16 +9,17 @@ from esphome.const import (
     CONF_ON_TOUCH,
     CONF_TRIGGER_ID,
 )
-from esphome.core import CORE
+from esphome.core import CORE, TimePeriod
 
 from . import Nextion, nextion_ns, nextion_ref
 from .base_component import (
     CONF_AUTO_WAKE_ON_TOUCH,
+    CONF_COMMAND_SPACING,
     CONF_EXIT_REPARSE_ON_START,
     CONF_ON_BUFFER_OVERFLOW,
-    CONF_ON_PAGE,
     CONF_ON_SETUP,
     CONF_ON_SLEEP,
+    CONF_ON_PAGE,
     CONF_ON_WAKE,
     CONF_SKIP_CONNECTION_HANDSHAKE,
     CONF_START_UP_PAGE,
@@ -88,6 +89,10 @@ CONFIG_SCHEMA = (
             cv.Optional(CONF_AUTO_WAKE_ON_TOUCH, default=True): cv.boolean,
             cv.Optional(CONF_EXIT_REPARSE_ON_START, default=False): cv.boolean,
             cv.Optional(CONF_SKIP_CONNECTION_HANDSHAKE, default=False): cv.boolean,
+            cv.Optional(CONF_COMMAND_SPACING): cv.All(
+                cv.positive_time_period_milliseconds,
+                cv.Range(max=TimePeriod(milliseconds=255)),
+            ),
         }
     )
     .extend(cv.polling_component_schema("5s"))
@@ -120,6 +125,10 @@ async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     await uart.register_uart_device(var, config)
 
+    if command_spacing := config.get(CONF_COMMAND_SPACING):
+        cg.add_define("USE_NEXTION_COMMAND_SPACING")
+        cg.add(var.set_command_spacing(command_spacing.total_milliseconds))
+
     if CONF_BRIGHTNESS in config:
         cg.add(var.set_brightness(config[CONF_BRIGHTNESS]))
 

esphome/components/nextion/nextion.cpp

@@ -31,11 +31,22 @@ bool Nextion::send_command_(const std::string &command) {
     return false;
   }
 
+#ifdef USE_NEXTION_COMMAND_SPACING
+  if (!this->ignore_is_setup_ && !this->command_pacer_.can_send()) {
+    return false;
+  }
+#endif  // USE_NEXTION_COMMAND_SPACING
+
   ESP_LOGN(TAG, "send_command %s", command.c_str());
 
   this->write_str(command.c_str());
   const uint8_t to_send[3] = {0xFF, 0xFF, 0xFF};
   this->write_array(to_send, sizeof(to_send));
+
+#ifdef USE_NEXTION_COMMAND_SPACING
+  this->command_pacer_.mark_sent();
+#endif  // USE_NEXTION_COMMAND_SPACING
+
   return true;
 }
 
@@ -158,6 +169,10 @@ void Nextion::dump_config() {
   if (this->start_up_page_ != -1) {
     ESP_LOGCONFIG(TAG, "  Start Up Page:    %" PRId16, this->start_up_page_);
   }
+
+#ifdef USE_NEXTION_COMMAND_SPACING
+  ESP_LOGCONFIG(TAG, "  Command spacing:  %" PRIu8 "ms", this->command_pacer_.get_spacing());
+#endif  // USE_NEXTION_COMMAND_SPACING
 }
 
 float Nextion::get_setup_priority() const { return setup_priority::DATA; }
@@ -312,6 +327,11 @@ bool Nextion::remove_from_q_(bool report_empty) {
   }
 
   NextionQueue *nb = this->nextion_queue_.front();
+  if (!nb || !nb->component) {
+    ESP_LOGE(TAG, "Invalid queue entry!");
+    this->nextion_queue_.pop_front();
+    return false;
+  }
   NextionComponentBase *component = nb->component;
 
   ESP_LOGN(TAG, "Removing %s from the queue", component->get_variable_name().c_str());
@@ -341,6 +361,12 @@ void Nextion::process_nextion_commands_() {
     return;
   }
 
+#ifdef USE_NEXTION_COMMAND_SPACING
+  if (!this->command_pacer_.can_send()) {
+    return;  // Will try again in next loop iteration
+  }
+#endif
+
   size_t to_process_length = 0;
   std::string to_process;
 
@@ -380,7 +406,9 @@ void Nextion::process_nextion_commands_() {
             this->setup_callback_.call();
           }
         }
-
+#ifdef USE_NEXTION_COMMAND_SPACING
+        this->command_pacer_.mark_sent();  // Here is where we should mark the command as sent
+#endif
         break;
       case 0x02:  // invalid Component ID or name was used
         ESP_LOGW(TAG, "Nextion reported component ID or name invalid!");
@@ -524,6 +552,11 @@ void Nextion::process_nextion_commands_() {
         }
 
         NextionQueue *nb = this->nextion_queue_.front();
+        if (!nb || !nb->component) {
+          ESP_LOGE(TAG, "Invalid queue entry!");
+          this->nextion_queue_.pop_front();
+          return;
+        }
         NextionComponentBase *component = nb->component;
 
         if (component->get_queue_type() != NextionQueueType::TEXT_SENSOR) {
@@ -564,6 +597,11 @@ void Nextion::process_nextion_commands_() {
         }
 
         NextionQueue *nb = this->nextion_queue_.front();
+        if (!nb || !nb->component) {
+          ESP_LOGE(TAG, "Invalid queue entry!");
+          this->nextion_queue_.pop_front();
+          return;
+        }
         NextionComponentBase *component = nb->component;
 
         if (component->get_queue_type() != NextionQueueType::SENSOR &&

esphome/components/nextion/nextion.h

@@ -35,8 +35,54 @@ using nextion_writer_t = std::function<void(Nextion &)>;
 
 static const std::string COMMAND_DELIMITER{static_cast<char>(255), static_cast<char>(255), static_cast<char>(255)};
 
+#ifdef USE_NEXTION_COMMAND_SPACING
+class NextionCommandPacer {
+ public:
+  /**
+   * @brief Creates command pacer with initial spacing
+   * @param initial_spacing Initial time between commands in milliseconds
+   */
+  explicit NextionCommandPacer(uint8_t initial_spacing = 0) : spacing_ms_(initial_spacing) {}
+
+  /**
+   * @brief Set the minimum time between commands
+   * @param spacing_ms Spacing in milliseconds
+   */
+  void set_spacing(uint8_t spacing_ms) { spacing_ms_ = spacing_ms; }
+
+  /**
+   * @brief Get current command spacing
+   * @return Current spacing in milliseconds
+   */
+  uint8_t get_spacing() const { return spacing_ms_; }
+
+  /**
+   * @brief Check if enough time has passed to send next command
+   * @return true if enough time has passed since last command
+   */
+  bool can_send() const { return (millis() - last_command_time_) >= spacing_ms_; }
+
+  /**
+   * @brief Mark a command as sent, updating the timing
+   */
+  void mark_sent() { last_command_time_ = millis(); }
+
+ private:
+  uint8_t spacing_ms_;
+  uint32_t last_command_time_{0};
+};
+#endif  // USE_NEXTION_COMMAND_SPACING
+
 class Nextion : public NextionBase, public PollingComponent, public uart::UARTDevice {
  public:
+#ifdef USE_NEXTION_COMMAND_SPACING
+  /**
+   * @brief Set the command spacing for the display
+   * @param spacing_ms Time in milliseconds between commands
+   */
+  void set_command_spacing(uint32_t spacing_ms) { this->command_pacer_.set_spacing(spacing_ms); }
+#endif  // USE_NEXTION_COMMAND_SPACING
+
   /**
    * Set the text of a component to a static string.
    * @param component The component name.
@@ -1227,6 +1273,9 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
   bool is_connected() { return this->is_connected_; }
 
  protected:
+#ifdef USE_NEXTION_COMMAND_SPACING
+  NextionCommandPacer command_pacer_{0};
+#endif  // USE_NEXTION_COMMAND_SPACING
   std::deque<NextionQueue *> nextion_queue_;
   std::deque<NextionQueue *> waveform_queue_;
   uint16_t recv_ret_string_(std::string &response, uint32_t timeout, bool recv_flag);
@@ -1360,5 +1409,6 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
   uint32_t started_ms_ = 0;
   bool sent_setup_commands_ = false;
 };
+
 }  // namespace nextion
 }  // namespace esphome