ESPHome 2025.6.0
Loading...
Searching...
No Matches
nextion_upload_arduino.cpp
Go to the documentation of this file.
1#include "nextion.h"
2
3#ifdef USE_NEXTION_TFT_UPLOAD
4#ifdef USE_ARDUINO
5
8#include "esphome/core/util.h"
9#include "esphome/core/log.h"
11#include <cinttypes>
12
13#ifdef USE_ESP32
14#include <esp_heap_caps.h>
15#endif
16
17namespace esphome {
18namespace nextion {
19static const char *const TAG = "nextion.upload.arduino";
20
21// Followed guide
22// https://unofficialnextion.com/t/nextion-upload-protocol-v1-2-the-fast-one/1044/2
23
24inline uint32_t Nextion::get_free_heap_() {
25#if defined(USE_ESP32)
26 return heap_caps_get_free_size(MALLOC_CAP_INTERNAL);
27#elif defined(USE_ESP8266)
28 return EspClass::getFreeHeap();
29#endif // USE_ESP32 vs USE_ESP8266
30}
31
32int Nextion::upload_by_chunks_(HTTPClient &http_client, uint32_t &range_start) {
33 uint32_t range_size = this->tft_size_ - range_start;
34 ESP_LOGV(TAG, "Heap: %" PRIu32, this->get_free_heap_());
35 uint32_t range_end = ((upload_first_chunk_sent_ or this->tft_size_ < 4096) ? this->tft_size_ : 4096) - 1;
36 ESP_LOGD(TAG, "Range start: %" PRIu32, range_start);
37 if (range_size <= 0 or range_end <= range_start) {
38 ESP_LOGD(TAG, "Range end: %" PRIu32, range_end);
39 ESP_LOGD(TAG, "Range size: %" PRIu32, range_size);
40 ESP_LOGE(TAG, "Invalid range");
41 return -1;
42 }
43
44 char range_header[32];
45 sprintf(range_header, "bytes=%" PRIu32 "-%" PRIu32, range_start, range_end);
46 ESP_LOGV(TAG, "Range: %s", range_header);
47 http_client.addHeader("Range", range_header);
48 int code = http_client.GET();
49 if (code != HTTP_CODE_OK and code != HTTP_CODE_PARTIAL_CONTENT) {
50 ESP_LOGW(TAG, "HTTP failed: %s", HTTPClient::errorToString(code).c_str());
51 return -1;
52 }
53
54 // Allocate the buffer dynamically
56 uint8_t *buffer = allocator.allocate(4096);
57 if (!buffer) {
58 ESP_LOGE(TAG, "Buffer alloc failed");
59 return -1;
60 }
61
62 std::string recv_string;
63 while (true) {
64 App.feed_wdt();
65 const uint16_t buffer_size =
66 this->content_length_ < 4096 ? this->content_length_ : 4096; // Limits buffer to the remaining data
67 ESP_LOGV(TAG, "Fetch %" PRIu16 " bytes", buffer_size);
68 uint16_t read_len = 0;
69 int partial_read_len = 0;
70 const uint32_t start_time = millis();
71 while (read_len < buffer_size && millis() - start_time < 5000) {
72 if (http_client.getStreamPtr()->available() > 0) {
73 partial_read_len =
74 http_client.getStreamPtr()->readBytes(reinterpret_cast<char *>(buffer) + read_len, buffer_size - read_len);
75 read_len += partial_read_len;
76 if (partial_read_len > 0) {
77 App.feed_wdt();
78 delay(2);
79 }
80 }
81 }
82 if (read_len != buffer_size) {
83 // Did not receive the full package within the timeout period
84 ESP_LOGE(TAG, "Read failed: %" PRIu16 "/%" PRIu16 " bytes", read_len, buffer_size);
85 // Deallocate buffer
86 allocator.deallocate(buffer, 4096);
87 buffer = nullptr;
88 return -1;
89 }
90 ESP_LOGV(TAG, "Fetched %d bytes", read_len);
91 if (read_len > 0) {
92 recv_string.clear();
93 this->write_array(buffer, buffer_size);
94 App.feed_wdt();
95 this->recv_ret_string_(recv_string, upload_first_chunk_sent_ ? 500 : 5000, true);
96 this->content_length_ -= read_len;
97 const float upload_percentage = 100.0f * (this->tft_size_ - this->content_length_) / this->tft_size_;
98#if defined(USE_ESP32) && defined(USE_PSRAM)
99 ESP_LOGD(TAG, "Upload: %0.2f%% (%" PRIu32 " left, heap: %" PRIu32 "+%" PRIu32 ")", upload_percentage,
100 this->content_length_, static_cast<uint32_t>(heap_caps_get_free_size(MALLOC_CAP_INTERNAL)),
101 static_cast<uint32_t>(heap_caps_get_free_size(MALLOC_CAP_SPIRAM)));
102#else
103 ESP_LOGD(TAG, "Upload: %0.2f%% (%" PRIu32 " left, heap: %" PRIu32 ")", upload_percentage, this->content_length_,
104 this->get_free_heap_());
105#endif
107 if (recv_string[0] == 0x08 && recv_string.size() == 5) { // handle partial upload request
108 ESP_LOGD(TAG, "Recv: [%s]",
109 format_hex_pretty(reinterpret_cast<const uint8_t *>(recv_string.data()), recv_string.size()).c_str());
110 uint32_t result = 0;
111 for (int j = 0; j < 4; ++j) {
112 result += static_cast<uint8_t>(recv_string[j + 1]) << (8 * j);
113 }
114 if (result > 0) {
115 ESP_LOGI(TAG, "New range: %" PRIu32, result);
116 this->content_length_ = this->tft_size_ - result;
117 range_start = result;
118 } else {
119 range_start = range_end + 1;
120 }
121 // Deallocate buffer
122 allocator.deallocate(buffer, 4096);
123 buffer = nullptr;
124 return range_end + 1;
125 } else if (recv_string[0] != 0x05 and recv_string[0] != 0x08) { // 0x05 == "ok"
126 ESP_LOGE(TAG, "Invalid response: [%s]",
127 format_hex_pretty(reinterpret_cast<const uint8_t *>(recv_string.data()), recv_string.size()).c_str());
128 // Deallocate buffer
129 allocator.deallocate(buffer, 4096);
130 buffer = nullptr;
131 return -1;
132 }
133
134 recv_string.clear();
135 } else if (read_len == 0) {
136 ESP_LOGV(TAG, "HTTP end");
137 break; // Exit the loop if there is no more data to read
138 } else {
139 ESP_LOGE(TAG, "HTTP read failed: %d", read_len);
140 break; // Exit the loop on error
141 }
142 }
143 range_start = range_end + 1;
144 // Deallocate buffer
145 allocator.deallocate(buffer, 4096);
146 buffer = nullptr;
147 return range_end + 1;
148}
149
150bool Nextion::upload_tft(uint32_t baud_rate, bool exit_reparse) {
151 ESP_LOGD(TAG, "TFT upload requested");
152 ESP_LOGD(TAG, "Exit reparse: %s", YESNO(exit_reparse));
153 ESP_LOGD(TAG, "URL: %s", this->tft_url_.c_str());
154
155 if (this->is_updating_) {
156 ESP_LOGW(TAG, "Upload in progress");
157 return false;
158 }
159
160 if (!network::is_connected()) {
161 ESP_LOGE(TAG, "No network");
162 return false;
163 }
164
165 this->is_updating_ = true;
166
167 if (exit_reparse) {
168 ESP_LOGD(TAG, "Exit reparse mode");
169 if (!this->set_protocol_reparse_mode(false)) {
170 ESP_LOGW(TAG, "Exit reparse failed");
171 return false;
172 }
173 }
174
175 // Check if baud rate is supported
177 static const std::vector<uint32_t> SUPPORTED_BAUD_RATES = {2400, 4800, 9600, 19200, 31250, 38400, 57600,
178 115200, 230400, 250000, 256000, 512000, 921600};
179 if (std::find(SUPPORTED_BAUD_RATES.begin(), SUPPORTED_BAUD_RATES.end(), baud_rate) == SUPPORTED_BAUD_RATES.end()) {
180 baud_rate = this->original_baud_rate_;
181 }
182 ESP_LOGD(TAG, "Baud rate: %" PRIu32, baud_rate);
183
184 // Define the configuration for the HTTP client
185 ESP_LOGV(TAG, "Init HTTP client");
186 ESP_LOGV(TAG, "Heap: %" PRIu32, this->get_free_heap_());
187 HTTPClient http_client;
188 http_client.setTimeout(15000); // Yes 15 seconds.... Helps 8266s along
189
190 bool begin_status = false;
191#ifdef USE_ESP32
192 begin_status = http_client.begin(this->tft_url_.c_str());
193#endif
194#ifdef USE_ESP8266
195#if USE_ARDUINO_VERSION_CODE >= VERSION_CODE(2, 7, 0)
196 http_client.setFollowRedirects(HTTPC_STRICT_FOLLOW_REDIRECTS);
197#elif USE_ARDUINO_VERSION_CODE >= VERSION_CODE(2, 6, 0)
198 http_client.setFollowRedirects(true);
199#endif
200#if USE_ARDUINO_VERSION_CODE >= VERSION_CODE(2, 6, 0)
201 http_client.setRedirectLimit(3);
202#endif
203 begin_status = http_client.begin(*this->get_wifi_client_(), this->tft_url_.c_str());
204#endif // USE_ESP8266
205 if (!begin_status) {
206 this->is_updating_ = false;
207 ESP_LOGD(TAG, "Connection failed");
208 return false;
209 } else {
210 ESP_LOGD(TAG, "Connected");
211 }
212 http_client.addHeader("Range", "bytes=0-255");
213 const char *header_names[] = {"Content-Range"};
214 http_client.collectHeaders(header_names, 1);
215 ESP_LOGD(TAG, "URL: %s", this->tft_url_.c_str());
216 http_client.setReuse(true);
217 // try up to 5 times. DNS sometimes needs a second try or so
218 int tries = 1;
219 int code = http_client.GET();
220 delay(100); // NOLINT
221
222 App.feed_wdt();
223 while (code != 200 && code != 206 && tries <= 5) {
224 ESP_LOGW(TAG, "HTTP fail: URL: %s; Error: %s, retry %d/5", this->tft_url_.c_str(),
225 HTTPClient::errorToString(code).c_str(), tries);
226
227 delay(250); // NOLINT
228 App.feed_wdt();
229 code = http_client.GET();
230 ++tries;
231 }
232
233 if (code != 200 and code != 206) {
234 return this->upload_end_(false);
235 }
236
237 String content_range_string = http_client.header("Content-Range");
238 content_range_string.remove(0, 12);
239 this->tft_size_ = content_range_string.toInt();
240
241 ESP_LOGD(TAG, "TFT size: %zu bytes", this->tft_size_);
242 if (this->tft_size_ < 4096) {
243 ESP_LOGE(TAG, "Size check failed");
244 ESP_LOGD(TAG, "Close HTTP");
245 http_client.end();
246 ESP_LOGV(TAG, "Connection closed");
247 return this->upload_end_(false);
248 } else {
249 ESP_LOGV(TAG, "Size check OK");
250 }
251 this->content_length_ = this->tft_size_;
252
253 ESP_LOGD(TAG, "Uploading");
254
255 // The Nextion will ignore the upload command if it is sleeping
256 ESP_LOGV(TAG, "Wake-up");
257 this->ignore_is_setup_ = true;
258 this->send_command_("sleep=0");
259 this->send_command_("dim=100");
260 delay(250); // NOLINT
261 ESP_LOGV(TAG, "Heap: %" PRIu32, this->get_free_heap_());
262
263 App.feed_wdt();
264 char command[128];
265 // Tells the Nextion the content length of the tft file and baud rate it will be sent at
266 // Once the Nextion accepts the command it will wait until the file is successfully uploaded
267 // If it fails for any reason a power cycle of the display will be needed
268 sprintf(command, "whmi-wris %d,%d,1", this->content_length_, baud_rate);
269
270 // Clear serial receive buffer
271 ESP_LOGV(TAG, "Clear RX buffer");
272 this->reset_(false);
273 delay(250); // NOLINT
274 ESP_LOGV(TAG, "Heap: %" PRIu32, this->get_free_heap_());
275
276 ESP_LOGV(TAG, "Upload cmd: %s", command);
277 this->send_command_(command);
278
279 if (baud_rate != this->original_baud_rate_) {
280 ESP_LOGD(TAG, "Baud: %" PRIu32 "->%" PRIu32, this->original_baud_rate_, baud_rate);
281 this->parent_->set_baud_rate(baud_rate);
282 this->parent_->load_settings();
283 }
284
285 App.feed_wdt();
286
287 std::string response;
288 ESP_LOGV(TAG, "Wait upload resp");
289 this->recv_ret_string_(response, 5000, true); // This can take some time to return
290
291 // The Nextion display will, if it's ready to accept data, send a 0x05 byte.
292 ESP_LOGD(TAG, "Upload resp: [%s] %zu B",
293 format_hex_pretty(reinterpret_cast<const uint8_t *>(response.data()), response.size()).c_str(),
294 response.length());
295 ESP_LOGV(TAG, "Heap: %" PRIu32, this->get_free_heap_());
296
297 if (response.find(0x05) != std::string::npos) {
298 ESP_LOGV(TAG, "Upload prep done");
299 } else {
300 ESP_LOGE(TAG, "Prep failed %d '%s'", response[0], response.c_str());
301 ESP_LOGD(TAG, "Close HTTP");
302 http_client.end();
303 ESP_LOGV(TAG, "Connection closed");
304 return this->upload_end_(false);
305 }
306
307 ESP_LOGD(TAG, "Upload TFT:");
308 ESP_LOGD(TAG, " URL: %s", this->tft_url_.c_str());
309 ESP_LOGD(TAG, " Size: %d bytes", this->content_length_);
310 ESP_LOGD(TAG, " Heap: %" PRIu32, this->get_free_heap_());
311
312 // Proceed with the content download as before
313
314 ESP_LOGV(TAG, "Start chunk transfer");
315
316 uint32_t position = 0;
317 while (this->content_length_ > 0) {
318 int upload_result = upload_by_chunks_(http_client, position);
319 if (upload_result < 0) {
320 ESP_LOGE(TAG, "Upload error");
321 ESP_LOGD(TAG, "Close HTTP");
322 http_client.end();
323 ESP_LOGV(TAG, "Connection closed");
324 return this->upload_end_(false);
325 }
326 App.feed_wdt();
327 ESP_LOGV(TAG, "Heap: %" PRIu32 " left: %" PRIu32, this->get_free_heap_(), this->content_length_);
328 }
329
330 ESP_LOGD(TAG, "Upload complete");
331
332 ESP_LOGV(TAG, "Close HTTP");
333 http_client.end();
334 ESP_LOGV(TAG, "Connection closed");
335 return upload_end_(true);
336}
337
338bool Nextion::upload_end_(bool successful) {
339 ESP_LOGD(TAG, "TFT upload done: %s", YESNO(successful));
340
341 if (successful) {
342 ESP_LOGD(TAG, "Restart");
343 delay(1500); // NOLINT
345 delay(1500); // NOLINT
346 } else {
347 ESP_LOGE(TAG, "TFT upload failed");
348
349 this->is_updating_ = false;
350 this->ignore_is_setup_ = false;
351
352 uint32_t baud_rate = this->parent_->get_baud_rate();
353 if (baud_rate != this->original_baud_rate_) {
354 ESP_LOGD(TAG, "Baud back: %" PRIu32 "->%" PRIu32, baud_rate, this->original_baud_rate_);
356 this->parent_->load_settings();
357 }
358 }
359
360 return successful;
361}
362
363#ifdef USE_ESP8266
365 if (this->tft_url_.compare(0, 6, "https:") == 0) {
366 if (this->wifi_client_secure_ == nullptr) {
367 // NOLINTNEXTLINE(cppcoreguidelines-owning-memory)
368 this->wifi_client_secure_ = new BearSSL::WiFiClientSecure();
369 this->wifi_client_secure_->setInsecure();
370 this->wifi_client_secure_->setBufferSizes(512, 512);
371 }
372 return this->wifi_client_secure_;
373 }
374
375 if (this->wifi_client_ == nullptr) {
376 // NOLINTNEXTLINE(cppcoreguidelines-owning-memory)
377 this->wifi_client_ = new WiFiClient();
378 }
379 return this->wifi_client_;
380}
381#endif // USE_ESP8266
382
383} // namespace nextion
384} // namespace esphome
385
386#endif // USE_ARDUINO
387#endif // USE_NEXTION_TFT_UPLOAD
void feed_wdt(uint32_t time=0)
An STL allocator that uses SPI or internal RAM.
Definition helpers.h:684
void deallocate(T *p, size_t n)
Definition helpers.h:742
T * allocate(size_t n)
Definition helpers.h:704
uint32_t get_free_heap_()
Returns the ESP Free Heap memory.
bool send_command_(const std::string &command)
Manually send a raw command to the display and don't wait for an acknowledgement packet.
Definition nextion.cpp:29
bool ignore_is_setup_
Sends commands ignoring of the Nextion has been setup.
Definition nextion.h:1326
WiFiClient * wifi_client_
Definition nextion.h:1366
bool upload_tft(uint32_t baud_rate=0, bool exit_reparse=true)
Uploads the TFT file to the Nextion display.
bool set_protocol_reparse_mode(bool active_mode)
Sets the Nextion display's protocol reparse mode.
bool upload_end_(bool successful)
Ends the upload process, restart Nextion and, if successful, restarts ESP.
BearSSL::WiFiClientSecure * wifi_client_secure_
Definition nextion.h:1367
uint16_t recv_ret_string_(std::string &response, uint32_t timeout, bool recv_flag)
Definition nextion.cpp:947
void reset_(bool reset_nextion=true)
Definition nextion.cpp:138
int upload_by_chunks_(HTTPClient &http_client, uint32_t &range_start)
will request chunk_size chunks from the web server and send each to the nextion
virtual void load_settings(bool dump_config)
Load the UART settings.
void set_baud_rate(uint32_t baud_rate)
UARTComponent * parent_
Definition uart.h:68
void write_array(const uint8_t *data, size_t len)
Definition uart.h:21
float position
Definition cover.h:0
bool is_connected()
Return whether the node is connected to the network (through wifi, eth, ...)
Definition util.cpp:19
Providing packet encoding functions for exchanging data with a remote host.
Definition a01nyub.cpp:7
void IRAM_ATTR HOT delay(uint32_t ms)
Definition core.cpp:29
uint32_t IRAM_ATTR HOT millis()
Definition core.cpp:28
Application App
Global storage of Application pointer - only one Application can exist.
std::string format_hex_pretty(const uint8_t *data, size_t length)
Format the byte array data of length len in pretty-printed, human-readable hex.
Definition helpers.cpp:372