diff --git a/ReleaseNotes.md b/ReleaseNotes.md index 1e1c0c5..b57acc1 100644 --- a/ReleaseNotes.md +++ b/ReleaseNotes.md @@ -99,6 +99,8 @@ packages: - Fallback to legacy forecast (attributes based) when new method (service based) fails. - Fix custom buttons icons not updating on Home page - Fix Nextion not communicating with ESPHome 2023.11.6 +- 4.1.3 patch: + - Upload TFT remove dependency to from ESPHome Nextion component   ## Details of noteworthy changes diff --git a/nspanel_blueprint.yaml b/nspanel_blueprint.yaml index 9dd5eef..3a0d3ca 100644 --- a/nspanel_blueprint.yaml +++ b/nspanel_blueprint.yaml @@ -33,7 +33,7 @@ blueprint: 🎉 Roadmap can be found here: [Roadmap](https://github.com/Blackymas/NSPanel_HA_Blueprint/labels/roadmap) - ℹ️ Version: v4.1.2 + ℹ️ Version: v4.1.3 source_url: https://github.com/Blackymas/NSPanel_HA_Blueprint/blob/main/nspanel_blueprint.yaml domain: automation @@ -3603,7 +3603,7 @@ trigger_variables: variables: ##### GENERAL ##### - blueprint_version: '4.1.2' + blueprint_version: '4.1.3' date_format_temp: !input 'date_format' #Avoid breaking change for existing users with legacy type format date_format: > diff --git a/nspanel_esphome_addon_upload_tft.yaml b/nspanel_esphome_addon_upload_tft.yaml index 512ecf7..d9592ae 100644 --- a/nspanel_esphome_addon_upload_tft.yaml +++ b/nspanel_esphome_addon_upload_tft.yaml @@ -13,6 +13,25 @@ substitutions: # nextion_update_blank_url: "https://github.com/Blackymas/NSPanel_HA_Blueprint/raw/main/custom_configuration/nspanel_blank.tft" ############################################## + ##### DON'T CHANGE THIS ##### + upload_tft_chunk_size_max: "32768" + ############################# + +external_components: + - source: github://pr#3256 # adds esp-idf support to http_request + components: + - http_request +# - source: github://pr#5484 # adds exit reparse to Nextion library +# components: +# - nextion + +##### HTTP REQUEST ##### +# Enables http client # +# for upload_tft. # +######################## +http_request: + id: httpclient + button: ##### UPDATE TFT DISPLAY ##### - name: ${device_name} Update TFT display @@ -52,10 +71,10 @@ api: display: - id: !extend disp1 - tft_url: ${nextion_update_url} + #tft_url: ${nextion_update_url} script: - - id: upload_tft + - id: upload_tft_new #NOT IN USE FOR NOW mode: single parameters: url: string @@ -79,7 +98,7 @@ script: }; ESP_LOGV(TAG, "Setting TFT url: %s", url.c_str()); - disp1->set_tft_url(url.c_str()); + //disp1->set_tft_url(url.c_str()); unsigned int upload_tries = 0; while (upload_tries < 3) { upload_tries++; @@ -89,7 +108,7 @@ script: exit_reparse->execute(); delay_seconds_(2); ESP_LOGV(TAG, "Calling upload from Nextion component"); - if (disp1->upload_tft()) id(restart_nspanel).press(); + //if (disp1->upload_tft()) id(restart_nspanel).press(); ESP_LOGD(TAG, "Turn off Nextion"); screen_power->turn_off(); delay_seconds_(3); @@ -108,3 +127,660 @@ script: restart_nspanel->press(); nextion_init->state = true; ESP_LOGV(TAG, "Finished!"); + + - id: upload_tft + mode: single + parameters: + url: string + then: + - lambda: |- + static const char *const TAG = "script.upload_tft"; + ESP_LOGD(TAG, "Starting..."); + + std::vector buffer_; + + bool is_updating_ = false; + + bool upload_first_chunk_sent_ = false; + + int content_length_ = 0; + int tft_size_ = 0; + + auto send_nextion_command = [](const std::string &command) -> bool + { + static const char *const TAG = "script.upload_tft.send_nextion_command"; + ESP_LOGD(TAG, "Sending: %s", command.c_str()); + id(tf_uart).write_str(command.c_str()); + const uint8_t to_send[3] = {0xFF, 0xFF, 0xFF}; + id(tf_uart).write_array(to_send, sizeof(to_send)); + return true; + }; + + auto recv_ret_string_ = [](std::string &response, uint32_t timeout, bool recv_flag) -> uint16_t + { + static const char *const TAG = "script.upload_tft.recv_ret_string_"; + uint16_t ret; + uint8_t c = 0; + uint8_t nr_of_ff_bytes = 0; + uint64_t start; + bool exit_flag = false; + bool ff_flag = false; + + start = millis(); + + while ((timeout == 0 && id(tf_uart).available()) || millis() - start <= timeout) + { + if (!id(tf_uart).available()) + { + App.feed_wdt(); + continue; + } + + id(tf_uart).read_byte(&c); + if (c == 0xFF) + { + nr_of_ff_bytes++; + } + else + { + nr_of_ff_bytes = 0; + ff_flag = false; + } + + if (nr_of_ff_bytes >= 3) + ff_flag = true; + + response += (char) c; + if (recv_flag) + { + if (response.find(0x05) != std::string::npos) + { + exit_flag = true; + } + } + App.feed_wdt(); + delay(2); + + if (exit_flag || ff_flag) + { + break; + } + } + + if (ff_flag) + response = response.substr(0, response.length() - 3); // Remove last 3 0xFF + + ret = response.length(); + return ret; + }; + + auto upload_end_ = [&](bool completed) -> bool + { + static const char *const TAG = "script.upload_tft.upload_end_"; + ESP_LOGD(TAG, "Completed: %i", completed ? 1 : 0); + //ESP_LOGD(TAG, "Restarting Nextion"); + //send_nextion_command("rest"); + #ifdef ARDUINO + delay(1500); + #elif defined(ESP_PLATFORM) + //vTaskDelay(pdMS_TO_TICKS(1500)); + #endif + + is_updating_ = false; + if (!completed) ESP_LOGD(TAG, "Nextion TFT upload will try again"); + return completed; + }; + + #ifdef ARDUINO // arduino # To do: Move to Nextion component on ESPHome + size_t transfer_buffer_size_ = 0; + uint8_t *transfer_buffer_{nullptr}; + auto upload_by_chunks_arduino = [&](HTTPClient *http, const std::string &url, int range_start) -> int + { + static const char *const TAG = "script.upload_tft.upload_by_chunks_arduino"; + int range_end; + + if (range_start == 0 && transfer_buffer_size_ > 16384) { // Start small at the first run in case of a big skip + range_end = 16384 - 1; + } else { + range_end = range_start + transfer_buffer_size_ - 1; + } + + if (range_end > tft_size_) + range_end = tft_size_; + + char range_header[64]; + sprintf(range_header, "bytes=%d-%d", range_start, range_end); + + ESP_LOGD(TAG, "Requesting range: %s", range_header); + + int tries = 1; + int code; + bool begin_status; + while (tries <= 10) { + begin_status = http->begin(url.c_str()); + + ++tries; + if (!begin_status) { + ESP_LOGD(TAG, "Connection failed"); + delay(1000); + continue; + }; + + http->addHeader("Range", range_header); + + code = http->GET(); + if (code == 200 || code == 206) { + break; + } + ESP_LOGW(TAG, "HTTP Request failed; URL: %s; Error: %s, retries(%d/10)", url.c_str(), + HTTPClient::errorToString(code).c_str(), tries); + http->end(); + delay(1000); + } + + if (tries > 10) { + return -1; + } + + std::string recv_string; + size_t size; + int fetched = 0; + int range = range_end - range_start; + int write_len; + + // fetch next segment from HTTP stream + while (fetched < range) { + size = http->getStreamPtr()->available(); + if (!size) { + App.feed_wdt(); + delay(2); + continue; + } + int c = http->getStreamPtr()->readBytes( + &transfer_buffer_[fetched], ((size > transfer_buffer_size_) ? transfer_buffer_size_ : size)); + fetched += c; + } + http->end(); + ESP_LOGD(TAG, "Fetched %d bytes", fetched); + + // upload fetched segments to the display in 4KB chunks + for (int i = 0; i < range; i += 4096) { + App.feed_wdt(); + write_len = content_length_ < 4096 ? content_length_ : 4096; + id(tf_uart).write_array(&transfer_buffer_[i], write_len); + content_length_ -= write_len; + ESP_LOGD(TAG, "Uploaded %0.1f %%, remaining %d bytes", + 100.0 * (tft_size_ - content_length_) / tft_size_, + content_length_); + + if (!upload_first_chunk_sent_) { + upload_first_chunk_sent_ = true; + delay(500); + } + + recv_ret_string_(recv_string, 5000, true); + if (recv_string[0] != 0x05) { // 0x05 == "ok" + ESP_LOGD(TAG, "recv_string [%s]", + format_hex_pretty(reinterpret_cast(recv_string.data()), recv_string.size()).c_str()); + } + + // handle partial upload request + if (recv_string[0] == 0x08 && recv_string.size() == 5) { + uint32_t result = 0; + for (int j = 0; j < 4; ++j) { + result += static_cast(recv_string[j + 1]) << (8 * j); + } + if (result > 0) { + ESP_LOGD(TAG, "Nextion reported new range %d", result); + content_length_ = tft_size_ - result; + return result; + } + } + + recv_string.clear(); + } + return range_end + 1; + }; + auto upload_tft_ = [&](const std::string &url, unsigned int update_baud_rate_) -> bool + { + static const char *const TAG = "script.upload_tft.upload_tft_arduino"; + ESP_LOGD(TAG, "Nextion TFT upload requested"); + ESP_LOGD(TAG, "url: %s", url.c_str()); + ESP_LOGD(TAG, "baud_rate: %i", update_baud_rate_); + + if (is_updating_) { + ESP_LOGD(TAG, "Currently updating"); + return upload_end_(false); + } + + if (!network::is_connected()) { + ESP_LOGD(TAG, "Network is not connected"); + return upload_end_(false); + } + + ESP_LOGD(TAG, "Setting Nextion protocol reparse mode to passive"); + id(disp1).set_protocol_reparse_mode(false); + + is_updating_ = true; + + HTTPClient http; + http.setTimeout(15000); // Yes 15 seconds.... Helps 8266s along + http.setFollowRedirects(HTTPC_STRICT_FOLLOW_REDIRECTS); + bool begin_status = http.begin(url.c_str()); + if (!begin_status) { + is_updating_ = false; + ESP_LOGD(TAG, "Connection failed"); + ExternalRAMAllocator allocator(ExternalRAMAllocator::ALLOW_FAILURE); + allocator.deallocate(transfer_buffer_, transfer_buffer_size_); + return upload_end_(false); + } else { + ESP_LOGD(TAG, "Connected"); + } + + http.addHeader("Range", "bytes=0-255"); + const char *header_names[] = {"Content-Range"}; + http.collectHeaders(header_names, 1); + ESP_LOGD(TAG, "Requesting URL: %s", url.c_str()); + + http.setReuse(true); + // try up to 5 times. DNS sometimes needs a second try or so + int tries = 1; + int code = http.GET(); + delay(100); + + while (code != 200 && code != 206 && tries <= 5) { + ESP_LOGW(TAG, "HTTP Request failed; URL: %s; Error: %s, retrying (%d/5)", url.c_str(), + HTTPClient::errorToString(code).c_str(), tries); + + delay(250); + code = http.GET(); + ++tries; + } + + if ((code != 200 && code != 206) || tries > 5) { + return upload_end_(false); + } + + String content_range_string = http.header("Content-Range"); + content_range_string.remove(0, 12); + content_length_ = content_range_string.toInt(); + tft_size_ = content_length_; + http.end(); + + if (content_length_ < 4096) { + ESP_LOGE(TAG, "Failed to get file size"); + return upload_end_(false); + } + + ESP_LOGD(TAG, "Updating Nextion"); + // The Nextion will ignore the update command if it is sleeping + + char command[128]; + // Tells the Nextion the content length of the tft file and baud rate it will be sent at + // Once the Nextion accepts the command it will wait until the file is successfully uploaded + // If it fails for any reason a power cycle of the display will be needed + sprintf(command, "whmi-wris %d,%d,1", content_length_, update_baud_rate_); + + // Clear serial receive buffer + uint8_t d; + while (id(tf_uart).available()) { + id(tf_uart).read_byte(&d); + }; + + send_nextion_command(command); + + if (update_baud_rate_ != id(tf_uart).get_baud_rate()) + { + id(tf_uart).set_baud_rate(update_baud_rate_); + id(tf_uart).setup(); + } + + std::string response; + ESP_LOGD(TAG, "Waiting for upgrade response"); + recv_ret_string_(response, 2000, 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]", + format_hex_pretty(reinterpret_cast(response.data()), response.size()).c_str()); + + if (response.find(0x05) != std::string::npos) { + ESP_LOGD(TAG, "Preparation for tft update done"); + } else { + ESP_LOGD(TAG, "Preparation for tft update failed %d \"%s\"", response[0], response.c_str()); + return upload_end_(false); + } + + // Nextion wants 4096 bytes at a time. Make chunk_size a multiple of 4096 + uint32_t chunk_size = 8192; + if (ESP.getFreeHeap() > 81920) { // Ensure some FreeHeap to other things and limit chunk size + chunk_size = ESP.getFreeHeap() - 65536; + chunk_size = int(chunk_size / 4096) * 4096; + chunk_size = chunk_size > ${upload_tft_chunk_size_max} ? ${upload_tft_chunk_size_max} : chunk_size; + } else if (ESP.getFreeHeap() < 32768) { + chunk_size = 4096; + } + + if (transfer_buffer_ == nullptr) { + ExternalRAMAllocator allocator(ExternalRAMAllocator::ALLOW_FAILURE); + ESP_LOGD(TAG, "Allocating buffer size %d, Heap size is %u", chunk_size, ESP.getFreeHeap()); + transfer_buffer_ = allocator.allocate(chunk_size); + if (transfer_buffer_ == nullptr) { // Try a smaller size + ESP_LOGD(TAG, "Could not allocate buffer size: %d trying 4096 instead", chunk_size); + chunk_size = 4096; + ESP_LOGD(TAG, "Allocating %d buffer", chunk_size); + transfer_buffer_ = allocator.allocate(chunk_size); + + if (!transfer_buffer_) + { + return upload_end_(false); + } + } + + transfer_buffer_size_ = chunk_size; + } + + ESP_LOGD(TAG, "Updating tft from \"%s\" with a file size of %d using %zu chunksize, Heap Size %d", + url.c_str(), content_length_, transfer_buffer_size_, ESP.getFreeHeap()); + + int result = 0; + while (content_length_ > 0) { + result = upload_by_chunks_arduino(&http, url, result); + if (result < 0) { + ESP_LOGD(TAG, "Error updating Nextion!"); + return upload_end_(false); + } + App.feed_wdt(); + ESP_LOGD(TAG, "Heap Size %d, Bytes left %d", ESP.getFreeHeap(), content_length_); + } + is_updating_ = false; + ESP_LOGD(TAG, "Successfully updated Nextion!"); + + return upload_end_(true); + }; + #elif defined(ESP_PLATFORM) // esp-idf # To do: Move to Nextion component on ESPHome + auto upload_range_esp_idf_ = [&](const std::string &url, int range_start) -> int { + static const char *const TAG = "script.upload_tft.upload_range_esp_idf_"; + ESP_LOGVV(TAG, "url: %s", url.c_str()); + uint range_size_ = tft_size_ - range_start; + ESP_LOGVV(TAG, "tft_size_: %i", tft_size_); + ESP_LOGV(TAG, "Available heap: %u", esp_get_free_heap_size()); + int range_end = (range_start == 0) ? std::min(tft_size_, 16383) : tft_size_; + if (range_size_ <= 0 or range_end <= range_start) { + ESP_LOGE(TAG, "Invalid range"); + ESP_LOGD(TAG, "Range start: %i", range_start); + ESP_LOGD(TAG, "Range end: %i", range_end); + ESP_LOGD(TAG, "Range size: %i", range_size_); + return -1; + } + + esp_http_client_config_t config = { + .url = url.c_str(), + .cert_pem = nullptr, + }; + esp_http_client_handle_t client = esp_http_client_init(&config); + + char range_header[64]; + sprintf(range_header, "bytes=%d-%d", range_start, range_end); + ESP_LOGV(TAG, "Requesting range: %s", range_header); + esp_http_client_set_header(client, "Range", range_header); + ESP_LOGVV(TAG, "Available heap: %u", esp_get_free_heap_size()); + ESP_LOGV(TAG, "Opening http connetion"); + esp_err_t err; + if ((err = esp_http_client_open(client, 0)) != ESP_OK) { + ESP_LOGE(TAG, "Failed to open HTTP connection: %s", esp_err_to_name(err)); + esp_http_client_cleanup(client); + return -1; + } + + ESP_LOGV(TAG, "Fetch content length"); + int content_length = esp_http_client_fetch_headers(client); + ESP_LOGV(TAG, "content_length = %d", content_length); + if (content_length <= 0) { + ESP_LOGE(TAG, "Failed to get content length: %d", content_length); + esp_http_client_cleanup(client); + return -1; + } + + int total_read_len = 0, read_len; + + ESP_LOGV(TAG, "Allocate buffer"); + uint8_t* buffer = new uint8_t[4096]; + std::string recv_string; + if (buffer == nullptr) { + ESP_LOGE(TAG, "Failed to allocate memory for buffer"); + ESP_LOGV(TAG, "Available heap: %u", esp_get_free_heap_size()); + } else { + ESP_LOGV(TAG, "Memory for buffer allocated successfully"); + + while (true) { + App.feed_wdt(); + ESP_LOGVV(TAG, "Available heap: %u", esp_get_free_heap_size()); + int read_len = esp_http_client_read(client, reinterpret_cast(buffer), 4096); + ESP_LOGVV(TAG, "Read %d bytes from HTTP client, writing to UART", read_len); + if (read_len > 0) { + tf_uart->write_array(buffer, read_len); + ESP_LOGVV(TAG, "Write to UART successful"); + recv_ret_string_(recv_string, 5000, true); + content_length_ -= read_len; + ESP_LOGD(TAG, "Uploaded %0.2f %%, remaining %d bytes", + 100.0 * (tft_size_ - content_length_) / tft_size_, + content_length_); + if (recv_string[0] != 0x05) { // 0x05 == "ok" + ESP_LOGD(TAG, "recv_string [%s]", + format_hex_pretty(reinterpret_cast(recv_string.data()), recv_string.size()).c_str()); + } + // handle partial upload request + if (recv_string[0] == 0x08 && recv_string.size() == 5) { + uint32_t result = 0; + for (int j = 0; j < 4; ++j) { + result += static_cast(recv_string[j + 1]) << (8 * j); + } + if (result > 0) { + ESP_LOGI(TAG, "Nextion reported new range %d", result); + content_length_ = tft_size_ - result; + // Deallocate the buffer when done + delete[] buffer; + ESP_LOGVV(TAG, "Memory for buffer deallocated"); + esp_http_client_cleanup(client); + esp_http_client_close(client); + return result; + } + } + recv_string.clear(); + } else if (read_len == 0) { + ESP_LOGV(TAG, "End of HTTP response reached"); + 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); + break; // Exit the loop on error + } + } + + // Deallocate the buffer when done + delete[] buffer; + ESP_LOGVV(TAG, "Memory for buffer deallocated"); + } + esp_http_client_cleanup(client); + esp_http_client_close(client); + return range_end + 1; + }; + auto upload_tft_ = [&](const std::string &url, unsigned int update_baud_rate_) -> bool { + static const char *const TAG = "script.upload_tft.upload_tft_esp_idf"; + ESP_LOGD(TAG, "Nextion TFT upload requested"); + ESP_LOGD(TAG, "url: %s", url.c_str()); + ESP_LOGD(TAG, "baud_rate: %i", update_baud_rate_); + + if (is_updating_) { + ESP_LOGW(TAG, "Currently updating"); + return upload_end_(false); + } + + if (!network::is_connected()) { + ESP_LOGE(TAG, "Network is not connected"); + return upload_end_(false); + } + + ESP_LOGD(TAG, "Setting Nextion protocol reparse mode to passive"); + id(disp1).set_protocol_reparse_mode(false); + + is_updating_ = true; + + // Define the configuration for the HTTP client + ESP_LOGV(TAG, "Establishing connection to HTTP server"); + ESP_LOGVV(TAG, "Available heap: %u", esp_get_free_heap_size()); + esp_http_client_config_t config = { + .url = url.c_str(), + .cert_pem = nullptr, + .method = HTTP_METHOD_HEAD, + .timeout_ms = 15000, + }; + + // Initialize the HTTP client with the configuration + ESP_LOGV(TAG, "Initializing HTTP client"); + ESP_LOGV(TAG, "Available heap: %u", esp_get_free_heap_size()); + esp_http_client_handle_t http = esp_http_client_init(&config); + if (!http) { + ESP_LOGE(TAG, "Failed to initialize HTTP client."); + return upload_end_(false); // return -1 to indicate an error + } + + // Perform the HTTP request + ESP_LOGV(TAG, "Check if the client could connect"); + ESP_LOGV(TAG, "Available heap: %u", esp_get_free_heap_size()); + esp_err_t err = esp_http_client_perform(http); + if (err != ESP_OK) { + ESP_LOGE(TAG, "HTTP request failed: %s", esp_err_to_name(err)); + esp_http_client_cleanup(http); + return upload_end_(false); + } + + // Check the HTTP Status Code + int status_code = esp_http_client_get_status_code(http); + ESP_LOGV(TAG, "HTTP Status Code: %d", status_code); + size_t tft_file_size = esp_http_client_get_content_length(http); + ESP_LOGD(TAG, "TFT file size: %zu", tft_file_size); + + if (tft_file_size < 4096) { + ESP_LOGE(TAG, "File size check failed. Size: %zu", tft_file_size); + esp_http_client_cleanup(http); + return upload_end_(false); + } else { + ESP_LOGD(TAG, "File size check passed. Proceeding..."); + } + content_length_ = tft_file_size; + tft_size_ = tft_file_size; + + ESP_LOGD(TAG, "Updating Nextion"); + // The Nextion will ignore the update command if it is sleeping + + char command[128]; + // Tells the Nextion the content length of the tft file and baud rate it will be sent at + // Once the Nextion accepts the command it will wait until the file is successfully uploaded + // If it fails for any reason a power cycle of the display will be needed + sprintf(command, "whmi-wris %d,%d,1", content_length_, update_baud_rate_); + + // Clear serial receive buffer + uint8_t d; + while (id(tf_uart).available()) { + id(tf_uart).read_byte(&d); + }; + + send_nextion_command(command); + + if (update_baud_rate_ != id(tf_uart).get_baud_rate()) + { + id(tf_uart).set_baud_rate(update_baud_rate_); + id(tf_uart).setup(); + } + + std::string response; + ESP_LOGD(TAG, "Waiting for upgrade response"); + recv_ret_string_(response, 2000, 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]", + format_hex_pretty(reinterpret_cast(response.data()), response.size()).c_str()); + + if (response.find(0x05) != std::string::npos) { + ESP_LOGV(TAG, "Preparation for tft update done"); + } else { + ESP_LOGE(TAG, "Preparation for tft update failed %d \"%s\"", response[0], response.c_str()); + esp_http_client_cleanup(http); + return upload_end_(false); + } + + ESP_LOGD(TAG, "Updating tft from \"%s\" with a file size of %d, Heap Size %d", + url.c_str(), content_length_, esp_get_free_heap_size()); + + ESP_LOGV(TAG, "Starting transfer by chunks loop"); + int result = 0; + while (content_length_ > 0) { + result = upload_range_esp_idf_(url.c_str(), result); + if (result < 0) { + ESP_LOGE(TAG, "Error updating Nextion!"); + esp_http_client_cleanup(http); + return upload_end_(false); + } + App.feed_wdt(); + ESP_LOGV(TAG, "Heap Size %d, Bytes left %d", esp_get_free_heap_size(), content_length_); + } + + is_updating_ = false; + ESP_LOGD(TAG, "Successfully updated Nextion!"); + + ESP_LOGD(TAG, "Close HTTP connection"); + esp_http_client_close(http); + esp_http_client_cleanup(http); + return upload_end_(true); + }; + #endif + + unsigned int upload_tries = 0; + while (upload_tries < 5) { + upload_tries++; + ESP_LOGD(TAG, "Try #%i", upload_tries); + if (upload_tft_(url, id(tf_uart).get_baud_rate())) id(restart_nspanel).press(); + ESP_LOGD(TAG, "Turn off Nextion"); + id(screen_power).turn_off(); + #ifdef ARDUINO + delay(1500); + #elif defined(ESP_PLATFORM) + vTaskDelay(pdMS_TO_TICKS(1500)); + #endif + ESP_LOGD(TAG, "Turn on Nextion"); + id(screen_power).turn_on(); + #ifdef ARDUINO + delay(1500); + #elif defined(ESP_PLATFORM) + vTaskDelay(pdMS_TO_TICKS(1500)); + #endif + } + unsigned int new_baud_rate; + if (id(tf_uart).get_baud_rate() == 115200) { + new_baud_rate = 921600; + } else { + new_baud_rate = 115200; + } + ESP_LOGD(TAG, "Trying again at %i bps", new_baud_rate); + if (upload_tft_(url, new_baud_rate)) { + id(restart_nspanel).press(); + } + ESP_LOGE(TAG, "TFT upload failed."); + ESP_LOGD(TAG, "Turn off Nextion"); + id(screen_power).turn_off(); + #ifdef ARDUINO + delay(1500); + #elif defined(ESP_PLATFORM) + vTaskDelay(pdMS_TO_TICKS(1500)); + #endif + ESP_LOGD(TAG, "Turn on Nextion"); + id(screen_power).turn_on(); + ESP_LOGD(TAG, "Restarting esphome"); + #ifdef ARDUINO + delay(1500); + #elif defined(ESP_PLATFORM) + vTaskDelay(pdMS_TO_TICKS(1500)); + #endif + id(restart_nspanel).press(); + + ESP_LOGD(TAG, "Finished!"); \ No newline at end of file diff --git a/nspanel_esphome_core.yaml b/nspanel_esphome_core.yaml index 037f55b..9cec649 100644 --- a/nspanel_esphome_core.yaml +++ b/nspanel_esphome_core.yaml @@ -7,13 +7,13 @@ substitutions: ##### DON'T CHANGE THIS ##### - version: "4.1.2" + version: "4.1.3" ############################# -external_components: - - source: github://pr#5825 # Remove this when that pr is merged and released - components: - - nextion +#external_components: +# - source: github://pr#5825 # Remove this when that pr is merged and released +# components: +# - nextion ##### ESPHOME CONFIGURATION ##### esphome: @@ -37,7 +37,7 @@ esphome: - script.execute: exit_reparse - wait_until: condition: - - lambda: !lambda return disp1->is_detected(); + - lambda: !lambda return disp1->is_setup(); timeout: 20s - lambda: |- static const char *const TAG = "on_boot"; @@ -55,7 +55,7 @@ esphome: }; nextion_status->execute(); - if (not disp1->is_detected()) { + if (not disp1->is_setup()) { ESP_LOGE(TAG, "No response from Nextion display"); ESP_LOGD(TAG, "Turn off Nextion"); screen_power->turn_off(); @@ -67,12 +67,12 @@ esphome: } - wait_until: condition: - - lambda: !lambda return disp1->is_detected(); + - lambda: !lambda return disp1->is_setup(); timeout: 20s - lambda: |- static const char *const TAG = "on_boot"; nextion_status->execute(); - if (not disp1->is_detected()) { + if (not disp1->is_setup()) { ESP_LOGE(TAG, "No response from Nextion display"); } ESP_LOGD(TAG, "Finished"); @@ -1349,7 +1349,7 @@ switch: on_turn_on: - wait_until: condition: - - lambda: !lambda return disp1->is_detected(); + - lambda: !lambda return disp1->is_setup(); timeout: 20s - lambda: |- if (id(boot_sequence_completed)) { @@ -2651,7 +2651,7 @@ script: - lambda: |- static const char *const TAG = "script.nextion_status"; ESP_LOGD(TAG, "Nextion status:"); - ESP_LOGD(TAG, " Is detected: %s", disp1->is_detected() ? "True" : "False"); + //ESP_LOGD(TAG, " Is detected: %s", disp1->is_detected() ? "True" : "False"); ESP_LOGD(TAG, " Is setup: %s", disp1->is_setup() ? "True" : "False"); ##### ADD-ONS ############################################################ diff --git a/nspanel_eu.HMI b/nspanel_eu.HMI index c6bb6ce..e495a49 100644 Binary files a/nspanel_eu.HMI and b/nspanel_eu.HMI differ diff --git a/nspanel_eu.tft b/nspanel_eu.tft index bae77b6..d551324 100644 Binary files a/nspanel_eu.tft and b/nspanel_eu.tft differ diff --git a/nspanel_eu_code/boot.txt b/nspanel_eu_code/boot.txt index b66ec4e..dab95f5 100644 --- a/nspanel_eu_code/boot.txt +++ b/nspanel_eu_code/boot.txt @@ -142,7 +142,7 @@ Text tft_version Dragging : 0 Send Component ID : disabled Associated Keyboard: none - Text : 4.1.2 + Text : 4.1.3 Max. Text Size : 9 Text esph_version diff --git a/nspanel_us.HMI b/nspanel_us.HMI index 54655ef..511511b 100644 Binary files a/nspanel_us.HMI and b/nspanel_us.HMI differ diff --git a/nspanel_us.tft b/nspanel_us.tft index 0686387..63e7e5e 100644 Binary files a/nspanel_us.tft and b/nspanel_us.tft differ diff --git a/nspanel_us_code/boot.txt b/nspanel_us_code/boot.txt index b66ec4e..dab95f5 100644 --- a/nspanel_us_code/boot.txt +++ b/nspanel_us_code/boot.txt @@ -142,7 +142,7 @@ Text tft_version Dragging : 0 Send Component ID : disabled Associated Keyboard: none - Text : 4.1.2 + Text : 4.1.3 Max. Text Size : 9 Text esph_version diff --git a/nspanel_us_land.HMI b/nspanel_us_land.HMI index db78de0..21fbc40 100644 Binary files a/nspanel_us_land.HMI and b/nspanel_us_land.HMI differ diff --git a/nspanel_us_land.tft b/nspanel_us_land.tft index f137e5e..4be1c69 100644 Binary files a/nspanel_us_land.tft and b/nspanel_us_land.tft differ diff --git a/nspanel_us_land_code/boot.txt b/nspanel_us_land_code/boot.txt index b66ec4e..dab95f5 100644 --- a/nspanel_us_land_code/boot.txt +++ b/nspanel_us_land_code/boot.txt @@ -142,7 +142,7 @@ Text tft_version Dragging : 0 Send Component ID : disabled Associated Keyboard: none - Text : 4.1.2 + Text : 4.1.3 Max. Text Size : 9 Text esph_version