223 lines
7.1 KiB
C++
223 lines
7.1 KiB
C++
#pragma once
|
|
|
|
#include "esphome.h"
|
|
// #include "esphome/components/sensor/sensor.h"
|
|
|
|
namespace esphome {
|
|
namespace wordclock {
|
|
|
|
struct Minute {
|
|
uint8_t minute;
|
|
uint8_t hour_offset;
|
|
std::vector<uint16_t> *segments;
|
|
};
|
|
|
|
struct Hour {
|
|
uint8_t hour;
|
|
std::vector<uint16_t> *segments;
|
|
};
|
|
|
|
struct SegmentCoords {
|
|
uint16_t x1;
|
|
uint16_t y1;
|
|
uint16_t x2;
|
|
uint16_t y2;
|
|
};
|
|
|
|
class BrightnessTransitionTransformer {
|
|
public:
|
|
virtual ~BrightnessTransitionTransformer() = default;
|
|
|
|
void setup(const uint8_t start_values, const uint8_t target_values, uint32_t length) {
|
|
this->start_time_ = millis();
|
|
this->length_ = length;
|
|
this->start_values_ = start_values;
|
|
this->target_values_ = target_values;
|
|
this->start();
|
|
}
|
|
virtual bool is_finished() { return this->get_progress_() >= 1.0f; }
|
|
virtual void start() {}
|
|
// virtual optional<uint8_t> apply() = 0;
|
|
virtual optional<uint8_t> apply() {
|
|
float v = BrightnessTransitionTransformer::smoothed_progress(this->get_progress_());
|
|
return esphome::lerp(v, this->start_values_, this->target_values_);
|
|
}
|
|
virtual void stop() {}
|
|
void reset() {
|
|
this->start_time_ = millis();
|
|
}
|
|
const uint8_t &get_start_values() const { return this->start_values_; }
|
|
const uint8_t &get_target_values() const { return this->target_values_; }
|
|
|
|
protected:
|
|
// The progress of this transition, on a scale of 0 to 1.
|
|
float get_progress_() {
|
|
uint32_t now = esphome::millis();
|
|
if (now < this->start_time_)
|
|
return 0.0f;
|
|
if (now >= this->start_time_ + this->length_)
|
|
return 1.0f;
|
|
return clamp((now - this->start_time_) / float(this->length_), 0.0f, 1.0f);
|
|
}
|
|
|
|
static float smoothed_progress(float x) { return x * x * x * (x * (x * 6.0f - 15.0f) + 10.0f); }
|
|
|
|
uint32_t start_time_;
|
|
uint32_t length_;
|
|
uint8_t start_values_;
|
|
uint8_t target_values_;
|
|
};
|
|
|
|
class Wordclock : public esphome::PollingComponent {
|
|
public:
|
|
Wordclock(
|
|
esphome::time::RealTimeClock *time,
|
|
esphome::addressable_light::AddressableLightDisplay *display,
|
|
esphome::light::AddressableLightState *light_state
|
|
);
|
|
|
|
void setup();
|
|
void update();
|
|
void set_brightness(uint8_t brightness) {
|
|
this->brightness = brightness;
|
|
}
|
|
bool get_effect_active() { return this->effect_active; }
|
|
void set_effect_active(bool x) { this->effect_active = x; }
|
|
|
|
bool get_effect_width() { return this->effect_width; }
|
|
void set_effect_width(bool x) { this->effect_width = x; }
|
|
|
|
bool get_effect_speed() { return this->effect_speed; }
|
|
void set_effect_speed(bool x) { this->effect_speed = x; }
|
|
|
|
void set_on_color(Color on_color) {
|
|
this->on_color = on_color;
|
|
}
|
|
void set_off_color(Color off_color) {
|
|
this->off_color = off_color;
|
|
}
|
|
void setup_transitions(uint32_t milliseconds);
|
|
|
|
void add_segment(SegmentCoords segment) {
|
|
this->segments->push_back(segment);
|
|
}
|
|
|
|
void add_static(uint16_t segment_id) {
|
|
this->static_segments->push_back(segment_id);
|
|
}
|
|
|
|
void add_hour(uint8_t hour, std::vector<uint16_t> *segments_ptr) {
|
|
this->hours->push_back(Hour{
|
|
.hour = hour,
|
|
.segments = segments_ptr,
|
|
});
|
|
}
|
|
|
|
void add_minute(uint8_t minute, uint8_t hour_offset, std::vector<uint16_t> *segments_ptr) {
|
|
this->minutes->push_back(Minute{
|
|
.minute = minute,
|
|
.hour_offset = hour_offset,
|
|
.segments = segments_ptr,
|
|
});
|
|
}
|
|
|
|
Color on_color {Color(0xFFFFFF)};
|
|
Color off_color {Color(0x000000)};
|
|
uint8_t brightness{255};
|
|
|
|
protected:
|
|
// ESPHome Components
|
|
esphome::time::RealTimeClock *time;
|
|
esphome::light::AddressableLightState *light_state;
|
|
esphome::addressable_light::AddressableLightDisplay *display;
|
|
|
|
// Time related state
|
|
bool valid_time{false};
|
|
int8_t current_hour{-1};
|
|
int8_t current_minute{-1};
|
|
|
|
// Segments Configuration
|
|
std::vector<SegmentCoords> *segments;
|
|
std::vector<uint16_t> *static_segments;
|
|
std::vector<Minute> *minutes;
|
|
std::vector<Hour> *hours;
|
|
|
|
BrightnessTransitionTransformer *off_transformer;
|
|
BrightnessTransitionTransformer *on_transformer;
|
|
|
|
std::vector<uint16_t> *added_segments;
|
|
std::vector<uint16_t> *removed_segments;
|
|
std::vector<uint16_t> *staying_segments;
|
|
|
|
std::vector<uint16_t> *current_segments;
|
|
std::vector<uint16_t> *previous_segments;
|
|
|
|
uint32_t current_position{0};
|
|
bool effect_active{true};
|
|
uint32_t effect_speed{12};
|
|
uint16_t effect_width{50};
|
|
Color get_next_color_base_(uint32_t position, uint32_t speed, uint16_t width, const Color ¤t_color);
|
|
Color get_next_color(uint32_t position, const Color ¤t_color);
|
|
|
|
|
|
// Utils
|
|
int8_t find_hour(uint8_t target_value);
|
|
int8_t find_minute(uint8_t target_value);
|
|
void find_difference(std::vector<uint16_t> *a_vec, std::vector<uint16_t> *b_vec);
|
|
|
|
void segment_effect_base(uint16_t segment_id, bool to_effect, Color base_color, uint8_t transition_progress) {
|
|
SegmentCoords s = this->segments->at(segment_id);
|
|
int x1 = s.x1; int y1 = s.y1; int x2 = s.x2; int y2 = s.y2;
|
|
Color color_to_draw;
|
|
Color effect_color;
|
|
|
|
const int32_t dx = abs(x2 - x1), sx = x1 < x2 ? 1 : -1;
|
|
const int32_t dy = -abs(y2 - y1), sy = y1 < y2 ? 1 : -1;
|
|
int32_t err = dx + dy;
|
|
while (true) {
|
|
effect_color = this->get_next_color(x1 + y1, Color(0)) * this->brightness;
|
|
if (to_effect) {
|
|
color_to_draw = base_color.gradient(effect_color, transition_progress);
|
|
} else {
|
|
color_to_draw = effect_color.gradient(base_color, transition_progress);
|
|
}
|
|
this->display->draw_pixel_at(x1, y1, color_to_draw);
|
|
if (x1 == x2 && y1 == y2) break;
|
|
int32_t e2 = 2 * err;
|
|
if (e2 >= dy) {
|
|
err += dy;
|
|
x1 += sx;
|
|
}
|
|
if (e2 <= dx) {
|
|
err += dx;
|
|
y1 += sy;
|
|
}
|
|
}
|
|
}
|
|
|
|
void enable_segment_effect(uint16_t segment_id, Color off_color, uint8_t transition_progress) {
|
|
segment_effect_base(segment_id, true, off_color, transition_progress);
|
|
}
|
|
void disable_segment_effect(uint16_t segment_id, Color off_color, uint8_t transition_progress) {
|
|
segment_effect_base(segment_id, false, off_color, transition_progress);
|
|
}
|
|
void apply_segment_effect(uint16_t segment_id) {
|
|
segment_effect_base(segment_id, true, Color(0), 255);
|
|
}
|
|
void start_idle_animation() {
|
|
this->display->fill(this->off_color);
|
|
this->display->set_enabled(false);
|
|
this->light_state->turn_on().set_effect("random_twinkle").perform();
|
|
}
|
|
|
|
void end_idle_animation() {
|
|
this->light_state->turn_off().perform();
|
|
this->display->set_enabled(true);
|
|
this->display->fill(this->off_color);
|
|
this->previous_segments->clear();
|
|
this->current_segments->clear();
|
|
}
|
|
};
|
|
} // namespace wordclock
|
|
} // namespace esphome
|
|
|