nextion.h

Go to the documentation of this file.

#pragma once

#include <deque>
#include <vector>

#include "esphome/core/defines.h"
#include "esphome/core/time.h"

#include "esphome/components/uart/uart.h"
#include "nextion_base.h"
#include "nextion_component.h"
#include "esphome/components/display/display_color_utils.h"

#ifdef USE_NEXTION_TFT_UPLOAD
#ifdef USE_ARDUINO
#ifdef USE_ESP32
#include <HTTPClient.h>
#endif  // USE_ESP32
#ifdef USE_ESP8266
#include <ESP8266HTTPClient.h>
#include <WiFiClientSecure.h>
#endif  // USE_ESP8266
#elif defined(USE_ESP_IDF)
#include <esp_http_client.h>
#endif  // ARDUINO vs USE_ESP_IDF
#endif  // USE_NEXTION_TFT_UPLOAD

namespace esphome {
namespace nextion {

class Nextion;
class NextionComponentBase;

using nextion_writer_t = std::function<void(Nextion &)>;

static const std::string COMMAND_DELIMITER{static_cast<char>(255), static_cast<char>(255), static_cast<char>(255)};

class Nextion : public NextionBase, public PollingComponent, public uart::UARTDevice {
 public:
  void set_component_text(const char *component, const char *text);

  void set_component_text_printf(const char *component, const char *format, ...) __attribute__((format(printf, 3, 4)));

  void set_component_value(const char *component, int32_t value);

  void set_component_picture(const char *component, uint8_t picture_id);

  void set_component_background_color(const char *component, uint16_t color);

  void set_component_background_color(const char *component, const char *color);

  void set_component_background_color(const char *component, Color color) override;

  void set_component_pressed_background_color(const char *component, uint16_t color);

  void set_component_pressed_background_color(const char *component, const char *color);

  void set_component_pressed_background_color(const char *component, Color color) override;

  void set_component_foreground_color(const char *component, uint16_t color);

  void set_component_foreground_color(const char *component, const char *color);

  void set_component_foreground_color(const char *component, Color color) override;

  void set_component_pressed_foreground_color(const char *component, uint16_t color);

  void set_component_pressed_foreground_color(const char *component, const char *color);

  void set_component_pressed_foreground_color(const char *component, Color color) override;

  void set_component_pic(const char *component, uint8_t pic_id);

  void set_component_picc(const char *component, uint8_t pic_id);

  void set_component_font_color(const char *component, uint16_t color);

  void set_component_font_color(const char *component, const char *color);

  void set_component_font_color(const char *component, Color color) override;

  void set_component_pressed_font_color(const char *component, uint16_t color);

  void set_component_pressed_font_color(const char *component, const char *color);

  void set_component_pressed_font_color(const char *component, Color color) override;

  void set_component_coordinates(const char *component, uint16_t x, uint16_t y);

  void set_component_font(const char *component, uint8_t font_id) override;

  void set_nextion_rtc_time(ESPTime time);

  void goto_page(const char *page);

  void goto_page(uint8_t page);

  void hide_component(const char *component) override;

  void show_component(const char *component) override;

  void enable_component_touch(const char *component);

  void disable_component_touch(const char *component);

  void add_waveform_data(uint8_t component_id, uint8_t channel_number, uint8_t value);

  void open_waveform_channel(uint8_t component_id, uint8_t channel_number, uint8_t value);

  void display_picture(uint16_t picture_id, uint16_t x_start, uint16_t y_start);

  void fill_area(uint16_t x1, uint16_t y1, uint16_t width, uint16_t height, uint16_t color);

  void fill_area(uint16_t x1, uint16_t y1, uint16_t width, uint16_t height, const char *color);

  void fill_area(uint16_t x1, uint16_t y1, uint16_t width, uint16_t height, Color color);

  void line(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, uint16_t color);

  void line(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, const char *color);

  void line(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, Color color);

  void rectangle(uint16_t x1, uint16_t y1, uint16_t width, uint16_t height, uint16_t color);

  void rectangle(uint16_t x1, uint16_t y1, uint16_t width, uint16_t height, const char *color);

  void rectangle(uint16_t x1, uint16_t y1, uint16_t width, uint16_t height, Color color);

  void circle(uint16_t center_x, uint16_t center_y, uint16_t radius, uint16_t color);

  void circle(uint16_t center_x, uint16_t center_y, uint16_t radius, const char *color);

  void circle(uint16_t center_x, uint16_t center_y, uint16_t radius, Color color);

  void filled_circle(uint16_t center_x, uint16_t center_y, uint16_t radius, uint16_t color);

