esphome 2025.6.2__py3-none-any.whl → 2025.7.0__py3-none-any.whl

esphome/components/nextion/nextion.h

@@ -932,21 +932,6 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    */
   void set_backlight_brightness(float brightness);
 
-  /**
-   * Sets whether the Nextion display should skip the connection handshake process.
-   * @param skip_handshake True or false. When skip_connection_handshake is true,
-   * the connection will be established without performing the handshake.
-   * This can be useful when using Nextion Simulator.
-   *
-   * Example:
-   * ```cpp
-   * it.set_skip_connection_handshake(true);
-   * ```
-   *
-   * When set to true, the display will be marked as connected without performing a handshake.
-   */
-  void set_skip_connection_handshake(bool skip_handshake) { this->skip_connection_handshake_ = skip_handshake; }
-
   /**
    * Sets Nextion mode between sleep and awake
    * @param True or false. Sleep=true to enter sleep mode or sleep=false to exit sleep mode.
@@ -1179,22 +1164,43 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
   void update_components_by_prefix(const std::string &prefix);
 
   /**
-   * Set the touch sleep timeout of the display.
-   * @param timeout Timeout in seconds.
+   * Set the touch sleep timeout of the display using the `thsp` command.
+   *
+   * Sets internal No-touch-then-sleep timer to specified value in seconds.
+   * Nextion will auto-enter sleep mode if and when this timer expires.
+   *
+   * @param touch_sleep_timeout Timeout in seconds.
+   *                           Range: 3 to 65535 seconds (minimum 3 seconds, maximum ~18 hours 12 minutes 15 seconds)
+   *                           Use 0 to disable touch sleep timeout.
+   *
+   * @note Once `thsp` is set, it will persist until reboot or reset. The Nextion device
+   *       needs to exit sleep mode to issue `thsp=0` to disable sleep on no touch.
+   *
+   * @note The display will only wake up by a restart or by setting up `thup` (auto wake on touch).
+   *       See set_auto_wake_on_touch() to configure wake behavior.
    *
    * Example:
    * ```cpp
+   * // Set 30 second touch timeout
    * it.set_touch_sleep_timeout(30);
+   *
+   * // Set maximum timeout (~18 hours)
+   * it.set_touch_sleep_timeout(65535);
+   *
+   * // Disable touch sleep timeout
+   * it.set_touch_sleep_timeout(0);
    * ```
    *
-   * After 30 seconds the display will go to sleep. Note: the display will only wakeup by a restart or by setting up
-   * `thup`.
+   * Related Nextion instruction: `thsp=<value>`
+   *
+   * @see set_auto_wake_on_touch() Configure automatic wake on touch
+   * @see sleep() Manually control sleep state
    */
-  void set_touch_sleep_timeout(uint32_t touch_sleep_timeout);
+  void set_touch_sleep_timeout(uint16_t touch_sleep_timeout = 0);
 
   /**
    * Sets which page Nextion loads when exiting sleep mode. Note this can be set even when Nextion is in sleep mode.
-   * @param wake_up_page The page id, from 0 to the lage page in Nextion. Set 255 (not set to any existing page) to
+   * @param wake_up_page The page id, from 0 to the last page in Nextion. Set 255 (not set to any existing page) to
    * wakes up to current page.
    *
    * Example:
@@ -1206,9 +1212,10 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    */
   void set_wake_up_page(uint8_t wake_up_page = 255);
 
+#ifdef USE_NEXTION_CONF_START_UP_PAGE
   /**
    * Sets which page Nextion loads when connecting to ESPHome.
-   * @param start_up_page The page id, from 0 to the lage page in Nextion. Set 255 (not set to any existing page) to
+   * @param start_up_page The page id, from 0 to the last page in Nextion. Set 255 (not set to any existing page) to
    * wakes up to current page.
    *
    * Example:
@@ -1219,6 +1226,7 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    * The display will go to page 2 when it establishes a connection to ESPHome.
    */
   void set_start_up_page(uint8_t start_up_page = 255) { this->start_up_page_ = start_up_page; }
+#endif  // USE_NEXTION_CONF_START_UP_PAGE
 
   /**
    * Sets if Nextion should auto-wake from sleep when touch press occurs.
@@ -1234,20 +1242,6 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    */
   void set_auto_wake_on_touch(bool auto_wake_on_touch);
 
