esphome 2025.5.2__py3-none-any.whl → 2025.6.0b1__py3-none-any.whl

esphome/components/nextion/nextion.h

@@ -75,6 +75,36 @@ class NextionCommandPacer {
 
 class Nextion : public NextionBase, public PollingComponent, public uart::UARTDevice {
  public:
+#ifdef USE_NEXTION_MAX_COMMANDS_PER_LOOP
+  /**
+   * @brief Set the maximum number of commands to process in each loop iteration
+   * @param value Maximum number of commands (default: 20)
+   *
+   * Limiting the number of commands per loop helps prevent stack overflows
+   * when a large number of commands are queued at once, especially during boot.
+   */
+  inline void set_max_commands_per_loop(uint16_t value) { this->max_commands_per_loop_ = value; }
+
+  /**
+   * @brief Get the current maximum number of commands allowed per loop iteration
+   * @return Configured command limit per loop
+   */
+  inline uint16_t get_max_commands_per_loop() const { return this->max_commands_per_loop_; }
+#endif  // USE_NEXTION_MAX_COMMANDS_PER_LOOP
+#ifdef USE_NEXTION_MAX_QUEUE_SIZE
+  /**
+   * @brief Set the maximum allowed queue size
+   * @param size Max number of entries allowed in nextion_queue_
+   */
+  inline void set_max_queue_size(size_t size) { this->max_queue_size_ = size; }
+
+  /**
+   * @brief Get the maximum allowed queue size
+   * @return Current limit (0 = unlimited)
+   */
+  inline size_t get_max_queue_size() const { return this->max_queue_size_; }
+#endif  // USE_NEXTION_MAX_QUEUE_SIZE
+
 #ifdef USE_NEXTION_COMMAND_SPACING
   /**
    * @brief Set the command spacing for the display
@@ -1273,6 +1303,12 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
   bool is_connected() { return this->is_connected_; }
 
  protected:
+#ifdef USE_NEXTION_MAX_COMMANDS_PER_LOOP
+  uint16_t max_commands_per_loop_{1000};
+#endif  // USE_NEXTION_MAX_COMMANDS_PER_LOOP
+#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};
 #endif  // USE_NEXTION_COMMAND_SPACING

esphome/components/nextion/nextion_commands.cpp

@@ -17,7 +17,7 @@ void Nextion::set_wake_up_page(uint8_t wake_up_page) {
 
 void Nextion::set_touch_sleep_timeout(uint32_t touch_sleep_timeout) {
   if (touch_sleep_timeout < 3) {
-    ESP_LOGD(TAG, "Sleep timeout out of bounds, range 3-65535");
+    ESP_LOGD(TAG, "Sleep timeout out of bounds (3-65535)");
     return;
   }
 
@@ -37,7 +37,7 @@ void Nextion::sleep(bool sleep) {
 
 // Protocol reparse mode
 bool Nextion::set_protocol_reparse_mode(bool active_mode) {
-  ESP_LOGV(TAG, "Set Nextion protocol reparse mode: %s", YESNO(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
   bool all_commands_sent = true;
   if (active_mode) {  // Sets active protocol reparse mode
@@ -184,7 +184,7 @@ void Nextion::goto_page(uint8_t page) { this->add_no_result_to_queue_with_printf
 
 void Nextion::set_backlight_brightness(float brightness) {
   if (brightness < 0 || brightness > 1.0) {
-    ESP_LOGD(TAG, "Brightness out of bounds, percentage range 0-1.0");
+    ESP_LOGD(TAG, "Brightness out of bounds (0-1.0)");
     return;
   }
   this->add_no_result_to_queue_with_printf_("backlight_brightness", "dim=%d", static_cast<int>(brightness * 100));

esphome/components/nextion/nextion_upload_arduino.cpp

@@ -31,7 +31,7 @@ inline uint32_t Nextion::get_free_heap_() {
 
 int Nextion::upload_by_chunks_(HTTPClient &http_client, uint32_t &range_start) {
   uint32_t range_size = this->tft_size_ - range_start;
-  ESP_LOGV(TAG, "Free heap: %" PRIu32, this->get_free_heap_());
+  ESP_LOGV(TAG, "Heap: %" PRIu32, this->get_free_heap_());
   uint32_t range_end = ((upload_first_chunk_sent_ or this->tft_size_ < 4096) ? this->tft_size_ : 4096) - 1;
   ESP_LOGD(TAG, "Range start: %" PRIu32, range_start);
   if (range_size <= 0 or range_end <= range_start) {
@@ -43,11 +43,11 @@ int Nextion::upload_by_chunks_(HTTPClient &http_client, uint32_t &range_start) {
 
   char range_header[32];
   sprintf(range_header, "bytes=%" PRIu32 "-%" PRIu32, range_start, range_end);
-  ESP_LOGV(TAG, "Requesting range: %s", range_header);
+  ESP_LOGV(TAG, "Range: %s", range_header);
   http_client.addHeader("Range", range_header);
   int code = http_client.GET();
   if (code != HTTP_CODE_OK and code != HTTP_CODE_PARTIAL_CONTENT) {
-    ESP_LOGW(TAG, "HTTP Request failed; Error: %s", HTTPClient::errorToString(code).c_str());
+    ESP_LOGW(TAG, "HTTP failed: %s", HTTPClient::errorToString(code).c_str());
     return -1;
   }
 
@@ -55,7 +55,7 @@ int Nextion::upload_by_chunks_(HTTPClient &http_client, uint32_t &range_start) {
   ExternalRAMAllocator<uint8_t> allocator(ExternalRAMAllocator<uint8_t>::ALLOW_FAILURE);
   uint8_t *buffer = allocator.allocate(4096);
   if (!buffer) {
-    ESP_LOGE(TAG, "Failed to allocate upload buffer");
+    ESP_LOGE(TAG, "Buffer alloc failed");
     return -1;
   }
 
@@ -64,7 +64,7 @@ int Nextion::upload_by_chunks_(HTTPClient &http_client, uint32_t &range_start) {
     App.feed_wdt();
     const uint16_t buffer_size =
         this->content_length_ < 4096 ? this->content_length_ : 4096;  // Limits buffer to the remaining data
-    ESP_LOGV(TAG, "Fetching %" PRIu16 " bytes from HTTP", buffer_size);
+    ESP_LOGV(TAG, "Fetch %" PRIu16 " bytes", buffer_size);
     uint16_t read_len = 0;
     int partial_read_len = 0;
     const uint32_t start_time = millis();
@@ -81,14 +81,13 @@ int Nextion::upload_by_chunks_(HTTPClient &http_client, uint32_t &range_start) {
     }
     if (read_len != buffer_size) {
       // Did not receive the full package within the timeout period
-      ESP_LOGE(TAG, "Failed to read full package, received only %" PRIu16 " of %" PRIu16 " bytes", read_len,
-               buffer_size);
+      ESP_LOGE(TAG, "Read failed: %" PRIu16 "/%" PRIu16 " bytes", read_len, buffer_size);
       // Deallocate buffer
       allocator.deallocate(buffer, 4096);
       buffer = nullptr;
       return -1;
     }
-    ESP_LOGV(TAG, "%d bytes fetched, writing it to UART", read_len);
+    ESP_LOGV(TAG, "Fetched %d bytes", read_len);
     if (read_len > 0) {
       recv_string.clear();
       this->write_array(buffer, buffer_size);
@@ -97,25 +96,23 @@ int Nextion::upload_by_chunks_(HTTPClient &http_client, uint32_t &range_start) {
       this->content_length_ -= read_len;
       const float upload_percentage = 100.0f * (this->tft_size_ - this->content_length_) / this->tft_size_;
 #if defined(USE_ESP32) && defined(USE_PSRAM)
-      ESP_LOGD(
-          TAG,
-          "Uploaded %0.2f%%, remaining %" PRIu32 " bytes, free heap: %" PRIu32 " (DRAM) + %" PRIu32 " (PSRAM) bytes",
-          upload_percentage, this->content_length_, static_cast<uint32_t>(heap_caps_get_free_size(MALLOC_CAP_INTERNAL)),
-          static_cast<uint32_t>(heap_caps_get_free_size(MALLOC_CAP_SPIRAM)));
+      ESP_LOGD(TAG, "Upload: %0.2f%% (%" PRIu32 " left, heap: %" PRIu32 "+%" PRIu32 ")", upload_percentage,
+               this->content_length_, static_cast<uint32_t>(heap_caps_get_free_size(MALLOC_CAP_INTERNAL)),
+               static_cast<uint32_t>(heap_caps_get_free_size(MALLOC_CAP_SPIRAM)));
 #else
-      ESP_LOGD(TAG, "Uploaded %0.2f%%, remaining %" PRIu32 " bytes, free heap: %" PRIu32 " bytes", upload_percentage,
-               this->content_length_, this->get_free_heap_());
+      ESP_LOGD(TAG, "Upload: %0.2f%% (%" PRIu32 " left, heap: %" PRIu32 ")", upload_percentage, this->content_length_,
+               this->get_free_heap_());
 #endif
       upload_first_chunk_sent_ = true;
       if (recv_string[0] == 0x08 && recv_string.size() == 5) {  // handle partial upload request
-        ESP_LOGD(TAG, "recv_string [%s]",
+        ESP_LOGD(TAG, "Recv: [%s]",
                  format_hex_pretty(reinterpret_cast<const uint8_t *>(recv_string.data()), recv_string.size()).c_str());
         uint32_t result = 0;
         for (int j = 0; j < 4; ++j) {
           result += static_cast<uint8_t>(recv_string[j + 1]) << (8 * j);
         }
         if (result > 0) {
-          ESP_LOGI(TAG, "Nextion reported new range %" PRIu32, result);
+          ESP_LOGI(TAG, "New range: %" PRIu32, result);
           this->content_length_ = this->tft_size_ - result;
           range_start = result;
         } else {
@@ -126,7 +123,7 @@ int Nextion::upload_by_chunks_(HTTPClient &http_client, uint32_t &range_start) {
         buffer = nullptr;
         return range_end + 1;
       } else if (recv_string[0] != 0x05 and recv_string[0] != 0x08) {  // 0x05 == "ok"
-        ESP_LOGE(TAG, "Invalid response from Nextion: [%s]",
+        ESP_LOGE(TAG, "Invalid response: [%s]",
                  format_hex_pretty(reinterpret_cast<const uint8_t *>(recv_string.data()), recv_string.size()).c_str());
         // Deallocate buffer
         allocator.deallocate(buffer, 4096);
@@ -136,10 +133,10 @@ int Nextion::upload_by_chunks_(HTTPClient &http_client, uint32_t &range_start) {
 
       recv_string.clear();
     } else if (read_len == 0) {
-      ESP_LOGV(TAG, "End of HTTP response reached");
+      ESP_LOGV(TAG, "HTTP end");
       break;  // Exit the loop if there is no more data to read
     } else {
-      ESP_LOGE(TAG, "Failed to read from HTTP client, error code: %d", read_len);
+      ESP_LOGE(TAG, "HTTP read failed: %d", read_len);
       break;  // Exit the loop on error
     }
   }
@@ -151,26 +148,26 @@ int Nextion::upload_by_chunks_(HTTPClient &http_client, uint32_t &range_start) {
 }
 
 bool Nextion::upload_tft(uint32_t baud_rate, bool exit_reparse) {
-  ESP_LOGD(TAG, "Nextion TFT upload requested");
+  ESP_LOGD(TAG, "TFT upload requested");
   ESP_LOGD(TAG, "Exit reparse: %s", YESNO(exit_reparse));
   ESP_LOGD(TAG, "URL: %s", this->tft_url_.c_str());
 
   if (this->is_updating_) {
-    ESP_LOGW(TAG, "Currently uploading");
+    ESP_LOGW(TAG, "Upload in progress");
     return false;
   }
 
   if (!network::is_connected()) {
-    ESP_LOGE(TAG, "Network is not connected");
+    ESP_LOGE(TAG, "No network");
     return false;
   }
 
   this->is_updating_ = true;
 
   if (exit_reparse) {
-    ESP_LOGD(TAG, "Exiting Nextion reparse mode");
+    ESP_LOGD(TAG, "Exit reparse mode");
     if (!this->set_protocol_reparse_mode(false)) {
-      ESP_LOGW(TAG, "Failed to request Nextion to exit reparse mode");
+      ESP_LOGW(TAG, "Exit reparse failed");
       return false;
     }
   }
@@ -185,8 +182,8 @@ bool Nextion::upload_tft(uint32_t baud_rate, bool exit_reparse) {
   ESP_LOGD(TAG, "Baud rate: %" PRIu32, baud_rate);
 
   // Define the configuration for the HTTP client
-  ESP_LOGV(TAG, "Initializing HTTP client");
-  ESP_LOGV(TAG, "Free heap: %" PRIu32, this->get_free_heap_());
+  ESP_LOGV(TAG, "Init HTTP client");
+  ESP_LOGV(TAG, "Heap: %" PRIu32, this->get_free_heap_());
   HTTPClient http_client;
   http_client.setTimeout(15000);  // Yes 15 seconds.... Helps 8266s along
 
@@ -215,7 +212,7 @@ bool Nextion::upload_tft(uint32_t baud_rate, bool exit_reparse) {
   http_client.addHeader("Range", "bytes=0-255");
   const char *header_names[] = {"Content-Range"};
   http_client.collectHeaders(header_names, 1);
-  ESP_LOGD(TAG, "Requesting URL: %s", this->tft_url_.c_str());
+  ESP_LOGD(TAG, "URL: %s", this->tft_url_.c_str());
   http_client.setReuse(true);
   // try up to 5 times. DNS sometimes needs a second try or so
   int tries = 1;
@@ -224,7 +221,7 @@ bool Nextion::upload_tft(uint32_t baud_rate, bool exit_reparse) {
 
   App.feed_wdt();
   while (code != 200 && code != 206 && tries <= 5) {
-    ESP_LOGW(TAG, "HTTP Request failed; URL: %s; Error: %s, retrying (%d/5)", this->tft_url_.c_str(),
+    ESP_LOGW(TAG, "HTTP fail: URL: %s; Error: %s, retry %d/5", this->tft_url_.c_str(),
              HTTPClient::errorToString(code).c_str(), tries);
 
     delay(250);  // NOLINT
@@ -241,27 +238,27 @@ bool Nextion::upload_tft(uint32_t baud_rate, bool exit_reparse) {
   content_range_string.remove(0, 12);
   this->tft_size_ = content_range_string.toInt();
 
-  ESP_LOGD(TAG, "TFT file size: %zu bytes", this->tft_size_);
+  ESP_LOGD(TAG, "TFT size: %zu bytes", this->tft_size_);
   if (this->tft_size_ < 4096) {
-    ESP_LOGE(TAG, "File size check failed.");
-    ESP_LOGD(TAG, "Close HTTP connection");
+    ESP_LOGE(TAG, "Size check failed");
+    ESP_LOGD(TAG, "Close HTTP");
     http_client.end();
     ESP_LOGV(TAG, "Connection closed");
     return this->upload_end_(false);
   } else {
-    ESP_LOGV(TAG, "File size check passed. Proceeding...");
+    ESP_LOGV(TAG, "Size check OK");
   }
   this->content_length_ = this->tft_size_;
 
-  ESP_LOGD(TAG, "Uploading Nextion");
+  ESP_LOGD(TAG, "Uploading");
 
   // The Nextion will ignore the upload command if it is sleeping
-  ESP_LOGV(TAG, "Wake-up Nextion");
+  ESP_LOGV(TAG, "Wake-up");
   this->ignore_is_setup_ = true;
   this->send_command_("sleep=0");
   this->send_command_("dim=100");
   delay(250);  // NOLINT
-  ESP_LOGV(TAG, "Free heap: %" PRIu32, this->get_free_heap_());
+  ESP_LOGV(TAG, "Heap: %" PRIu32, this->get_free_heap_());
 
   App.feed_wdt();
   char command[128];
@@ -271,16 +268,16 @@ bool Nextion::upload_tft(uint32_t baud_rate, bool exit_reparse) {
   sprintf(command, "whmi-wris %d,%d,1", this->content_length_, baud_rate);
 
   // Clear serial receive buffer
-  ESP_LOGV(TAG, "Clear serial receive buffer");
+  ESP_LOGV(TAG, "Clear RX buffer");
   this->reset_(false);
   delay(250);  // NOLINT
-  ESP_LOGV(TAG, "Free heap: %" PRIu32, this->get_free_heap_());
+  ESP_LOGV(TAG, "Heap: %" PRIu32, this->get_free_heap_());
 
-  ESP_LOGV(TAG, "Send upload instruction: %s", command);
+  ESP_LOGV(TAG, "Upload cmd: %s", command);
   this->send_command_(command);
 
   if (baud_rate != this->original_baud_rate_) {
-    ESP_LOGD(TAG, "Changing baud rate from %" PRIu32 " to %" PRIu32 " bps", this->original_baud_rate_, baud_rate);
+    ESP_LOGD(TAG, "Baud: %" PRIu32 "->%" PRIu32, this->original_baud_rate_, baud_rate);
     this->parent_->set_baud_rate(baud_rate);
     this->parent_->load_settings();
   }
@@ -288,74 +285,74 @@ bool Nextion::upload_tft(uint32_t baud_rate, bool exit_reparse) {
   App.feed_wdt();
 
   std::string response;
-  ESP_LOGV(TAG, "Waiting for upgrade response");
+  ESP_LOGV(TAG, "Wait upload resp");
   this->recv_ret_string_(response, 5000, true);  // This can take some time to return
 
   // The Nextion display will, if it's ready to accept data, send a 0x05 byte.
-  ESP_LOGD(TAG, "Upgrade response is [%s] - %zu byte(s)",
+  ESP_LOGD(TAG, "Upload resp: [%s] %zu B",
            format_hex_pretty(reinterpret_cast<const uint8_t *>(response.data()), response.size()).c_str(),
            response.length());
-  ESP_LOGV(TAG, "Free heap: %" PRIu32, this->get_free_heap_());
+  ESP_LOGV(TAG, "Heap: %" PRIu32, this->get_free_heap_());
 
   if (response.find(0x05) != std::string::npos) {
-    ESP_LOGV(TAG, "Preparation for TFT upload done");
+    ESP_LOGV(TAG, "Upload prep done");
   } else {
-    ESP_LOGE(TAG, "Preparation for TFT upload failed %d \"%s\"", response[0], response.c_str());
-    ESP_LOGD(TAG, "Close HTTP connection");
+    ESP_LOGE(TAG, "Prep failed %d '%s'", response[0], response.c_str());
+    ESP_LOGD(TAG, "Close HTTP");
     http_client.end();
     ESP_LOGV(TAG, "Connection closed");
     return this->upload_end_(false);
   }
 
-  ESP_LOGD(TAG, "Uploading TFT to Nextion:");
-  ESP_LOGD(TAG, "  URL: %s", this->tft_url_.c_str());
-  ESP_LOGD(TAG, "  File size: %d bytes", this->content_length_);
-  ESP_LOGD(TAG, "  Free heap: %" PRIu32, this->get_free_heap_());
+  ESP_LOGD(TAG, "Upload TFT:");
+  ESP_LOGD(TAG, "  URL:  %s", this->tft_url_.c_str());
+  ESP_LOGD(TAG, "  Size: %d bytes", this->content_length_);
+  ESP_LOGD(TAG, "  Heap: %" PRIu32, this->get_free_heap_());
 
   // Proceed with the content download as before
 
-  ESP_LOGV(TAG, "Starting transfer by chunks loop");
+  ESP_LOGV(TAG, "Start chunk transfer");
 
   uint32_t position = 0;
   while (this->content_length_ > 0) {
     int upload_result = upload_by_chunks_(http_client, position);
     if (upload_result < 0) {
-      ESP_LOGE(TAG, "Error uploading TFT to Nextion!");
-      ESP_LOGD(TAG, "Close HTTP connection");
+      ESP_LOGE(TAG, "Upload error");
+      ESP_LOGD(TAG, "Close HTTP");
       http_client.end();
       ESP_LOGV(TAG, "Connection closed");
       return this->upload_end_(false);
     }
     App.feed_wdt();
-    ESP_LOGV(TAG, "Free heap: %" PRIu32 ", Bytes left: %" PRIu32, this->get_free_heap_(), this->content_length_);
+    ESP_LOGV(TAG, "Heap: %" PRIu32 " left: %" PRIu32, this->get_free_heap_(), this->content_length_);
   }
 
-  ESP_LOGD(TAG, "Successfully uploaded TFT to Nextion!");
+  ESP_LOGD(TAG, "Upload complete");
 
-  ESP_LOGD(TAG, "Close HTTP connection");
+  ESP_LOGV(TAG, "Close HTTP");
   http_client.end();
   ESP_LOGV(TAG, "Connection closed");
   return upload_end_(true);
 }
 
 bool Nextion::upload_end_(bool successful) {
-  ESP_LOGD(TAG, "Nextion TFT upload finished: %s", YESNO(successful));
+  ESP_LOGD(TAG, "TFT upload done: %s", YESNO(successful));
   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, "Changing baud rate back from %" PRIu32 " to %" PRIu32 " bps", 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();
   }
 
   if (successful) {
-    ESP_LOGD(TAG, "Restarting ESPHome");
+    ESP_LOGD(TAG, "Restart");
     delay(1500);  // NOLINT
-    arch_restart();
+    App.safe_reboot();
   } else {
-    ESP_LOGE(TAG, "Nextion TFT upload failed");
+    ESP_LOGE(TAG, "TFT upload failed");
   }
   return successful;
 }