  void filled_circle(uint16_t center_x, uint16_t center_y, uint16_t radius, const char *color);

  void filled_circle(uint16_t center_x, uint16_t center_y, uint16_t radius, Color color);

  void qrcode(uint16_t x1, uint16_t y1, const char *content, uint16_t size = 200, uint16_t background_color = 65535,
              uint16_t foreground_color = 0, uint8_t logo_pic = -1, uint8_t border_width = 8);

  void qrcode(uint16_t x1, uint16_t y1, const char *content, uint16_t size,
              Color background_color = Color(255, 255, 255), Color foreground_color = Color(0, 0, 0),
              uint8_t logo_pic = -1, uint8_t border_width = 8);

  void set_backlight_brightness(float brightness);

  void set_touch_sleep_timeout(uint16_t timeout);

  void set_wake_up_page(uint8_t page_id = 255);

  void set_start_up_page(uint8_t page_id = 255);

  void set_auto_wake_on_touch(bool auto_wake);

  void set_exit_reparse_on_start(bool exit_reparse);

  void set_skip_connection_handshake(bool skip_handshake) { this->skip_connection_handshake_ = skip_handshake; }

  void sleep(bool sleep);

  bool set_protocol_reparse_mode(bool active_mode);

  // ======== Nextion Intelligent Series ========

  void set_component_vid(const char *component, uint8_t vid_id);

  void set_component_drag(const char *component, bool drag);

  void set_component_aph(const char *component, uint8_t aph);

  void set_component_position(const char *component, uint32_t x, uint32_t y);

  // ========== INTERNAL METHODS ==========
  // (In most use cases you won't need these)
  void register_touch_component(NextionComponentBase *obj) { this->touch_.push_back(obj); }
  void register_switch_component(NextionComponentBase *obj) { this->switchtype_.push_back(obj); }
  void register_binarysensor_component(NextionComponentBase *obj) { this->binarysensortype_.push_back(obj); }
  void register_sensor_component(NextionComponentBase *obj) { this->sensortype_.push_back(obj); }
  void register_textsensor_component(NextionComponentBase *obj) { this->textsensortype_.push_back(obj); }

  void setup() override;
  void set_brightness(float brightness) { this->brightness_ = brightness; }
  float get_setup_priority() const override;
  void update() override;
  void loop() override;
  void set_writer(const nextion_writer_t &writer);

  // This function has been deprecated
  void set_wait_for_ack(bool wait_for_ack);

  bool send_command(const char *command);

  bool send_command_printf(const char *format, ...) __attribute__((format(printf, 2, 3)));

#ifdef USE_NEXTION_TFT_UPLOAD

  void set_tft_url(const std::string &tft_url) { this->tft_url_ = tft_url; }

  bool upload_tft(uint32_t baud_rate = 0, bool exit_reparse = true);

#endif  // USE_NEXTION_TFT_UPLOAD

  void dump_config() override;

  void soft_reset();

  void add_sleep_state_callback(std::function<void()> &&callback);

  void add_wake_state_callback(std::function<void()> &&callback);

  void add_setup_state_callback(std::function<void()> &&callback);

  void add_new_page_callback(std::function<void(uint8_t)> &&callback);

  void add_touch_event_callback(std::function<void(uint8_t, uint8_t, bool)> &&callback);

  void update_all_components();

  void set_nextion_sensor_state(int queue_type, const std::string &name, float state);
  void set_nextion_sensor_state(NextionQueueType queue_type, const std::string &name, float state);
  void set_nextion_text_state(const std::string &name, const std::string &state);

  void add_no_result_to_queue_with_set(NextionComponentBase *component, int32_t state_value) override;
  void add_no_result_to_queue_with_set(const std::string &variable_name, const std::string &variable_name_to_send,
                                       int32_t state_value) override;

  void add_no_result_to_queue_with_set(NextionComponentBase *component, const std::string &state_value) override;
  void add_no_result_to_queue_with_set(const std::string &variable_name, const std::string &variable_name_to_send,
                                       const std::string &state_value) override;

  void add_to_get_queue(NextionComponentBase *component) override;

  void add_addt_command_to_queue(NextionComponentBase *component) override;

  void update_components_by_prefix(const std::string &prefix);

  void set_touch_sleep_timeout_internal(uint32_t touch_sleep_timeout) {
    this->touch_sleep_timeout_ = touch_sleep_timeout;
  }
  void set_wake_up_page_internal(uint8_t wake_up_page) { this->wake_up_page_ = wake_up_page; }
  void set_start_up_page_internal(uint8_t start_up_page) { this->start_up_page_ = start_up_page; }
  void set_auto_wake_on_touch_internal(bool auto_wake_on_touch) { this->auto_wake_on_touch_ = auto_wake_on_touch; }
  void set_exit_reparse_on_start_internal(bool exit_reparse_on_start) {
    this->exit_reparse_on_start_ = exit_reparse_on_start;
  }

