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 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 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, int 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, int x, int 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(int component_id, uint8_t channel_number, uint8_t value);
  void open_waveform_channel(int component_id, uint8_t channel_number, uint8_t value);
  void display_picture(int picture_id, int x_start, int y_start);
  void fill_area(int x1, int y1, int width, int height, uint16_t color);
  void fill_area(int x1, int y1, int width, int height, const char *color);
  void fill_area(int x1, int y1, int width, int height, Color color);
  void line(int x1, int y1, int x2, int y2, uint16_t color);
  void line(int x1, int y1, int x2, int y2, const char *color);
  void line(int x1, int y1, int x2, int y2, Color color);
  void rectangle(int x1, int y1, int width, int height, uint16_t color);
  void rectangle(int x1, int y1, int width, int height, const char *color);
  void rectangle(int x1, int y1, int width, int height, Color color);
  void circle(int center_x, int center_y, int radius, uint16_t color);
  void circle(int center_x, int center_y, int radius, const char *color);
  void circle(int center_x, int center_y, int radius, Color color);
  void filled_circle(int center_x, int center_y, int radius, uint16_t color);
  void filled_circle(int center_x, int center_y, int radius, const char *color);
  void filled_circle(int center_x, int center_y, int radius, Color color);

  void qrcode(int x1, int y1, const char *content, int size = 200, uint16_t background_color = 65535,
              uint16_t foreground_color = 0, int logo_pic = -1, uint8_t border_width = 8);
  void qrcode(int x1, int y1, const char *content, int size, Color background_color = Color(255, 255, 255),
              Color foreground_color = Color(0, 0, 0), int 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 sleep(bool sleep);
  void set_protocol_reparse_mode(bool active_mode);

  // ========== 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_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; }

#endif

  bool upload_tft();

  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, int state_value) override;
  void add_no_result_to_queue_with_set(const std::string &variable_name, const std::string &variable_name_to_send,
                                       int 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(); }

 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;
  int wake_up_page_ = -1;
  int start_up_page_ = -1;
  bool auto_wake_on_touch_ = true;
  bool exit_reparse_on_start_ = 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, int 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
  int content_length_ = 0;
  int tft_size_ = 0;
#ifdef ARDUINO

  int upload_by_chunks_(HTTPClient *http, int range_start);

  bool upload_with_range_(uint32_t range_start, uint32_t range_end);

  bool upload_from_buffer_(const uint8_t *file_buf, size_t buf_size);
  bool upload_end_(bool successful);
#elif defined(USE_ESP_IDF)

  int upload_range(const std::string &url, int range_start);
  bool upload_end(bool successful);
#endif  // ARDUINO vs ESP-IDF

#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 USE_NEXTION_TFT_UPLOAD
  std::string tft_url_;
  uint8_t *transfer_buffer_{nullptr};
  size_t transfer_buffer_size_;
  bool upload_first_chunk_sent_ = false;
#endif

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

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