557 lines
20 KiB
YAML
557 lines
20 KiB
YAML
#####################################################################################################
|
|
##### NSPANEL ESPHOME created by Blackymas - https://github.com/Blackymas/NSPanel_HA_Blueprint #####
|
|
##### TFT Upload engine #####
|
|
##### PLEASE only make changes if it is necessary and also the required knowledge is available. #####
|
|
##### For normal use with the Blueprint, no changes are necessary. #####
|
|
#####################################################################################################
|
|
##### ATTENTION: This will add advanced elements to the core system and requires the core part. #####
|
|
#####################################################################################################
|
|
---
|
|
substitutions:
|
|
################## Defaults ##################
|
|
# Just in case user forgets to set something #
|
|
nextion_update_url: "https://raw.githubusercontent.com/Blackymas/NSPanel_HA_Blueprint/main/nspanel_eu.tft"
|
|
nextion_update_base_url: "https://raw.githubusercontent.com/Blackymas/NSPanel_HA_Blueprint/"
|
|
##############################################
|
|
|
|
##### DON'T CHANGE THIS #####
|
|
upload_tft_chunk_size_max: "32768"
|
|
upload_tft_baud_rate: "921600"
|
|
#############################
|
|
|
|
api:
|
|
on_client_connected:
|
|
- script.execute: report_settings
|
|
|
|
services:
|
|
##### SERVICE TO UPDATE THE TFT FILE from URL #####
|
|
##### It will use the default url if url is empty or "default"
|
|
- service: upload_tft_url
|
|
variables:
|
|
url: string
|
|
then:
|
|
- lambda: |-
|
|
static const char *const TAG = "addon_upload_tft.service.upload_tft_url";
|
|
ESP_LOGVV(TAG, "Starting...");
|
|
|
|
std::string clean_url = url;
|
|
// Convert to lowercase
|
|
std::transform(clean_url.begin(), clean_url.end(), clean_url.begin(),
|
|
[](unsigned char c){ return std::tolower(c); });
|
|
// Trim trailing spaces
|
|
auto endPos = clean_url.find_last_not_of(" \t");
|
|
if (std::string::npos != endPos) {
|
|
clean_url = clean_url.substr(0, endPos + 1);
|
|
}
|
|
|
|
if (clean_url.empty() or clean_url == "default") url = id(tft_url);
|
|
upload_tft->execute(url.c_str());
|
|
|
|
button:
|
|
##### UPDATE TFT DISPLAY #####
|
|
- id: tft_update
|
|
name: Update TFT display
|
|
platform: template
|
|
icon: mdi:file-sync
|
|
entity_category: config
|
|
on_press:
|
|
- lambda: |-
|
|
static const char *const TAG = "addon_upload_tft.button.tft_update.on_press";
|
|
ESP_LOGD(TAG, "Update TFT display button pressed");
|
|
upload_tft->execute(id(tft_url).c_str());
|
|
|
|
display:
|
|
- id: !extend disp1
|
|
tft_url: ${nextion_update_url}
|
|
exit_reparse_on_start: true
|
|
|
|
esphome:
|
|
on_boot:
|
|
- priority: 601.0
|
|
then:
|
|
- lambda: |-
|
|
// Hide TFT file selectors when using arduino
|
|
#ifdef ARDUINO
|
|
tft_file_branch->set_internal(true);
|
|
tft_file_model->set_internal(true);
|
|
#elif defined(ESP_PLATFORM)
|
|
tft_file_branch->set_internal(false);
|
|
tft_file_model->set_internal(false);
|
|
#endif
|
|
|
|
globals:
|
|
- id: baud_rate_original
|
|
type: uint
|
|
restore_value: false
|
|
initial_value: '115200'
|
|
|
|
- id: baud_rate_target
|
|
type: uint
|
|
restore_value: false
|
|
initial_value: ${upload_tft_baud_rate}
|
|
|
|
#- id: tft_branch
|
|
# type: uint
|
|
# restore_value: true
|
|
# initial_value: '0'
|
|
|
|
- id: tft_is_valid
|
|
type: bool
|
|
restore_value: false
|
|
initial_value: 'false'
|
|
|
|
#- id: tft_model
|
|
# type: uint
|
|
# restore_value: true
|
|
# initial_value: '0'
|
|
|
|
- id: tft_upload_attempt
|
|
type: uint
|
|
restore_value: false
|
|
initial_value: '0'
|
|
|
|
- id: tft_url
|
|
type: std::string
|
|
restore_value: false
|
|
initial_value: '"${nextion_update_url}"'
|
|
|
|
script:
|
|
- id: nextion_uart_command
|
|
mode: queued
|
|
parameters:
|
|
command: string
|
|
then:
|
|
- lambda: |-
|
|
static const char *const TAG = "addon_upload_tft.script.nextion_uart_command";
|
|
if (disp1->is_setup()) {
|
|
ESP_LOGD(TAG, "Sending `%s` directly to Nextion", command.c_str());
|
|
disp1->send_command_printf(command.c_str());
|
|
} else {
|
|
ESP_LOGD(TAG, "Sending `%s` directly to UART", command.c_str());
|
|
tf_uart->write_str(command.c_str());
|
|
const uint8_t to_send[3] = {0xFF, 0xFF, 0xFF};
|
|
tf_uart->write_array(to_send, sizeof(to_send));
|
|
}
|
|
App.feed_wdt();
|
|
|
|
- id: nextion_upload
|
|
mode: single
|
|
then:
|
|
- lambda: |-
|
|
static const char *const TAG = "addon_upload_tft.script.nextion_upload";
|
|
ESP_LOGD(TAG, "Waiting for empty UART and Nextion queues");
|
|
- wait_until:
|
|
condition:
|
|
- lambda: !lambda return (disp1->queue_size()<=0);
|
|
- lambda: !lambda return (tf_uart->available()<=0);
|
|
timeout: 10s
|
|
- delay: 2s
|
|
- lambda: |-
|
|
static const char *const TAG = "addon_upload_tft.script.nextion_upload";
|
|
ESP_LOGD(TAG, "Starting TFT upload...");
|
|
esphome::nextion::Nextion::TFTUploadResult upload_result = disp1->upload_tft();
|
|
if (upload_result == esphome::nextion::Nextion::TFTUploadResult::OK)
|
|
App.safe_reboot();
|
|
else
|
|
ESP_LOGE(TAG, "TFT upload failed: %s", esphome::nextion::Nextion::TFTUploadResultToString(upload_result));
|
|
|
|
- id: open_upload_dialog
|
|
mode: restart
|
|
then:
|
|
- lambda: |-
|
|
static const char *const TAG = "addon_upload_tft.script.open_upload_dialog";
|
|
ESP_LOGD(TAG, "Showing upload dialog page");
|
|
disp1->goto_page("confirm");
|
|
disp1->hide_component("bt_close");
|
|
disp1->hide_component("bt_accept");
|
|
disp1->hide_component("bt_clear");
|
|
disp1->hide_component("bt_close");
|
|
#ifdef ARDUINO
|
|
disp1->set_component_text_printf("confirm.title", "Upload TFT\\rArduino");
|
|
#elif defined(ESP_PLATFORM)
|
|
disp1->set_component_text_printf("confirm.title", "Upload TFT\\rESP-IDF");
|
|
#endif
|
|
page_id->update();
|
|
|
|
- id: report_settings
|
|
mode: restart
|
|
then:
|
|
- delay: 15s
|
|
- lambda: |-
|
|
static const char *const TAG = "addon_upload_tft.script.report_settings";
|
|
ESP_LOGI(TAG, "TFT URL: %s", id(tft_url).c_str());
|
|
ESP_LOGI(TAG, "Substitutions:");
|
|
ESP_LOGI(TAG, " nextion_update_url: ${nextion_update_url}");
|
|
ESP_LOGI(TAG, " nextion_update_base_url: ${nextion_update_base_url}");
|
|
ESP_LOGI(TAG, " upload_tft_chunk_size_max: ${upload_tft_chunk_size_max}");
|
|
ESP_LOGI(TAG, " upload_tft_baud_rate: ${upload_tft_baud_rate}");
|
|
|
|
- id: report_upload_progress
|
|
mode: restart
|
|
parameters:
|
|
message: string
|
|
then:
|
|
- lambda: |-
|
|
static const char *const TAG = "addon_upload_tft.script.report_upload_progress";
|
|
ESP_LOGD(TAG, "%s", message.c_str());
|
|
if (id(tft_is_valid)) {
|
|
if (page_id->state != 26) {
|
|
open_upload_dialog->execute();
|
|
}
|
|
display_wrapped_text->execute("confirm.body", message.c_str(), 18);
|
|
disp1->set_backlight_brightness(1);
|
|
App.feed_wdt();
|
|
}
|
|
|
|
- id: !extend restore_settings
|
|
mode: restart
|
|
then:
|
|
- lambda: |-
|
|
static const char *const TAG = "addon_upload_tft.script.restore_settings";
|
|
|
|
// ESP_LOGD(TAG, "Restoring TFT file branch selector to index %u", id(tft_branch));
|
|
// auto tft_file_branch_call = id(tft_file_branch).make_call();
|
|
// tft_file_branch_call.set_index(id(tft_branch));
|
|
// tft_file_branch_call.perform();
|
|
|
|
// ESP_LOGD(TAG, "Restoring TFT file model selector to index %u", id(tft_model));
|
|
// auto tft_file_model_call = id(tft_file_model).make_call();
|
|
// tft_file_model_call.set_index(id(tft_model));
|
|
// tft_file_model_call.perform();
|
|
|
|
- id: set_tft_file
|
|
mode: restart
|
|
then:
|
|
- delay: 2s
|
|
- lambda: |-
|
|
#ifdef ARDUINO
|
|
static const char *const TAG = "addon_upload_tft.script.set_tft_file.arduino";
|
|
#elif defined(ESP_PLATFORM)
|
|
static const char *const TAG = "addon_upload_tft.script.set_tft_file.esp_idf";
|
|
#endif
|
|
std::string branch = tft_file_branch->state;
|
|
std::string model = tft_file_model->state;
|
|
ESP_LOGD(TAG, "TFT URL set:");
|
|
ESP_LOGD(TAG, " Branch: %s", branch.c_str());
|
|
ESP_LOGD(TAG, " Model: %s", model.c_str());
|
|
// if (id(is_restored_settings) and tft_file_branch->active_index().has_value())
|
|
// id(tft_branch) = tft_file_branch->active_index().value();
|
|
// if (id(is_restored_settings) and tft_file_model->active_index().has_value())
|
|
// id(tft_model) = tft_file_model->active_index().value();
|
|
|
|
if (id(is_uploading_tft))
|
|
ESP_LOGW(TAG, " TFT Upload in progress.");
|
|
else {
|
|
#ifdef ARDUINO
|
|
std::string url = "${nextion_update_url}";
|
|
#elif defined(ESP_PLATFORM)
|
|
std::string url;
|
|
std::string file_name;
|
|
if (model == "NSPanel Blank") file_name = "nspanel_blank.tft";
|
|
else if (model == "NSPanel EU") file_name = "nspanel_eu.tft";
|
|
else if (model == "NSPanel US") file_name = "nspanel_us.tft";
|
|
else if (model == "NSPanel US Landscape") file_name = "nspanel_us_land.tft";
|
|
else if (model == "NSPanel EU (CJK languages)") file_name = "advanced/hmi/nspanel_CJK_eu.tft";
|
|
else if (model == "NSPanel US (CJK languages)") file_name = "advanced/hmi/nspanel_CJK_us.tft";
|
|
else if (model == "NSPanel US Landscape (CJK languages)") file_name = "advanced/hmi/nspanel_CJK_us_land.tft";
|
|
if (file_name.empty()) url = "${nextion_update_url}";
|
|
else {
|
|
std::string base_url("${nextion_update_base_url}");
|
|
url = base_url + branch + "/" + file_name;
|
|
|
|
// Remove trailing slashes or spaces
|
|
auto endPos = url.find_last_not_of(" /");
|
|
if (std::string::npos != endPos) {
|
|
url = url.substr(0, endPos + 1);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
ESP_LOGD(TAG, " Full URL: %s", url.c_str());
|
|
id(tft_url) = url;
|
|
disp1->set_tft_url(url.c_str());
|
|
}
|
|
|
|
- id: upload_tft # I've changed this to use ESPHome commands to avoid the parallelism from lambdas
|
|
mode: single
|
|
parameters:
|
|
url: string
|
|
then:
|
|
# Make sure the screen is ON
|
|
- if:
|
|
condition:
|
|
- switch.is_off: screen_power
|
|
then:
|
|
- switch.turn_on: screen_power
|
|
- delay: 5s
|
|
# Wait for recent changes to TFT url
|
|
- script.wait: set_tft_file
|
|
# Then start the upload
|
|
- lambda: |-
|
|
static const char *const TAG = "addon_upload_tft.script.upload_tft";
|
|
ESP_LOGD(TAG, "Starting...");
|
|
|
|
id(is_uploading_tft) = true;
|
|
|
|
nextion_status->execute();
|
|
|
|
uint32_t supported_baud_rates[] = {2400, 4800, 9600, 19200, 31250, 38400, 57600, 115200, 230400, 250000, 256000, 512000, 921600};
|
|
|
|
auto is_baud_rate_supported = [supported_baud_rates](uint32_t baud_rate_requested) -> bool {
|
|
size_t size = sizeof(supported_baud_rates) / sizeof(supported_baud_rates[0]);
|
|
for (size_t i = 0; i < size; ++i) {
|
|
if (supported_baud_rates[i] == baud_rate_requested) {
|
|
return true;
|
|
}
|
|
}
|
|
return false; // Return false if not found
|
|
};
|
|
|
|
// The upload process starts here
|
|
ESP_LOGD(TAG, "Starting the upload script");
|
|
|
|
// Detect baud rates to be used
|
|
id(baud_rate_original) = tf_uart->get_baud_rate();
|
|
if (!is_baud_rate_supported(id(baud_rate_original))) id(baud_rate_original) = 115200;
|
|
|
|
std::string upload_tft_baud_rate_string = "${upload_tft_baud_rate}";
|
|
id(baud_rate_target) = stoi(upload_tft_baud_rate_string);
|
|
if (!is_baud_rate_supported(id(baud_rate_target))) id(baud_rate_target) = id(baud_rate_original);
|
|
|
|
ESP_LOGD(TAG, " Target upload baud rate: %d bps", id(baud_rate_target));
|
|
ESP_LOGD(TAG, " Current baud rate: %" PRIu32 " bps", tf_uart->get_baud_rate());
|
|
ESP_LOGD(TAG, " Valid TFT: %s", YESNO(id(tft_is_valid)));
|
|
|
|
// Upload URL
|
|
ESP_LOGD(TAG, " Upload URL: %s", url.c_str());
|
|
#ifdef ARDUINO
|
|
auto startsWith = [](const std::string& str, const std::string& prefix) -> bool {
|
|
if (str.length() < prefix.length()) return false;
|
|
|
|
std::string lowerStr = str.substr(0, prefix.length());
|
|
std::transform(lowerStr.begin(), lowerStr.end(), lowerStr.begin(),
|
|
[](unsigned char c){ return std::tolower(c); });
|
|
|
|
std::string lowerPrefix = prefix;
|
|
std::transform(lowerPrefix.begin(), lowerPrefix.end(), lowerPrefix.begin(),
|
|
[](unsigned char c){ return std::tolower(c); });
|
|
|
|
return lowerStr == lowerPrefix;
|
|
};
|
|
|
|
if (startsWith(url, "https")) {
|
|
ESP_LOGE(TAG, "HTTPS is not supported by Arduino framework.");
|
|
ESP_LOGE(TAG, "This transfer will most likely fail.");
|
|
ESP_LOGE(TAG, "Please use HTTP instead.");
|
|
}
|
|
#endif
|
|
disp1->set_tft_url(url.c_str());
|
|
|
|
nextion_uart_command->execute("bkcmd=3");
|
|
|
|
- lambda: if (id(tft_is_valid)) disp1->goto_page("home");
|
|
- delay: 2s
|
|
- script.execute: open_upload_dialog
|
|
- script.wait: open_upload_dialog
|
|
- lambda: page_id->update();
|
|
- wait_until:
|
|
condition:
|
|
- lambda: !lambda return (page_id->state == 26);
|
|
timeout: 2s
|
|
- script.execute:
|
|
id: report_upload_progress
|
|
message: "Set Nextion unavailable for blueprint calls"
|
|
- script.wait: report_upload_progress
|
|
- binary_sensor.template.publish:
|
|
id: nextion_init
|
|
state: false
|
|
- script.execute:
|
|
id: report_upload_progress
|
|
message: "Stopping other scripts"
|
|
- script.wait: report_upload_progress
|
|
- script.execute: stop_all
|
|
- script.wait: stop_all
|
|
- wait_until:
|
|
condition:
|
|
- lambda: !lambda return (!id(tft_is_valid));
|
|
timeout: 1s
|
|
|
|
### Attempt twice at the target baud rate
|
|
- script.execute:
|
|
id: upload_tft_sequence_attempt
|
|
baud_rate: !lambda return id(baud_rate_target);
|
|
- script.wait: upload_tft_sequence_attempt
|
|
|
|
### Attempt twice at the original baud rate
|
|
- if:
|
|
condition:
|
|
- lambda: |-
|
|
return (id(baud_rate_original) != id(baud_rate_target));
|
|
then:
|
|
- script.execute:
|
|
id: upload_tft_sequence_attempt
|
|
baud_rate: !lambda return id(baud_rate_original);
|
|
- script.wait: upload_tft_sequence_attempt
|
|
|
|
### Attempt twice at the Nextion's default baud rate (115200bps)
|
|
- if:
|
|
condition:
|
|
- lambda: |-
|
|
return (id(baud_rate_original) != 115200 and id(baud_rate_target) != 115200);
|
|
then:
|
|
- script.execute:
|
|
id: upload_tft_sequence_attempt
|
|
baud_rate: 115200
|
|
- script.wait: upload_tft_sequence_attempt
|
|
|
|
### Restart Nextion and attempt twice again at default baud rate (115200bps)
|
|
- script.execute:
|
|
id: report_upload_progress
|
|
message: "Restarting Nextion display"
|
|
- script.wait: report_upload_progress
|
|
- wait_until:
|
|
condition:
|
|
- lambda: !lambda return (!id(tft_is_valid));
|
|
timeout: 3s
|
|
- switch.turn_off: screen_power
|
|
- delay: 2s
|
|
- switch.turn_on: screen_power
|
|
- delay: 5s
|
|
- script.execute:
|
|
id: upload_tft_sequence_attempt
|
|
baud_rate: 115200
|
|
- script.wait: upload_tft_sequence_attempt
|
|
|
|
### All tries failed ###
|
|
- script.execute:
|
|
id: report_upload_progress
|
|
message: "TFT upload failed"
|
|
- script.wait: report_upload_progress
|
|
- wait_until:
|
|
condition:
|
|
- lambda: !lambda return (!id(tft_is_valid));
|
|
timeout: 5s
|
|
- script.execute:
|
|
id: report_upload_progress
|
|
message: "Turn off Nextion and restart ESPHome"
|
|
- script.wait: report_upload_progress
|
|
- wait_until:
|
|
condition:
|
|
- lambda: !lambda return (!id(tft_is_valid));
|
|
timeout: 5s
|
|
- switch.turn_off: screen_power
|
|
- delay: 2s
|
|
# Restart ESPHome
|
|
- lambda: !lambda App.safe_reboot();
|
|
|
|
### This code should never run
|
|
- delay: 2s
|
|
- lambda: |-
|
|
static const char *const TAG = "addon_upload_tft.script.upload_tft";
|
|
ESP_LOGD(TAG, "Finishing...");
|
|
id(is_uploading_tft) = false;
|
|
screen_power->publish_state(true);
|
|
ESP_LOGE(TAG, "TFT upload finished unsuccessfully!");
|
|
|
|
- id: upload_tft_sequence_attempt
|
|
mode: single
|
|
parameters:
|
|
baud_rate: uint
|
|
then:
|
|
- script.execute: nextion_status
|
|
- script.wait: nextion_status
|
|
- script.execute:
|
|
id: report_upload_progress
|
|
message: "Setting baud rate"
|
|
- script.wait: report_upload_progress
|
|
- script.execute:
|
|
id: set_baud_rate
|
|
baud_rate: !lambda return baud_rate;
|
|
definitive: false
|
|
- script.wait: set_baud_rate
|
|
- delay: 2s
|
|
- repeat:
|
|
count: 2
|
|
then:
|
|
# First attempt
|
|
- script.execute: upload_tft_attempt
|
|
- script.wait: upload_tft_attempt
|
|
- delay: 5s
|
|
|
|
- id: upload_tft_attempt
|
|
mode: single
|
|
then:
|
|
- logger.log: "Attempting to upload TFT"
|
|
- lambda: !lambda id(tft_upload_attempt)++;
|
|
- lambda: |-
|
|
char update_msg[128];
|
|
sprintf(update_msg, "Attempt #%d at %" PRIu32 " bps", id(tft_upload_attempt), tf_uart->get_baud_rate());
|
|
report_upload_progress->execute(update_msg);
|
|
- script.wait: report_upload_progress
|
|
- wait_until:
|
|
condition:
|
|
- lambda: !lambda return (!id(tft_is_valid));
|
|
timeout: 1s
|
|
- script.execute: nextion_upload
|
|
- script.wait: nextion_upload
|
|
- lambda: |-
|
|
char update_msg[128];
|
|
sprintf(update_msg, "Attempt #%d at %" PRIu32 " bps failed!", id(tft_upload_attempt), tf_uart->get_baud_rate());
|
|
report_upload_progress->execute(update_msg);
|
|
- script.wait: report_upload_progress
|
|
|
|
select:
|
|
- id: tft_file_branch
|
|
name: Update TFT display - Branch
|
|
platform: template
|
|
options:
|
|
- "v${version}"
|
|
- "beta"
|
|
- "dev"
|
|
initial_option: "v${version}"
|
|
optimistic: true
|
|
restore_value: false
|
|
internal: true
|
|
entity_category: config
|
|
disabled_by_default: true
|
|
icon: mdi:file-sync
|
|
on_value:
|
|
- script.execute: set_tft_file
|
|
|
|
- id: tft_file_model
|
|
name: Update TFT display - Model
|
|
platform: template
|
|
options:
|
|
- "Use nextion_update_url"
|
|
- "NSPanel Blank"
|
|
- "NSPanel EU"
|
|
- "NSPanel US"
|
|
- "NSPanel US Landscape"
|
|
- "NSPanel EU (CJK languages)"
|
|
- "NSPanel US (CJK languages)"
|
|
- "NSPanel US Landscape (CJK languages)"
|
|
initial_option: "Use nextion_update_url"
|
|
optimistic: true
|
|
restore_value: true
|
|
internal: true
|
|
entity_category: config
|
|
disabled_by_default: false
|
|
icon: mdi:file-sync
|
|
on_value:
|
|
- script.execute: set_tft_file
|
|
|
|
sensor:
|
|
- id: !extend display_mode
|
|
on_value:
|
|
then:
|
|
lambda: |-
|
|
static const char *const TAG = "addon_upload_tft.sensor.display_mode";
|
|
id(tft_is_valid) = (display_mode->state > 0 and display_mode->state < 4);
|
|
if (id(tft_is_valid))
|
|
ESP_LOGD(TAG, "Valid TFT: True");
|
|
else {
|
|
ESP_LOGW(TAG, "Display mode: %i", int(display_mode->state));
|
|
ESP_LOGW(TAG, "Valid TFT: False");
|
|
}
|
|
...
|