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_ESP32
#include <HTTPClient.h>
#endif
#ifdef USE_ESP8266
#include <ESP8266HTTPClient.h>
#include <WiFiClientSecure.h>
#endif
#endif

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, const char *picture);
  void set_component_background_color(const char *component, uint32_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, uint32_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_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, uint32_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, uint32_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, 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, 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, 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, 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, const char *color);
  void filled_circle(int center_x, int center_y, int radius, Color color);

  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 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

  void 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 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; }

 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 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;
  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);
  void upload_end_();

#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_{};

  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