  size_t queue_size() { return this->nextion_queue_.size(); }

  bool is_updating() override;

 protected:
  std::deque<NextionQueue *> nextion_queue_;
  std::deque<NextionQueue *> waveform_queue_;
  uint16_t recv_ret_string_(std::string &response, uint32_t timeout, bool recv_flag);
  void all_components_send_state_(bool force_update = false);
  uint64_t comok_sent_ = 0;
  bool remove_from_q_(bool report_empty = true);

  bool ignore_is_setup_ = false;

  bool nextion_reports_is_setup_ = false;
  uint8_t nextion_event_;

  void process_nextion_commands_();
  void process_serial_();
  bool is_updating_ = false;
  uint32_t touch_sleep_timeout_ = 0;
  int16_t wake_up_page_ = -1;
  int16_t start_up_page_ = -1;
  bool auto_wake_on_touch_ = true;
  bool exit_reparse_on_start_ = false;
  bool skip_connection_handshake_ = false;

  bool send_command_(const std::string &command);
  void add_no_result_to_queue_(const std::string &variable_name);
  bool add_no_result_to_queue_with_ignore_sleep_printf_(const std::string &variable_name, const char *format, ...)
      __attribute__((format(printf, 3, 4)));
  void add_no_result_to_queue_with_command_(const std::string &variable_name, const std::string &command);

  bool add_no_result_to_queue_with_printf_(const std::string &variable_name, const char *format, ...)
      __attribute__((format(printf, 3, 4)));

  void add_no_result_to_queue_with_set_internal_(const std::string &variable_name,
                                                 const std::string &variable_name_to_send, int32_t state_value,
                                                 bool is_sleep_safe = false);

  void add_no_result_to_queue_with_set_internal_(const std::string &variable_name,
                                                 const std::string &variable_name_to_send,
                                                 const std::string &state_value, bool is_sleep_safe = false);

  void check_pending_waveform_();

#ifdef USE_NEXTION_TFT_UPLOAD
#ifdef USE_ESP8266
  WiFiClient *wifi_client_{nullptr};
  BearSSL::WiFiClientSecure *wifi_client_secure_{nullptr};
  WiFiClient *get_wifi_client_();
#endif  // USE_ESP8266
  std::string tft_url_;
  uint32_t content_length_ = 0;
  int tft_size_ = 0;
  uint32_t original_baud_rate_ = 0;
  bool upload_first_chunk_sent_ = false;

#ifdef USE_ARDUINO

  int upload_by_chunks_(HTTPClient &http_client, uint32_t &range_start);
#elif defined(USE_ESP_IDF)

  int upload_by_chunks_(esp_http_client_handle_t http_client, uint32_t &range_start);
#endif  // USE_ARDUINO vs USE_ESP_IDF

  bool upload_end_(bool successful);

  uint32_t get_free_heap_();

#endif  // USE_NEXTION_TFT_UPLOAD

  bool get_is_connected_() { return this->is_connected_; }

  bool check_connect_();

  std::vector<NextionComponentBase *> touch_;
  std::vector<NextionComponentBase *> switchtype_;
  std::vector<NextionComponentBase *> sensortype_;
  std::vector<NextionComponentBase *> textsensortype_;
  std::vector<NextionComponentBase *> binarysensortype_;
  CallbackManager<void()> setup_callback_{};
  CallbackManager<void()> sleep_callback_{};
  CallbackManager<void()> wake_callback_{};
  CallbackManager<void(uint8_t)> page_callback_{};
  CallbackManager<void(uint8_t, uint8_t, bool)> touch_callback_{};

  optional<nextion_writer_t> writer_;
  float brightness_{1.0};

  std::string device_model_;
  std::string firmware_version_;
  std::string serial_number_;
  std::string flash_size_;

  void remove_front_no_sensors_();

#ifdef NEXTION_PROTOCOL_LOG
  void print_queue_members_();
#endif  // NEXTION_PROTOCOL_LOG
  void reset_(bool reset_nextion = true);

  std::string command_data_;
  bool is_connected_ = false;
  const uint16_t startup_override_ms_ = 8000;
  const uint16_t max_q_age_ms_ = 8000;
  uint32_t started_ms_ = 0;
  bool sent_setup_commands_ = false;
};
}  // namespace nextion
}  // namespace esphome