-  /**
-   * Sets if Nextion should exit the active reparse mode before the "connect" command is sent
-   * @param exit_reparse_on_start True or false. When exit_reparse_on_start is true, the exit reparse command
-   * will be sent before requesting the connection from Nextion.
-   *
-   * Example:
-   * ```cpp
-   * it.set_exit_reparse_on_start(true);
-   * ```
-   *
-   * The display will be requested to leave active reparse mode before setup.
-   */
-  void set_exit_reparse_on_start(bool exit_reparse_on_start) { this->exit_reparse_on_start_ = exit_reparse_on_start; }
-
   /**
    * @brief Retrieves the number of commands pending in the Nextion command queue.
    *
@@ -1290,7 +1284,7 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    * the Nextion display. A connection is considered established when:
    *
    * - The initial handshake with the display is completed successfully, or
-   * - The handshake is skipped via skip_connection_handshake_ flag
+   * - The handshake is skipped via USE_NEXTION_CONFIG_SKIP_CONNECTION_HANDSHAKE flag
    *
    * The connection status is particularly useful when:
    * - Troubleshooting communication issues
@@ -1300,7 +1294,7 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    * @return true if the Nextion display is connected and ready to receive commands
    * @return false if the display is not yet connected or connection was lost
    */
-  bool is_connected() { return this->is_connected_; }
+  bool is_connected() { return this->connection_state_.is_connected_; }
 
  protected:
 #ifdef USE_NEXTION_MAX_COMMANDS_PER_LOOP
@@ -1309,34 +1303,54 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
 #ifdef USE_NEXTION_MAX_QUEUE_SIZE
   size_t max_queue_size_{0};
 #endif  // USE_NEXTION_MAX_QUEUE_SIZE
+
 #ifdef USE_NEXTION_COMMAND_SPACING
   NextionCommandPacer command_pacer_{0};
+
+  /**
+   * @brief Process any commands in the queue that are pending due to command spacing
+   *
+   * This method checks if the first item in the nextion_queue_ has a pending command
+   * that was previously blocked by command spacing. If spacing now allows and a
+   * pending command exists, it attempts to send the command. Once successfully sent,
+   * the pending command is cleared and the queue item continues normal processing.
+   *
+   * Called from loop() to retry sending commands that were delayed by spacing.
+   */
+  void process_pending_in_queue_();
 #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);
   void all_components_send_state_(bool force_update = false);
-  uint64_t comok_sent_ = 0;
+  uint32_t comok_sent_ = 0;
   bool remove_from_q_(bool report_empty = true);
 
   /**
-   * @brief
-   * Sends commands ignoring of the Nextion has been setup.
+   * @brief Status flags for Nextion display state management
+   *
+   * Uses bitfields to pack multiple boolean states into a single byte,
+   * saving 5 bytes of RAM compared to individual bool variables.
    */
-  bool ignore_is_setup_ = false;
-
-  bool nextion_reports_is_setup_ = false;
-  uint8_t nextion_event_;
+  struct {
+    uint8_t is_connected_ : 1;              ///< Connection established with Nextion display
+    uint8_t sent_setup_commands_ : 1;       ///< Initial setup commands have been sent
+    uint8_t ignore_is_setup_ : 1;           ///< Temporarily ignore setup state for special operations
+    uint8_t nextion_reports_is_setup_ : 1;  ///< Nextion has reported successful initialization
+    uint8_t is_updating_ : 1;               ///< TFT firmware update is currently in progress
+    uint8_t auto_wake_on_touch_ : 1;        ///< Display should wake automatically on touch (default: true)
+    uint8_t reserved_ : 2;                  ///< Reserved bits for future flag additions
+  } connection_state_{};                    ///< Zero-initialized status flags (all start as false)
 
   void process_nextion_commands_();
   void process_serial_();
-  bool is_updating_ = false;
-  uint32_t touch_sleep_timeout_ = 0;
-  int16_t wake_up_page_ = -1;
-  int16_t start_up_page_ = -1;
+  uint16_t touch_sleep_timeout_ = 0;
+  uint8_t wake_up_page_ = 255;
+#ifdef USE_NEXTION_CONF_START_UP_PAGE
+  uint8_t start_up_page_ = 255;
+#endif  // USE_NEXTION_CONF_START_UP_PAGE
   bool auto_wake_on_touch_ = true;
