diff --git a/.gitignore b/.gitignore index 110437c368..71b66b2499 100644 --- a/.gitignore +++ b/.gitignore @@ -128,3 +128,5 @@ tests/.esphome/ sdkconfig.* !sdkconfig.defaults + +.tests/ \ No newline at end of file diff --git a/esphome/components/display/display_buffer.cpp b/esphome/components/display/display_buffer.cpp index cfd73509ea..9fe4137a14 100644 --- a/esphome/components/display/display_buffer.cpp +++ b/esphome/components/display/display_buffer.cpp @@ -15,6 +15,84 @@ static const char *const TAG = "display"; const Color COLOR_OFF(0, 0, 0, 0); const Color COLOR_ON(255, 255, 255, 255); +void Rect::expand(int16_t horizontal, int16_t vertical) { + if (this->is_set() && (this->w >= (-2 * horizontal)) && (this->h >= (-2 * vertical))) { + this->x = this->x - horizontal; + this->y = this->y - vertical; + this->w = this->w + (2 * horizontal); + this->h = this->h + (2 * vertical); + } +} + +void Rect::extend(Rect rect) { + if (!this->is_set()) { + this->x = rect.x; + this->y = rect.y; + this->w = rect.w; + this->h = rect.h; + } else { + if (this->x > rect.x) { + this->x = rect.x; + } + if (this->y > rect.y) { + this->y = rect.y; + } + if (this->x2() < rect.x2()) { + this->w = rect.x2() - this->x; + } + if (this->y2() < rect.y2()) { + this->h = rect.y2() - this->y; + } + } +} +void Rect::shrink(Rect rect) { + if (!this->inside(rect)) { + (*this) = Rect(); + } else { + if (this->x < rect.x) { + this->x = rect.x; + } + if (this->y < rect.y) { + this->y = rect.y; + } + if (this->x2() > rect.x2()) { + this->w = rect.x2() - this->x; + } + if (this->y2() > rect.y2()) { + this->h = rect.y2() - this->y; + } + } +} + +bool Rect::inside(int16_t x, int16_t y, bool absolute) { // NOLINT + if (!this->is_set()) { + return true; + } + if (absolute) { + return ((x >= 0) && (x <= this->w) && (y >= 0) && (y <= this->h)); + } else { + return ((x >= this->x) && (x <= this->x2()) && (y >= this->y) && (y <= this->y2())); + } +} + +bool Rect::inside(Rect rect, bool absolute) { + if (!this->is_set() || !rect.is_set()) { + return true; + } + if (absolute) { + return ((rect.x <= this->w) && (rect.w >= 0) && (rect.y <= this->h) && (rect.h >= 0)); + } else { + return ((rect.x <= this->x2()) && (rect.x2() >= this->x) && (rect.y <= this->y2()) && (rect.y2() >= this->y)); + } +} + +void Rect::info(const std::string &prefix) { + if (this->is_set()) { + ESP_LOGI(TAG, "%s [%3d,%3d,%3d,%3d]", prefix.c_str(), this->x, this->y, this->w, this->h); + } else + ESP_LOGI(TAG, "%s ** IS NOT SET **", prefix.c_str()); +} + void DisplayBuffer::init_internal_(uint32_t buffer_length) { ExternalRAMAllocator allocator(ExternalRAMAllocator::ALLOW_FAILURE); this->buffer_ = allocator.allocate(buffer_length); @@ -24,6 +102,7 @@ void DisplayBuffer::init_internal_(uint32_t buffer_length) { } this->clear(); } + void DisplayBuffer::fill(Color color) { this->filled_rectangle(0, 0, this->get_width(), this->get_height(), color); } void DisplayBuffer::clear() { this->fill(COLOR_OFF); } int DisplayBuffer::get_width() { @@ -50,6 +129,9 @@ int DisplayBuffer::get_height() { } void DisplayBuffer::set_rotation(DisplayRotation rotation) { this->rotation_ = rotation; } void HOT DisplayBuffer::draw_pixel_at(int x, int y, Color color) { + if (!this->get_clipping().inside(x, y)) + return; // NOLINT + switch (this->rotation_) { case DISPLAY_ROTATION_0_DEGREES: break; @@ -368,6 +450,10 @@ void DisplayBuffer::do_update_() { } else if (this->writer_.has_value()) { (*this->writer_)(*this); } + // remove all not ended clipping regions + while (is_clipping()) { + end_clipping(); + } } void DisplayOnPageChangeTrigger::process(DisplayPage *from, DisplayPage *to) { if ((this->from_ == nullptr || this->from_ == from) && (this->to_ == nullptr || this->to_ == to)) @@ -392,6 +478,41 @@ void DisplayBuffer::strftime(int x, int y, Font *font, const char *format, time: } #endif +void DisplayBuffer::start_clipping(Rect rect) { + if (!this->clipping_rectangle_.empty()) { + Rect r = this->clipping_rectangle_.back(); + rect.shrink(r); + } + this->clipping_rectangle_.push_back(rect); +} +void DisplayBuffer::end_clipping() { + if (this->clipping_rectangle_.empty()) { + ESP_LOGE(TAG, "clear: Clipping is not set."); + } else { + this->clipping_rectangle_.pop_back(); + } +} +void DisplayBuffer::extend_clipping(Rect add_rect) { + if (this->clipping_rectangle_.empty()) { + ESP_LOGE(TAG, "add: Clipping is not set."); + } else { + this->clipping_rectangle_.back().extend(add_rect); + } +} +void DisplayBuffer::shrink_clipping(Rect add_rect) { + if (this->clipping_rectangle_.empty()) { + ESP_LOGE(TAG, "add: Clipping is not set."); + } else { + this->clipping_rectangle_.back().shrink(add_rect); + } +} +Rect DisplayBuffer::get_clipping() { + if (this->clipping_rectangle_.empty()) { + return Rect(); + } else { + return this->clipping_rectangle_.back(); + } +} bool Glyph::get_pixel(int x, int y) const { const int x_data = x - this->glyph_data_->offset_x; const int y_data = y - this->glyph_data_->offset_y; diff --git a/esphome/components/display/display_buffer.h b/esphome/components/display/display_buffer.h index b652989067..3763da8041 100644 --- a/esphome/components/display/display_buffer.h +++ b/esphome/components/display/display_buffer.h @@ -4,7 +4,6 @@ #include "esphome/core/defines.h" #include "esphome/core/automation.h" #include "display_color_utils.h" - #include #include @@ -100,6 +99,32 @@ enum DisplayRotation { DISPLAY_ROTATION_270_DEGREES = 270, }; +static const int16_t VALUE_NO_SET = 32766; + +class Rect { + public: + int16_t x; ///< X coordinate of corner + int16_t y; ///< Y coordinate of corner + int16_t w; ///< Width of region + int16_t h; ///< Height of region + + Rect() : x(VALUE_NO_SET), y(VALUE_NO_SET), w(VALUE_NO_SET), h(VALUE_NO_SET) {} // NOLINT + inline Rect(int16_t x, int16_t y, int16_t w, int16_t h) ALWAYS_INLINE : x(x), y(y), w(w), h(h) {} + inline int16_t x2() { return this->x + this->w; }; ///< X coordinate of corner + inline int16_t y2() { return this->y + this->h; }; ///< Y coordinate of corner + + inline bool is_set() ALWAYS_INLINE { return (this->h != VALUE_NO_SET) && (this->w != VALUE_NO_SET); } + + void expand(int16_t horizontal, int16_t vertical); + + void extend(Rect rect); + void shrink(Rect rect); + + bool inside(Rect rect, bool absolute = false); + bool inside(int16_t x, int16_t y, bool absolute = false); + void info(const std::string &prefix = "rect info:"); +}; + class Font; class Image; class DisplayBuffer; @@ -126,6 +151,7 @@ class DisplayBuffer { int get_width(); /// Get the height of the image in pixels with rotation applied. int get_height(); + /// Set a single pixel at the specified coordinates to the given color. void draw_pixel_at(int x, int y, Color color = COLOR_ON); @@ -374,6 +400,49 @@ class DisplayBuffer { */ virtual DisplayType get_display_type() = 0; + /** Set the clipping rectangle for further drawing + * + * @param[in] rect: Pointer to Rect for clipping (or NULL for entire screen) + * + * return true if success, false if error + */ + void start_clipping(Rect rect); + void start_clipping(int16_t left, int16_t top, int16_t right, int16_t bottom) { + start_clipping(Rect(left, top, right - left, bottom - top)); + }; + + /** Add a rectangular region to the invalidation region + * - This is usually called when an element has been modified + * + * @param[in] rect: Rectangle to add to the invalidation region + */ + void extend_clipping(Rect rect); + void extend_clipping(int16_t left, int16_t top, int16_t right, int16_t bottom) { + this->extend_clipping(Rect(left, top, right - left, bottom - top)); + }; + + /** substract a rectangular region to the invalidation region + * - This is usually called when an element has been modified + * + * @param[in] rect: Rectangle to add to the invalidation region + */ + void shrink_clipping(Rect rect); + void shrink_clipping(uint16_t left, uint16_t top, uint16_t right, uint16_t bottom) { + this->shrink_clipping(Rect(left, top, right - left, bottom - top)); + }; + + /** Reset the invalidation region + */ + void end_clipping(); + + /** Get the current the clipping rectangle + * + * return rect for active clipping region + */ + Rect get_clipping(); + + bool is_clipping() const { return !this->clipping_rectangle_.empty(); } + protected: void vprintf_(int x, int y, Font *font, Color color, TextAlign align, const char *format, va_list arg); @@ -390,6 +459,7 @@ class DisplayBuffer { DisplayPage *previous_page_{nullptr}; std::vector on_page_change_triggers_; bool auto_clear_enabled_{true}; + std::vector clipping_rectangle_; }; class DisplayPage { diff --git a/esphome/components/pid/pid_autotuner.cpp b/esphome/components/pid/pid_autotuner.cpp index fc012aaa39..1b3ddebcc5 100644 --- a/esphome/components/pid/pid_autotuner.cpp +++ b/esphome/components/pid/pid_autotuner.cpp @@ -1,6 +1,10 @@ #include "pid_autotuner.h" #include "esphome/core/log.h" +#ifndef M_PI +#define M_PI 3.1415926535897932384626433 +#endif + namespace esphome { namespace pid { @@ -73,7 +77,7 @@ PIDAutotuner::PIDAutotuneResult PIDAutotuner::update(float setpoint, float proce } if (!std::isnan(this->setpoint_) && this->setpoint_ != setpoint) { - ESP_LOGW(TAG, "Setpoint changed during autotune! The result will not be accurate!"); + ESP_LOGW(TAG, "%s: Setpoint changed during autotune! The result will not be accurate!", this->id_.c_str()); } this->setpoint_ = setpoint; @@ -87,7 +91,7 @@ PIDAutotuner::PIDAutotuneResult PIDAutotuner::update(float setpoint, float proce if (!this->frequency_detector_.has_enough_data() || !this->amplitude_detector_.has_enough_data()) { // not enough data for calculation yet - ESP_LOGV(TAG, " Not enough data yet for aututuner"); + ESP_LOGV(TAG, "%s: Not enough data yet for autotuner", this->id_.c_str()); return res; } @@ -97,12 +101,13 @@ PIDAutotuner::PIDAutotuneResult PIDAutotuner::update(float setpoint, float proce // The frequency/amplitude is not fully accurate yet, try to wait // until the fault clears, or terminate after a while anyway if (zc_symmetrical) { - ESP_LOGVV(TAG, " ZC is not symmetrical"); + ESP_LOGVV(TAG, "%s: ZC is not symmetrical", this->id_.c_str()); } if (amplitude_convergent) { - ESP_LOGVV(TAG, " Amplitude is not convergent"); + ESP_LOGVV(TAG, "%s: Amplitude is not convergent", this->id_.c_str()); } uint32_t phase = this->relay_function_.phase_count; + ESP_LOGVV(TAG, "%s: >", this->id_.c_str()); ESP_LOGVV(TAG, " Phase %u, enough=%u", phase, enough_data_phase_); if (this->enough_data_phase_ == 0) { @@ -116,7 +121,7 @@ PIDAutotuner::PIDAutotuneResult PIDAutotuner::update(float setpoint, float proce } } - ESP_LOGI(TAG, "PID Autotune finished!"); + ESP_LOGI(TAG, "%s: PID Autotune finished!", this->id_.c_str()); float osc_ampl = this->amplitude_detector_.get_mean_oscillation_amplitude(); float d = (this->relay_function_.output_positive - this->relay_function_.output_negative) / 2.0f; @@ -131,12 +136,12 @@ PIDAutotuner::PIDAutotuneResult PIDAutotuner::update(float setpoint, float proce return res; } void PIDAutotuner::dump_config() { - ESP_LOGI(TAG, "PID Autotune:"); if (this->state_ == AUTOTUNE_SUCCEEDED) { + ESP_LOGI(TAG, "%s: PID Autotune:", this->id_.c_str()); ESP_LOGI(TAG, " State: Succeeded!"); bool has_issue = false; if (!this->amplitude_detector_.is_amplitude_convergent()) { - ESP_LOGW(TAG, " Could not reliable determine oscillation amplitude, PID parameters may be inaccurate!"); + ESP_LOGW(TAG, " Could not reliably determine oscillation amplitude, PID parameters may be inaccurate!"); ESP_LOGW(TAG, " Please make sure you eliminate all outside influences on the measured temperature."); has_issue = true; } @@ -173,10 +178,12 @@ void PIDAutotuner::dump_config() { print_rule_("Pessen Integral PID", 0.7f, 1.75f, 0.105f); print_rule_("Some Overshoot PID", 0.333f, 0.667f, 0.111f); print_rule_("No Overshoot PID", 0.2f, 0.4f, 0.0625f); + ESP_LOGI(TAG, "%s: Autotune completed", this->id_.c_str()); } if (this->state_ == AUTOTUNE_RUNNING) { - ESP_LOGI(TAG, " Autotune is still running!"); + ESP_LOGD(TAG, "%s: PID Autotune:", this->id_.c_str()); + ESP_LOGD(TAG, " Autotune is still running!"); ESP_LOGD(TAG, " Status: Trying to reach %.2f °C", setpoint_ - relay_function_.current_target_error()); ESP_LOGD(TAG, " Stats so far:"); ESP_LOGD(TAG, " Phases: %u", relay_function_.phase_count); @@ -221,7 +228,6 @@ float PIDAutotuner::RelayFunction::update(float error) { float output = state == RELAY_FUNCTION_POSITIVE ? output_positive : output_negative; if (change) { this->phase_count++; - ESP_LOGV(TAG, "Autotune: Turning output to %.1f%%", output * 100); } return output; @@ -245,10 +251,8 @@ void PIDAutotuner::OscillationFrequencyDetector::update(uint32_t now, float erro if (had_crossing) { // Had crossing above hysteresis threshold, record - ESP_LOGV(TAG, "Autotune: Detected Zero-Cross at %u", now); if (this->last_zerocross != 0) { uint32_t dt = now - this->last_zerocross; - ESP_LOGV(TAG, " dt: %u", dt); this->zerocrossing_intervals.push_back(dt); } this->last_zerocross = now; @@ -297,13 +301,11 @@ void PIDAutotuner::OscillationAmplitudeDetector::update(float error, // The positive error peak must have been in previous segment (180° shifted) // record phase_max this->phase_maxs.push_back(phase_max); - ESP_LOGV(TAG, "Autotune: Phase Max: %f", phase_max); } else if (last_relay_state == RelayFunction::RELAY_FUNCTION_NEGATIVE) { // Transitioned from negative error to positive error. // The negative error peak must have been in previous segment (180° shifted) // record phase_min this->phase_mins.push_back(phase_min); - ESP_LOGV(TAG, "Autotune: Phase Min: %f", phase_min); } // reset phase values for next phase this->phase_min = error; diff --git a/esphome/components/pid/pid_autotuner.h b/esphome/components/pid/pid_autotuner.h index 88716d2b89..98dc02bcc4 100644 --- a/esphome/components/pid/pid_autotuner.h +++ b/esphome/components/pid/pid_autotuner.h @@ -31,6 +31,8 @@ class PIDAutotuner { void dump_config(); + void set_autotuner_id(std::string id) { this->id_ = std::move(id); } + void set_noiseband(float noiseband) { relay_function_.noiseband = noiseband; // ZC detector uses 1/4 the noiseband of relay function (noise suppression) @@ -106,6 +108,7 @@ class PIDAutotuner { } state_ = AUTOTUNE_RUNNING; float ku_; float pu_; + std::string id_; }; } // namespace pid diff --git a/esphome/components/pid/pid_climate.cpp b/esphome/components/pid/pid_climate.cpp index 81c3e1f12e..dab4502d40 100644 --- a/esphome/components/pid/pid_climate.cpp +++ b/esphome/components/pid/pid_climate.cpp @@ -130,9 +130,6 @@ void PIDClimate::update_pid_() { // keep autotuner instance so that subsequent dump_configs will print the long result message. } else { value = res.output; - if (mode != climate::CLIMATE_MODE_HEAT_COOL) { - ESP_LOGW(TAG, "For PID autotuner you need to set AUTO (also called heat/cool) mode!"); - } } } } @@ -151,10 +148,24 @@ void PIDClimate::start_autotune(std::unique_ptr &&autotune) { float min_value = this->supports_cool_() ? -1.0f : 0.0f; float max_value = this->supports_heat_() ? 1.0f : 0.0f; this->autotuner_->config(min_value, max_value); + this->autotuner_->set_autotuner_id(this->get_object_id()); + + ESP_LOGI(TAG, + "%s: Autotune has started. This can take a long time depending on the " + "responsiveness of your system. Your system " + "output will be altered to deliberately oscillate above and below the setpoint multiple times. " + "Until your sensor provides a reading, the autotuner may display \'nan\'", + this->get_object_id().c_str()); + this->set_interval("autotune-progress", 10000, [this]() { if (this->autotuner_ != nullptr && !this->autotuner_->is_finished()) this->autotuner_->dump_config(); }); + + if (mode != climate::CLIMATE_MODE_HEAT_COOL) { + ESP_LOGW(TAG, "%s: !!! For PID autotuner you need to set AUTO (also called heat/cool) mode!", + this->get_object_id().c_str()); + } } void PIDClimate::reset_integral_term() { this->controller_.reset_accumulated_integral(); } diff --git a/esphome/const.py b/esphome/const.py index ebadf84dc7..d62c4689ad 100644 --- a/esphome/const.py +++ b/esphome/const.py @@ -1,6 +1,6 @@ """Constants used by esphome.""" -__version__ = "2023.2.0b3" +__version__ = "2023.2.0b4" ALLOWED_NAME_CHARS = "abcdefghijklmnopqrstuvwxyz0123456789-_"