10 static const char *
const TAG =
"nextion";
34 ESP_LOGN(TAG,
"send_command %s", command.c_str());
37 const uint8_t to_send[3] = {0xFF, 0xFF, 0xFF};
68 if (!response.empty() && response[0] == 0x1A) {
70 ESP_LOGD(TAG,
"0x1A error ignored during setup");
73 if (response.empty() || response.find(
"comok") == std::string::npos) {
74 #ifdef NEXTION_PROTOCOL_LOG 75 ESP_LOGN(TAG,
"Bad connect request %s", response.c_str());
76 for (
size_t i = 0; i < response.length(); i++) {
77 ESP_LOGN(TAG,
"response %s %d %d %c", response.c_str(), i, response[i], response[i]);
81 ESP_LOGW(TAG,
"Nextion is not connected! ");
87 ESP_LOGI(TAG,
"Nextion is connected");
90 ESP_LOGN(TAG,
"connect request %s", response.c_str());
94 std::vector<std::string> connect_info;
95 while ((start = response.find_first_not_of(
',', end)) != std::string::npos) {
96 end = response.find(
',', start);
97 connect_info.push_back(response.substr(start, end - start));
102 ESP_LOGN(TAG,
"Received connect_info %zu", connect_info.size());
109 ESP_LOGE(TAG,
"Nextion returned bad connect value \"%s\"", response.c_str());
128 ESP_LOGCONFIG(TAG,
"Nextion:");
129 ESP_LOGCONFIG(TAG,
" Device Model: %s", this->
device_model_.c_str());
131 ESP_LOGCONFIG(TAG,
" Serial Number: %s", this->
serial_number_.c_str());
132 ESP_LOGCONFIG(TAG,
" Flash Size: %s", this->
flash_size_.c_str());
141 ESP_LOGCONFIG(TAG,
" Wake Up Page: %d", this->
wake_up_page_);
184 binarysensortype->update_component();
187 sensortype->update_component();
190 switchtype->update_component();
193 textsensortype->update_component();
203 va_start(arg, format);
204 int ret = vsnprintf(buffer,
sizeof(buffer), format, arg);
207 ESP_LOGW(TAG,
"Building command for format '%s' failed!", format);
218 #ifdef NEXTION_PROTOCOL_LOG 220 ESP_LOGN(TAG,
"print_queue_members_ (top 10) size %zu", this->
nextion_queue_.size());
221 ESP_LOGN(TAG,
"*******************************************");
228 ESP_LOGN(TAG,
"Nextion queue is null");
230 ESP_LOGN(TAG,
"Nextion queue type: %d:%s , name: %s", i->component->get_queue_type(),
231 i->component->get_queue_type_string().c_str(), i->component->get_variable_name().c_str());
234 ESP_LOGN(TAG,
"*******************************************");
276 ESP_LOGD(TAG,
"Manually set nextion report ready");
285 ESP_LOGE(TAG,
"Nextion queue is empty!");
293 ESP_LOGN(TAG,
"Removing %s from the queue", component->
get_variable_name().c_str());
320 size_t to_process_length = 0;
321 std::string to_process;
324 #ifdef NEXTION_PROTOCOL_LOG 327 while ((to_process_length = this->
command_data_.find(COMMAND_DELIMITER)) != std::string::npos) {
328 ESP_LOGN(TAG,
"print_queue_members_ size %zu", this->
nextion_queue_.size());
329 while (to_process_length + COMMAND_DELIMITER.length() < this->
command_data_.length() &&
330 static_cast<uint8_t
>(this->
command_data_[to_process_length + COMMAND_DELIMITER.length()]) == 0xFF) {
332 ESP_LOGN(TAG,
"Add extra 0xFF to process");
337 to_process_length -= 1;
338 to_process = this->
command_data_.substr(1, to_process_length);
342 ESP_LOGW(TAG,
"Nextion reported invalid instruction!");
348 ESP_LOGVV(TAG,
"instruction sent by user was successful");
349 ESP_LOGN(TAG,
"this->nextion_queue_.empty() %s", this->
nextion_queue_.empty() ?
"True" :
"False");
354 ESP_LOGD(TAG,
"Nextion is setup");
362 ESP_LOGW(TAG,
"Nextion reported component ID or name invalid!");
366 ESP_LOGW(TAG,
"Nextion reported page ID invalid!");
370 ESP_LOGW(TAG,
"Nextion reported picture ID invalid!");
374 ESP_LOGW(TAG,
"Nextion reported font ID invalid!");
378 ESP_LOGW(TAG,
"Nextion File operation fail!");
381 ESP_LOGW(TAG,
"Nextion Instructions with CRC validation fails their CRC check!");
384 ESP_LOGW(TAG,
"Nextion reported baud rate invalid!");
389 "Nextion reported invalid Waveform ID or Channel # was used but no waveform sensor in queue found!");
394 ESP_LOGW(TAG,
"Nextion reported invalid Waveform ID %d or Channel # %d was used!",
397 ESP_LOGN(TAG,
"Removing waveform from queue with component id %d and waveform id %d",
405 ESP_LOGW(TAG,
"Nextion reported variable name invalid!");
409 ESP_LOGW(TAG,
"Nextion reported variable operation invalid!");
413 ESP_LOGW(TAG,
"Nextion reported failed to assign variable!");
417 ESP_LOGW(TAG,
"Nextion reported operating EEPROM failed!");
420 ESP_LOGW(TAG,
"Nextion reported parameter quantity invalid!");
424 ESP_LOGW(TAG,
"Nextion reported component I/O operation invalid!");
427 ESP_LOGW(TAG,
"Nextion reported undefined escape characters!");
431 ESP_LOGW(TAG,
"Nextion reported too long variable name!");
435 ESP_LOGW(TAG,
"Nextion reported Serial Buffer overflow!");
438 if (to_process_length != 3) {
439 ESP_LOGW(TAG,
"Touch event data is expecting 3, received %zu", to_process_length);
443 uint8_t page_id = to_process[0];
444 uint8_t component_id = to_process[1];
445 uint8_t touch_event = to_process[2];
446 ESP_LOGD(TAG,
"Got touch event:");
447 ESP_LOGD(TAG,
" page_id: %u", page_id);
448 ESP_LOGD(TAG,
" component_id: %u", component_id);
449 ESP_LOGD(TAG,
" event type: %s", touch_event ?
"PRESS" :
"RELEASE");
450 for (
auto *touch : this->
touch_) {
451 touch->process_touch(page_id, component_id, touch_event != 0);
458 if (to_process_length != 1) {
459 ESP_LOGW(TAG,
"New page event data is expecting 1, received %zu", to_process_length);
463 uint8_t page_id = to_process[0];
464 ESP_LOGD(TAG,
"Got new page: %u", page_id);
473 if (to_process_length != 5) {
474 ESP_LOGW(TAG,
"Touch coordinate data is expecting 5, received %zu", to_process_length);
475 ESP_LOGW(TAG,
"%s", to_process.c_str());
479 uint16_t
x = (uint16_t(to_process[0]) << 8) | to_process[1];
480 uint16_t
y = (uint16_t(to_process[2]) << 8) | to_process[3];
481 uint8_t touch_event = to_process[4];
482 ESP_LOGD(TAG,
"Got touch event:");
483 ESP_LOGD(TAG,
" x: %u", x);
484 ESP_LOGD(TAG,
" y: %u", y);
485 ESP_LOGD(TAG,
" type: %s", touch_event ?
"PRESS" :
"RELEASE");
496 ESP_LOGW(TAG,
"ERROR: Received string return but the queue is empty");
504 ESP_LOGE(TAG,
"ERROR: Received string return but next in queue \"%s\" is not a text sensor",
507 ESP_LOGN(TAG,
"Received get_string response: \"%s\" for component id: %s, type: %s", to_process.c_str(),
525 ESP_LOGE(TAG,
"ERROR: Received numeric return but the queue is empty");
529 if (to_process_length == 0) {
530 ESP_LOGE(TAG,
"ERROR: Received numeric return but no data!");
538 for (
int i = 0; i < 4; ++i) {
539 value += to_process[i] << (8 * i);
549 ESP_LOGE(TAG,
"ERROR: Received numeric return but next in queue \"%s\" is not a valid sensor type %d",
552 ESP_LOGN(TAG,
"Received numeric return for variable %s, queue type %d:%s, value %d",
565 ESP_LOGVV(TAG,
"Received Nextion entering sleep automatically");
572 ESP_LOGVV(TAG,
"Received Nextion leaves sleep automatically");
580 ESP_LOGD(TAG,
"system successful start up %zu", to_process_length);
594 std::string variable_name;
597 auto index = to_process.find(
'\0');
598 if (index == std::string::npos || (to_process_length - index - 1) < 1) {
599 ESP_LOGE(TAG,
"Bad switch component data received for 0x90 event!");
600 ESP_LOGN(TAG,
"to_process %s %zu %d", to_process.c_str(), to_process_length, index);
604 variable_name = to_process.substr(0, index);
607 ESP_LOGN(TAG,
"Got Switch:");
608 ESP_LOGN(TAG,
" variable_name: %s", variable_name.c_str());
609 ESP_LOGN(TAG,
" value: %d", to_process[0] != 0);
612 switchtype->process_bool(variable_name, to_process[index] != 0);
623 std::string variable_name;
625 auto index = to_process.find(
'\0');
626 if (index == std::string::npos || (to_process_length - index - 1) != 4) {
627 ESP_LOGE(TAG,
"Bad sensor component data received for 0x91 event!");
628 ESP_LOGN(TAG,
"to_process %s %zu %d", to_process.c_str(), to_process_length, index);
632 index = to_process.find(
'\0');
633 variable_name = to_process.substr(0, index);
636 for (
int i = 0; i < 4; ++i) {
637 value += to_process[i + index + 1] << (8 * i);
640 ESP_LOGN(TAG,
"Got sensor:");
641 ESP_LOGN(TAG,
" variable_name: %s", variable_name.c_str());
642 ESP_LOGN(TAG,
" value: %d", value);
645 sensor->process_sensor(variable_name, value);
658 std::string variable_name;
659 std::string text_value;
662 auto index = to_process.find(
'\0');
663 if (index == std::string::npos || (to_process_length - index - 1) < 1) {
664 ESP_LOGE(TAG,
"Bad text sensor component data received for 0x92 event!");
665 ESP_LOGN(TAG,
"to_process %s %zu %d", to_process.c_str(), to_process_length, index);
669 variable_name = to_process.substr(0, index);
672 text_value = to_process.substr(index);
674 ESP_LOGN(TAG,
"Got Text Sensor:");
675 ESP_LOGN(TAG,
" variable_name: %s", variable_name.c_str());
676 ESP_LOGN(TAG,
" value: %s", text_value.c_str());
683 textsensortype->process_text(variable_name, text_value);
694 std::string variable_name;
697 auto index = to_process.find(
'\0');
698 if (index == std::string::npos || (to_process_length - index - 1) < 1) {
699 ESP_LOGE(TAG,
"Bad binary sensor component data received for 0x92 event!");
700 ESP_LOGN(TAG,
"to_process %s %zu %d", to_process.c_str(), to_process_length, index);
704 variable_name = to_process.substr(0, index);
707 ESP_LOGN(TAG,
"Got Binary Sensor:");
708 ESP_LOGN(TAG,
" variable_name: %s", variable_name.c_str());
709 ESP_LOGN(TAG,
" value: %d", to_process[index] != 0);
712 binarysensortype->process_bool(&variable_name[0], to_process[index] != 0);
717 ESP_LOGVV(TAG,
"Nextion reported data transmit finished!");
722 ESP_LOGVV(TAG,
"Nextion reported ready for transmit!");
724 ESP_LOGE(TAG,
"No waveforms in queue to send data!");
729 auto *component = nb->component;
730 size_t buffer_to_send = component->get_wave_buffer_size() < 255 ? component->get_wave_buffer_size()
733 this->
write_array(component->get_wave_buffer().data(),
static_cast<int>(buffer_to_send));
735 ESP_LOGN(TAG,
"Nextion sending waveform data for component id %d and waveform id %d, size %zu",
736 component->get_component_id(), component->get_wave_channel_id(), buffer_to_send);
738 component->clear_wave_buffer(buffer_to_send);
744 ESP_LOGW(TAG,
"Received unknown event from nextion: 0x%02X", this->
nextion_event_);
749 this->
command_data_.erase(0, to_process_length + COMMAND_DELIMITER.length() + 1);
761 ESP_LOGD(TAG,
"Removing old queue type \"%s\" name \"%s\" queue_time 0",
769 ESP_LOGD(TAG,
"Removing old queue type \"%s\" name \"%s\"", component->
get_queue_type_string().c_str(),
789 ESP_LOGN(TAG,
"Loop End");
799 ESP_LOGN(TAG,
"Received state:");
800 ESP_LOGN(TAG,
" variable: %s", name.c_str());
801 ESP_LOGN(TAG,
" state: %lf", state);
802 ESP_LOGN(TAG,
" queue type: %d", queue_type);
804 switch (queue_type) {
807 if (name == sensor->get_variable_name()) {
808 sensor->set_state(state,
true,
true);
816 if (name == sensor->get_variable_name()) {
817 sensor->set_state(state != 0,
true,
true);
825 if (name == sensor->get_variable_name()) {
826 sensor->set_state(state != 0,
true,
true);
833 ESP_LOGW(TAG,
"set_nextion_sensor_state does not support a queue type %d", queue_type);
839 ESP_LOGD(TAG,
"Received state:");
840 ESP_LOGD(TAG,
" variable: %s", name.c_str());
841 ESP_LOGD(TAG,
" state: %s", state.c_str());
844 if (name == sensor->get_variable_name()) {
845 sensor->set_state(state,
true,
true);
852 ESP_LOGD(TAG,
"all_components_send_state_ ");
854 if (force_update || binarysensortype->get_needs_to_send_update())
855 binarysensortype->send_state_to_nextion();
858 if ((force_update || sensortype->get_needs_to_send_update()) && sensortype->get_wave_chan_id() == 0)
859 sensortype->send_state_to_nextion();
862 if (force_update || switchtype->get_needs_to_send_update())
863 switchtype->send_state_to_nextion();
866 if (force_update || textsensortype->get_needs_to_send_update())
867 textsensortype->send_state_to_nextion();
873 if (binarysensortype->get_variable_name().find(prefix, 0) != std::string::npos)
874 binarysensortype->update_component_settings(
true);
877 if (sensortype->get_variable_name().find(prefix, 0) != std::string::npos)
878 sensortype->update_component_settings(
true);
881 if (switchtype->get_variable_name().find(prefix, 0) != std::string::npos)
882 switchtype->update_component_settings(
true);
885 if (textsensortype->get_variable_name().find(prefix, 0) != std::string::npos)
886 textsensortype->update_component_settings(
true);
893 uint8_t nr_of_ff_bytes = 0;
895 bool exit_flag =
false;
896 bool ff_flag =
false;
900 while ((timeout == 0 && this->
available()) ||
millis() - start <= timeout) {
915 if (nr_of_ff_bytes >= 3)
918 response += (char) c;
920 if (response.find(0x05) != std::string::npos) {
927 if (exit_flag || ff_flag) {
933 response = response.substr(0, response.length() - 3);
935 ret = response.length();
981 va_start(arg, format);
982 int ret = vsnprintf(buffer,
sizeof(buffer), format, arg);
985 ESP_LOGW(TAG,
"Building command for format '%s' failed!", format);
1006 va_start(arg, format);
1007 int ret = vsnprintf(buffer,
sizeof(buffer), format, arg);
1010 ESP_LOGW(TAG,
"Building command for format '%s' failed!", format);
1033 const std::string &variable_name_to_send,
int state_value) {
1038 const std::string &variable_name_to_send,
int state_value,
1039 bool is_sleep_safe) {
1060 const std::string &variable_name_to_send,
1061 const std::string &state_value) {
1066 const std::string &variable_name_to_send,
1067 const std::string &state_value,
bool is_sleep_safe) {
1072 state_value.c_str());
1123 auto *component = nb->component;
1124 size_t buffer_to_send = component->get_wave_buffer_size() < 255 ? component->get_wave_buffer_size()
1127 std::string command =
"addt " +
to_string(component->get_component_id()) +
"," +
1137 ESPDEPRECATED(
"set_wait_for_ack(bool) is deprecated and has no effect",
"v1.20")
void goto_page(const char *page)
Show the page with a given name.
bool ignore_is_setup_
Sends commands ignoring of the Nextion has been setup.
void write_str(const char *str)
void all_components_send_state_(bool force_update=false)
CallbackManager< void(uint8_t)> page_callback_
CallbackManager< void()> sleep_callback_
const float DATA
For components that import data from directly connected sensors like DHT.
void add_new_page_callback(std::function< void(uint8_t)> &&callback)
Add a callback to be notified when the nextion changes pages.
void write_array(const uint8_t *data, size_t len)
void add_wake_state_callback(std::function< void()> &&callback)
Add a callback to be notified of wake state changes.
uint8_t get_wave_channel_id()
bool send_command_printf(const char *format,...) __attribute__((format(printf
Manually send a raw formatted command to the display.
void add_no_result_to_queue_with_set(NextionComponentBase *component, int state_value) override
void add_addt_command_to_queue(NextionComponentBase *component) override
Add addt command to the queue.
bool exit_reparse_on_start_
uint32_t startup_override_ms_
void add_to_get_queue(NextionComponentBase *component) override
std::vector< NextionComponentBase * > touch_
optional< nextion_writer_t > writer_
void update_all_components()
void add_setup_state_callback(std::function< void()> &&callback)
Add a callback to be notified when the nextion completes its initialize setup.
bool sent_setup_commands_
bool send_command_(const std::string &command)
Manually send a raw command to the display and don't wait for an acknowledgement packet.
float get_setup_priority() const override
std::string serial_number_
CallbackManager< void(uint8_t, uint8_t, bool)> touch_callback_
bool void add_no_result_to_queue_with_set_internal_(const std::string &variable_name, const std::string &variable_name_to_send, int state_value, bool is_sleep_safe=false)
uint32_t IRAM_ATTR HOT millis()
virtual std::string get_queue_type_string()
void set_exit_reparse_on_start(bool exit_reparse)
Sets if Nextion should exit the active reparse mode before the "connect" command is sent...
bool nextion_reports_is_setup_
bool add_no_result_to_queue_with_printf_(const std::string &variable_name, const char *format,...) __attribute__((format(printf
Sends a formatted command to the nextion.
void add_sleep_state_callback(std::function< void()> &&callback)
Add a callback to be notified of sleep state changes.
std::string get_variable_name()
virtual void set_state_from_string(const std::string &state_value, bool publish, bool send_to_nextion)
void set_nextion_sensor_state(int queue_type, const std::string &name, float state)
Set the nextion sensor state object.
CallbackManager< void()> setup_callback_
bool read_byte(uint8_t *data)
void set_nextion_text_state(const std::string &name, const std::string &state)
void set_wait_for_ack(bool wait_for_ack)
std::deque< NextionQueue * > nextion_queue_
CallbackManager< void()> wake_callback_
void print_queue_members_()
std::string get_variable_name_to_send()
Application App
Global storage of Application pointer - only one Application can exist.
void add_no_result_to_queue_(const std::string &variable_name)
std::deque< NextionQueue * > waveform_queue_
std::string command_data_
bool remove_from_q_(bool report_empty=true)
void set_backlight_brightness(float brightness)
Set the brightness of the backlight.
std::string device_model_
bool add_no_result_to_queue_with_ignore_sleep_printf_(const std::string &variable_name, const char *format,...) __attribute__((format(printf
void set_touch_sleep_timeout(uint16_t timeout)
Set the touch sleep timeout of the display.
std::vector< NextionComponentBase * > textsensortype_
ESPDEPRECATED("set_wait_for_ack(bool) is deprecated and has no effect", "v1.20") void Nextion
void add_touch_event_callback(std::function< void(uint8_t, uint8_t, bool)> &&callback)
Add a callback to be notified when Nextion has a touch event.
void set_wake_up_page(uint8_t page_id=255)
Sets which page Nextion loads when exiting sleep mode.
uint8_t get_component_id()
std::vector< NextionComponentBase * > sensortype_
void dump_config() override
std::string to_string(int value)
void process_nextion_commands_()
std::vector< NextionComponentBase * > switchtype_
virtual NextionQueueType get_queue_type()
void set_auto_wake_on_touch(bool auto_wake)
Sets if Nextion should auto-wake from sleep when touch press occurs.
virtual void set_state_from_int(int state_value, bool publish, bool send_to_nextion)
NextionComponentBase * component
This is a workaround until we can figure out a way to get the tflite-micro idf component code availab...
bool void add_no_result_to_queue_with_command_(const std::string &variable_name, const std::string &command)
void reset_(bool reset_nextion=true)
void update_components_by_prefix(const std::string &prefix)
std::string firmware_version_
void set_variable_name(const std::string &variable_name, const std::string &variable_name_to_send="")
uint32_t touch_sleep_timeout_
void check_pending_waveform_()
uint16_t recv_ret_string_(std::string &response, uint32_t timeout, bool recv_flag)
std::function< void(Nextion &)> nextion_writer_t
std::vector< NextionComponentBase * > binarysensortype_
void set_writer(const nextion_writer_t &writer)
void IRAM_ATTR HOT delay(uint32_t ms)