-  bool exit_reparse_on_start_ = false;
-  bool skip_connection_handshake_ = false;
 
   /**
    * Manually send a raw command to the display and don't wait for an acknowledgement packet.
@@ -1348,6 +1362,23 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
       __attribute__((format(printf, 3, 4)));
   void add_no_result_to_queue_with_command_(const std::string &variable_name, const std::string &command);
 
+#ifdef USE_NEXTION_COMMAND_SPACING
+  /**
+   * @brief Add a command to the Nextion queue with a pending command for retry
+   *
+   * This method creates a queue entry for a command that was blocked by command spacing.
+   * The command string is stored in the queue item's pending_command field so it can
+   * be retried later when spacing allows. This ensures commands are not lost when
+   * sent too quickly.
+   *
+   * If the max_queue_size limit is configured and reached, the command will be dropped.
+   *
+   * @param variable_name Name of the variable or component associated with the command
+   * @param command The actual command string to be sent when spacing allows
+   */
+  void add_no_result_to_queue_with_pending_command_(const std::string &variable_name, const std::string &command);
+#endif  // USE_NEXTION_COMMAND_SPACING
+
   bool add_no_result_to_queue_with_printf_(const std::string &variable_name, const char *format, ...)
       __attribute__((format(printf, 3, 4)));
 
@@ -1426,10 +1457,12 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
   optional<nextion_writer_t> writer_;
   optional<float> brightness_;
 
+#ifdef USE_NEXTION_CONFIG_DUMP_DEVICE_INFO
   std::string device_model_;
   std::string firmware_version_;
   std::string serial_number_;
   std::string flash_size_;
+#endif  // USE_NEXTION_CONFIG_DUMP_DEVICE_INFO
 
   void remove_front_no_sensors_();
 
@@ -1439,11 +1472,9 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
   void reset_(bool reset_nextion = true);
 
   std::string command_data_;
-  bool is_connected_ = false;
   const uint16_t startup_override_ms_ = 8000;
   const uint16_t max_q_age_ms_ = 8000;
   uint32_t started_ms_ = 0;
-  bool sent_setup_commands_ = false;
 };
 
 }  // namespace nextion

esphome/components/nextion/nextion_commands.cpp

@@ -15,14 +15,15 @@ void Nextion::set_wake_up_page(uint8_t wake_up_page) {
   this->add_no_result_to_queue_with_set_internal_("wake_up_page", "wup", wake_up_page, true);
 }
 
-void Nextion::set_touch_sleep_timeout(uint32_t touch_sleep_timeout) {
-  if (touch_sleep_timeout < 3) {
-    ESP_LOGD(TAG, "Sleep timeout out of bounds (3-65535)");
-    return;
+void Nextion::set_touch_sleep_timeout(const uint16_t touch_sleep_timeout) {
+  // Validate range: Nextion thsp command requires min 3, max 65535 seconds (0 disables)
+  if (touch_sleep_timeout != 0 && touch_sleep_timeout < 3) {
+    this->touch_sleep_timeout_ = 3;  // Auto-correct to minimum valid value
+  } else {
+    this->touch_sleep_timeout_ = touch_sleep_timeout;
   }
 
-  this->touch_sleep_timeout_ = touch_sleep_timeout;
-  this->add_no_result_to_queue_with_set_internal_("touch_sleep_timeout", "thsp", touch_sleep_timeout, true);
+  this->add_no_result_to_queue_with_set_internal_("touch_sleep_timeout", "thsp", this->touch_sleep_timeout_, true);
 }
 
 void Nextion::sleep(bool sleep) {
@@ -38,7 +39,7 @@ void Nextion::sleep(bool sleep) {
 // Protocol reparse mode
 bool Nextion::set_protocol_reparse_mode(bool active_mode) {
   ESP_LOGV(TAG, "Reparse mode: %s", YESNO(active_mode));
-  this->ignore_is_setup_ = true;  // if not in reparse mode setup will fail, so it should be ignored
+  this->connection_state_.ignore_is_setup_ = true;  // if not in reparse mode setup will fail, so it should be ignored
   bool all_commands_sent = true;
   if (active_mode) {  // Sets active protocol reparse mode
     all_commands_sent &= this->send_command_("recmod=1");
@@ -48,10 +49,10 @@ bool Nextion::set_protocol_reparse_mode(bool active_mode) {
     all_commands_sent &= this->send_command_("recmod=0");  // Sending recmode=0 twice is recommended
     all_commands_sent &= this->send_command_("recmod=0");
   }
-  if (!this->nextion_reports_is_setup_) {  // No need to connect if is already setup
+  if (!this->connection_state_.nextion_reports_is_setup_) {  // No need to connect if is already setup
     all_commands_sent &= this->send_command_("connect");
   }
-  this->ignore_is_setup_ = false;
+  this->connection_state_.ignore_is_setup_ = false;
   return all_commands_sent;
 }
 
@@ -191,7 +192,7 @@ void Nextion::set_backlight_brightness(float brightness) {
 }
 
 void Nextion::set_auto_wake_on_touch(bool auto_wake_on_touch) {
-  this->auto_wake_on_touch_ = auto_wake_on_touch;
+  this->connection_state_.auto_wake_on_touch_ = auto_wake_on_touch;
   this->add_no_result_to_queue_with_set("auto_wake_on_touch", "thup", auto_wake_on_touch ? 1 : 0);
 }
 

esphome/components/nextion/nextion_component.cpp

@@ -8,8 +8,8 @@ void NextionComponent::set_background_color(Color bco) {
     return;  // This is a variable. no need to set color
   }
   this->bco_ = bco;
-  this->bco_needs_update_ = true;
-  this->bco_is_set_ = true;
+  this->component_flags_.bco_needs_update = true;
+  this->component_flags_.bco_is_set = true;
   this->update_component_settings();
 }
 
@@ -19,8 +19,8 @@ void NextionComponent::set_background_pressed_color(Color bco2) {
   }
 
   this->bco2_ = bco2;
-  this->bco2_needs_update_ = true;
-  this->bco2_is_set_ = true;
+  this->component_flags_.bco2_needs_update = true;
+  this->component_flags_.bco2_is_set = true;
   this->update_component_settings();
 }
 
@@ -29,8 +29,8 @@ void NextionComponent::set_foreground_color(Color pco) {
     return;  // This is a variable. no need to set color
   }
   this->pco_ = pco;
-  this->pco_needs_update_ = true;
-  this->pco_is_set_ = true;
+  this->component_flags_.pco_needs_update = true;
+  this->component_flags_.pco_is_set = true;
   this->update_component_settings();
 }
 
@@ -39,8 +39,8 @@ void NextionComponent::set_foreground_pressed_color(Color pco2) {
     return;  // This is a variable. no need to set color
   }
   this->pco2_ = pco2;
-  this->pco2_needs_update_ = true;
-  this->pco2_is_set_ = true;
+  this->component_flags_.pco2_needs_update = true;
+  this->component_flags_.pco2_is_set = true;
   this->update_component_settings();
 }
 
@@ -49,8 +49,8 @@ void NextionComponent::set_font_id(uint8_t font_id) {
     return;  // This is a variable. no need to set color
   }
   this->font_id_ = font_id;
-  this->font_id_needs_update_ = true;
-  this->font_id_is_set_ = true;
+  this->component_flags_.font_id_needs_update = true;
+  this->component_flags_.font_id_is_set = true;
   this->update_component_settings();
 }
 
@@ -58,20 +58,20 @@ void NextionComponent::set_visible(bool visible) {
   if (this->variable_name_ == this->variable_name_to_send_) {
     return;  // This is a variable. no need to set color
   }
-  this->visible_ = visible;
-  this->visible_needs_update_ = true;
-  this->visible_is_set_ = true;
+  this->component_flags_.visible = visible;
+  this->component_flags_.visible_needs_update = true;
+  this->component_flags_.visible_is_set = true;
   this->update_component_settings();
 }
 
 void NextionComponent::update_component_settings(bool force_update) {
-  if (this->nextion_->is_sleeping() || !this->nextion_->is_setup() || !this->visible_is_set_ ||
-      (!this->visible_needs_update_ && !this->visible_)) {
+  if (this->nextion_->is_sleeping() || !this->nextion_->is_setup() || !this->component_flags_.visible_is_set ||
+      (!this->component_flags_.visible_needs_update && !this->component_flags_.visible)) {
     this->needs_to_send_update_ = true;
     return;
   }
 
-  if (this->visible_needs_update_ || (force_update && this->visible_is_set_)) {
+  if (this->component_flags_.visible_needs_update || (force_update && this->component_flags_.visible_is_set)) {
     std::string name_to_send = this->variable_name_;
 
     size_t pos = name_to_send.find_last_of('.');
@@ -79,9 +79,9 @@ void NextionComponent::update_component_settings(bool force_update) {
       name_to_send = name_to_send.substr(pos + 1);
     }
 
-    this->visible_needs_update_ = false;
+    this->component_flags_.visible_needs_update = false;
 
-    if (this->visible_) {
+    if (this->component_flags_.visible) {
       this->nextion_->show_component(name_to_send.c_str());
       this->send_state_to_nextion();
     } else {
@@ -90,26 +90,26 @@ void NextionComponent::update_component_settings(bool force_update) {
     }
   }
 
-  if (this->bco_needs_update_ || (force_update && this->bco2_is_set_)) {
+  if (this->component_flags_.bco_needs_update || (force_update && this->component_flags_.bco2_is_set)) {
     this->nextion_->set_component_background_color(this->variable_name_.c_str(), this->bco_);
-    this->bco_needs_update_ = false;
+    this->component_flags_.bco_needs_update = false;
   }
-  if (this->bco2_needs_update_ || (force_update && this->bco2_is_set_)) {
+  if (this->component_flags_.bco2_needs_update || (force_update && this->component_flags_.bco2_is_set)) {
     this->nextion_->set_component_pressed_background_color(this->variable_name_.c_str(), this->bco2_);
-    this->bco2_needs_update_ = false;
+    this->component_flags_.bco2_needs_update = false;
   }
-  if (this->pco_needs_update_ || (force_update && this->pco_is_set_)) {
+  if (this->component_flags_.pco_needs_update || (force_update && this->component_flags_.pco_is_set)) {
     this->nextion_->set_component_foreground_color(this->variable_name_.c_str(), this->pco_);
-    this->pco_needs_update_ = false;
+    this->component_flags_.pco_needs_update = false;
   }
-  if (this->pco2_needs_update_ || (force_update && this->pco2_is_set_)) {
+  if (this->component_flags_.pco2_needs_update || (force_update && this->component_flags_.pco2_is_set)) {
     this->nextion_->set_component_pressed_foreground_color(this->variable_name_.c_str(), this->pco2_);
-    this->pco2_needs_update_ = false;
+    this->component_flags_.pco2_needs_update = false;
   }
 
-  if (this->font_id_needs_update_ || (force_update && this->font_id_is_set_)) {
+  if (this->component_flags_.font_id_needs_update || (force_update && this->component_flags_.font_id_is_set)) {
     this->nextion_->set_component_font(this->variable_name_.c_str(), this->font_id_);
-    this->font_id_needs_update_ = false;
+    this->component_flags_.font_id_needs_update = false;
   }
 }
 }  // namespace nextion

esphome/components/nextion/nextion_component.h

@@ -21,29 +21,64 @@ class NextionComponent : public NextionComponentBase {
   void set_visible(bool visible);
 
  protected:
+  /**
+   * @brief Constructor initializes component state with visible=true (default state)
+   */
+  NextionComponent() {
+    component_flags_ = {};         // Zero-initialize all state
+    component_flags_.visible = 1;  // Set default visibility to true
+  }
+
   NextionBase *nextion_;
 
-  bool bco_needs_update_ = false;
-  bool bco_is_set_ = false;
-  Color bco_;
-  bool bco2_needs_update_ = false;
-  bool bco2_is_set_ = false;
-  Color bco2_;
-  bool pco_needs_update_ = false;
-  bool pco_is_set_ = false;
-  Color pco_;
-  bool pco2_needs_update_ = false;
-  bool pco2_is_set_ = false;
-  Color pco2_;
+  // Color and styling properties
+  Color bco_;   // Background color
+  Color bco2_;  // Pressed background color
+  Color pco_;   // Foreground color
+  Color pco2_;  // Pressed foreground color
   uint8_t font_id_ = 0;
-  bool font_id_needs_update_ = false;
-  bool font_id_is_set_ = false;
 
-  bool visible_ = true;
-  bool visible_needs_update_ = false;
-  bool visible_is_set_ = false;
+  /**
+   * @brief Component state management using compact bitfield structure
+   *
+   * Stores all component state flags and properties in a single 16-bit bitfield
+   * for efficient memory usage and improved cache locality.
+   *
+   * Each component property maintains two state flags:
+   * - needs_update: Indicates the property requires synchronization with the display
+   * - is_set: Tracks whether the property has been explicitly configured
+   *
+   * The visible field stores both the update flags and the actual visibility state.
+   */
+  struct ComponentState {
+    // Background color flags
+    uint16_t bco_needs_update : 1;
+    uint16_t bco_is_set : 1;
+
+    // Pressed background color flags
+    uint16_t bco2_needs_update : 1;
+    uint16_t bco2_is_set : 1;
+
+    // Foreground color flags
+    uint16_t pco_needs_update : 1;
+    uint16_t pco_is_set : 1;
+
+    // Pressed foreground color flags
+    uint16_t pco2_needs_update : 1;
+    uint16_t pco2_is_set : 1;
+
+    // Font ID flags
+    uint16_t font_id_needs_update : 1;
+    uint16_t font_id_is_set : 1;
+
+    // Visibility flags
+    uint16_t visible_needs_update : 1;
+    uint16_t visible_is_set : 1;
+    uint16_t visible : 1;  // Actual visibility state
 
-  // void send_state_to_nextion() = 0;
+    // Reserved bits for future expansion
+    uint16_t reserved : 3;
+  } component_flags_;
 };
 }  // namespace nextion
 }  // namespace esphome

esphome/components/nextion/nextion_component_base.h

@@ -25,6 +25,9 @@ class NextionQueue {
   virtual ~NextionQueue() = default;
   NextionComponentBase *component;
   uint32_t queue_time = 0;
+
+  // Store command for retry if spacing blocked it
+  std::string pending_command;  // Empty if command was sent successfully
 };
 
 class NextionComponentBase {

esphome/components/nextion/nextion_upload.cpp

@@ -0,0 +1,36 @@
+#include "nextion.h"
+
+#ifdef USE_NEXTION_TFT_UPLOAD
+
+#include "esphome/core/application.h"
+
+namespace esphome {
+namespace nextion {
+static const char *const TAG = "nextion.upload";
+
+bool Nextion::upload_end_(bool successful) {
+  if (successful) {
+    ESP_LOGD(TAG, "Upload successful");
+    delay(1500);  // NOLINT
+    App.safe_reboot();
+  } else {
+    ESP_LOGE(TAG, "Upload failed");
+
+    this->connection_state_.is_updating_ = false;
+    this->connection_state_.ignore_is_setup_ = false;
+
+    uint32_t baud_rate = this->parent_->get_baud_rate();
+    if (baud_rate != this->original_baud_rate_) {
+      ESP_LOGD(TAG, "Baud: %" PRIu32 "->%" PRIu32, baud_rate, this->original_baud_rate_);
+      this->parent_->set_baud_rate(this->original_baud_rate_);
+      this->parent_->load_settings();
+    }
+  }
+
+  return successful;
+}
+
+}  // namespace nextion
+}  // namespace esphome
+
+#endif  // USE_NEXTION_TFT_UPLOAD

esphome/components/nextion/nextion_upload_arduino.cpp

@@ -3,12 +3,12 @@
 #ifdef USE_NEXTION_TFT_UPLOAD
 #ifdef USE_ARDUINO
 
+#include <cinttypes>
+#include "esphome/components/network/util.h"
 #include "esphome/core/application.h"
 #include "esphome/core/defines.h"
-#include "esphome/core/util.h"
 #include "esphome/core/log.h"
-#include "esphome/components/network/util.h"
-#include <cinttypes>
+#include "esphome/core/util.h"
 
 #ifdef USE_ESP32
 #include <esp_heap_caps.h>
@@ -52,7 +52,7 @@ int Nextion::upload_by_chunks_(HTTPClient &http_client, uint32_t &range_start) {
   }
 
   // Allocate the buffer dynamically
-  ExternalRAMAllocator<uint8_t> allocator(ExternalRAMAllocator<uint8_t>::ALLOW_FAILURE);
+  RAMAllocator<uint8_t> allocator;
   uint8_t *buffer = allocator.allocate(4096);
   if (!buffer) {
     ESP_LOGE(TAG, "Buffer alloc failed");
@@ -67,8 +67,8 @@ int Nextion::upload_by_chunks_(HTTPClient &http_client, uint32_t &range_start) {
     ESP_LOGV(TAG, "Fetch %" PRIu16 " bytes", buffer_size);
     uint16_t read_len = 0;
     int partial_read_len = 0;
-    const uint32_t start_time = millis();
-    while (read_len < buffer_size && millis() - start_time < 5000) {
+    const uint32_t start_time = App.get_loop_component_start_time();
+    while (read_len < buffer_size && App.get_loop_component_start_time() - start_time < 5000) {
       if (http_client.getStreamPtr()->available() > 0) {
         partial_read_len =
             http_client.getStreamPtr()->readBytes(reinterpret_cast<char *>(buffer) + read_len, buffer_size - read_len);
@@ -152,7 +152,7 @@ bool Nextion::upload_tft(uint32_t baud_rate, bool exit_reparse) {
   ESP_LOGD(TAG, "Exit reparse: %s", YESNO(exit_reparse));
   ESP_LOGD(TAG, "URL: %s", this->tft_url_.c_str());
 
-  if (this->is_updating_) {
+  if (this->connection_state_.is_updating_) {
     ESP_LOGW(TAG, "Upload in progress");
     return false;
   }
@@ -162,7 +162,7 @@ bool Nextion::upload_tft(uint32_t baud_rate, bool exit_reparse) {
     return false;
   }
 
-  this->is_updating_ = true;
+  this->connection_state_.is_updating_ = true;
 
   if (exit_reparse) {
     ESP_LOGD(TAG, "Exit reparse mode");
@@ -203,7 +203,7 @@ bool Nextion::upload_tft(uint32_t baud_rate, bool exit_reparse) {
   begin_status = http_client.begin(*this->get_wifi_client_(), this->tft_url_.c_str());
 #endif  // USE_ESP8266
   if (!begin_status) {
-    this->is_updating_ = false;
+    this->connection_state_.is_updating_ = false;
     ESP_LOGD(TAG, "Connection failed");
     return false;
   } else {
@@ -254,7 +254,7 @@ bool Nextion::upload_tft(uint32_t baud_rate, bool exit_reparse) {
 
   // The Nextion will ignore the upload command if it is sleeping
   ESP_LOGV(TAG, "Wake-up");
-  this->ignore_is_setup_ = true;
+  this->connection_state_.ignore_is_setup_ = true;
   this->send_command_("sleep=0");
   this->send_command_("dim=100");
   delay(250);  // NOLINT
@@ -335,31 +335,6 @@ bool Nextion::upload_tft(uint32_t baud_rate, bool exit_reparse) {
   return upload_end_(true);
 }
 
-bool Nextion::upload_end_(bool successful) {
-  ESP_LOGD(TAG, "TFT upload done: %s", YESNO(successful));
-
-  if (successful) {
-    ESP_LOGD(TAG, "Restart");
-    delay(1500);  // NOLINT
-    App.safe_reboot();
-    delay(1500);  // NOLINT
-  } else {
-    ESP_LOGE(TAG, "TFT upload failed");
-
-    this->is_updating_ = false;
-    this->ignore_is_setup_ = false;
-
-    uint32_t baud_rate = this->parent_->get_baud_rate();
-    if (baud_rate != this->original_baud_rate_) {
-      ESP_LOGD(TAG, "Baud back: %" PRIu32 "->%" PRIu32, baud_rate, this->original_baud_rate_);
-      this->parent_->set_baud_rate(this->original_baud_rate_);
-      this->parent_->load_settings();
-    }
-  }
-
-  return successful;
-}
-
 #ifdef USE_ESP8266
 WiFiClient *Nextion::get_wifi_client_() {
   if (this->tft_url_.compare(0, 6, "https:") == 0) {