ESPHome  2024.5.2
addressable_light_effect.h
Go to the documentation of this file.
1 #pragma once
2 
3 #include <utility>
4 #include <vector>
5 
9 
10 namespace esphome {
11 namespace light {
12 
13 inline static int16_t sin16_c(uint16_t theta) {
14  static const uint16_t BASE[] = {0, 6393, 12539, 18204, 23170, 27245, 30273, 32137};
15  static const uint8_t SLOPE[] = {49, 48, 44, 38, 31, 23, 14, 4};
16  uint16_t offset = (theta & 0x3FFF) >> 3; // 0..2047
17  if (theta & 0x4000)
18  offset = 2047 - offset;
19  uint8_t section = offset / 256; // 0..7
20  uint16_t b = BASE[section];
21  uint8_t m = SLOPE[section];
22  uint8_t secoffset8 = uint8_t(offset) / 2;
23  uint16_t mx = m * secoffset8;
24  int16_t y = mx + b;
25  if (theta & 0x8000)
26  return -y;
27  return y;
28 }
29 inline static uint8_t half_sin8(uint8_t v) { return sin16_c(uint16_t(v) * 128u) >> 8; }
30 
32  public:
33  explicit AddressableLightEffect(const std::string &name) : LightEffect(name) {}
34  void start_internal() override {
35  this->get_addressable_()->set_effect_active(true);
37  this->start();
38  }
39  void stop() override { this->get_addressable_()->set_effect_active(false); }
40  virtual void apply(AddressableLight &it, const Color &current_color) = 0;
41  void apply() override {
42  // not using any color correction etc. that will be handled by the addressable layer through ESPColorCorrection
44  this->apply(*this->get_addressable_(), current_color);
45  }
46 
47  protected:
49 };
50 
52  public:
53  AddressableLambdaLightEffect(const std::string &name,
54  std::function<void(AddressableLight &, Color, bool initial_run)> f,
55  uint32_t update_interval)
56  : AddressableLightEffect(name), f_(std::move(f)), update_interval_(update_interval) {}
57  void start() override { this->initial_run_ = true; }
58  void apply(AddressableLight &it, const Color &current_color) override {
59  const uint32_t now = millis();
60  if (now - this->last_run_ >= this->update_interval_ || this->initial_run_) {
61  this->last_run_ = now;
62  this->f_(it, current_color, this->initial_run_);
63  this->initial_run_ = false;
64  it.schedule_show();
65  }
66  }
67 
68  protected:
69  std::function<void(AddressableLight &, Color, bool initial_run)> f_;
70  uint32_t update_interval_;
71  uint32_t last_run_{0};
73 };
74 
76  public:
77  explicit AddressableRainbowLightEffect(const std::string &name) : AddressableLightEffect(name) {}
78  void apply(AddressableLight &it, const Color &current_color) override {
79  ESPHSVColor hsv;
80  hsv.value = 255;
81  hsv.saturation = 240;
82  uint16_t hue = (millis() * this->speed_) % 0xFFFF;
83  const uint16_t add = 0xFFFF / this->width_;
84  for (auto var : it) {
85  hsv.hue = hue >> 8;
86  var = hsv;
87  hue += add;
88  }
89  it.schedule_show();
90  }
91  void set_speed(uint32_t speed) { this->speed_ = speed; }
92  void set_width(uint16_t width) { this->width_ = width; }
93 
94  protected:
95  uint32_t speed_{10};
96  uint16_t width_{50};
97 };
98 
100  uint8_t r, g, b, w;
101  bool random;
102  size_t num_leds;
103  bool gradient;
104 };
105 
107  public:
108  explicit AddressableColorWipeEffect(const std::string &name) : AddressableLightEffect(name) {}
109  void set_colors(const std::vector<AddressableColorWipeEffectColor> &colors) { this->colors_ = colors; }
110  void set_add_led_interval(uint32_t add_led_interval) { this->add_led_interval_ = add_led_interval; }
111  void set_reverse(bool reverse) { this->reverse_ = reverse; }
112  void apply(AddressableLight &it, const Color &current_color) override {
113  const uint32_t now = millis();
114  if (now - this->last_add_ < this->add_led_interval_)
115  return;
116  this->last_add_ = now;
117  if (this->reverse_)
118  it.shift_left(1);
119  else
120  it.shift_right(1);
121  const AddressableColorWipeEffectColor &color = this->colors_[this->at_color_];
122  Color esp_color = Color(color.r, color.g, color.b, color.w);
123  if (color.gradient) {
124  size_t next_color_index = (this->at_color_ + 1) % this->colors_.size();
125  const AddressableColorWipeEffectColor &next_color = this->colors_[next_color_index];
126  const Color next_esp_color = Color(next_color.r, next_color.g, next_color.b, next_color.w);
127  uint8_t gradient = 255 * ((float) this->leds_added_ / color.num_leds);
128  esp_color = esp_color.gradient(next_esp_color, gradient);
129  }
130  if (this->reverse_)
131  it[-1] = esp_color;
132  else
133  it[0] = esp_color;
134  if (++this->leds_added_ >= color.num_leds) {
135  this->leds_added_ = 0;
136  this->at_color_ = (this->at_color_ + 1) % this->colors_.size();
137  AddressableColorWipeEffectColor &new_color = this->colors_[this->at_color_];
138  if (new_color.random) {
140  new_color.r = c.r;
141  new_color.g = c.g;
142  new_color.b = c.b;
143  }
144  }
145  it.schedule_show();
146  }
147 
148  protected:
149  std::vector<AddressableColorWipeEffectColor> colors_;
150  size_t at_color_{0};
151  uint32_t last_add_{0};
152  uint32_t add_led_interval_{};
153  size_t leds_added_{0};
154  bool reverse_{};
155 };
156 
158  public:
159  explicit AddressableScanEffect(const std::string &name) : AddressableLightEffect(name) {}
160  void set_move_interval(uint32_t move_interval) { this->move_interval_ = move_interval; }
161  void set_scan_width(uint32_t scan_width) { this->scan_width_ = scan_width; }
162  void apply(AddressableLight &it, const Color &current_color) override {
163  const uint32_t now = millis();
164  if (now - this->last_move_ < this->move_interval_)
165  return;
166 
167  if (direction_) {
168  this->at_led_++;
169  if (this->at_led_ == it.size() - this->scan_width_)
170  this->direction_ = false;
171  } else {
172  this->at_led_--;
173  if (this->at_led_ == 0)
174  this->direction_ = true;
175  }
176  this->last_move_ = now;
177 
178  it.all() = Color::BLACK;
179  for (uint32_t i = 0; i < this->scan_width_; i++) {
180  it[this->at_led_ + i] = current_color;
181  }
182 
183  it.schedule_show();
184  }
185 
186  protected:
187  uint32_t move_interval_{};
188  uint32_t scan_width_{1};
189  uint32_t last_move_{0};
190  uint32_t at_led_{0};
191  bool direction_{true};
192 };
193 
195  public:
196  explicit AddressableTwinkleEffect(const std::string &name) : AddressableLightEffect(name) {}
197  void apply(AddressableLight &addressable, const Color &current_color) override {
198  const uint32_t now = millis();
199  uint8_t pos_add = 0;
200  if (now - this->last_progress_ > this->progress_interval_) {
201  const uint32_t pos_add32 = (now - this->last_progress_) / this->progress_interval_;
202  pos_add = pos_add32;
203  this->last_progress_ += pos_add32 * this->progress_interval_;
204  }
205  for (auto view : addressable) {
206  if (view.get_effect_data() != 0) {
207  const uint8_t sine = half_sin8(view.get_effect_data());
208  view = current_color * sine;
209  const uint8_t new_pos = view.get_effect_data() + pos_add;
210  if (new_pos < view.get_effect_data())
211  view.set_effect_data(0);
212  else
213  view.set_effect_data(new_pos);
214  } else {
215  view = Color::BLACK;
216  }
217  }
218  while (random_float() < this->twinkle_probability_) {
219  const size_t pos = random_uint32() % addressable.size();
220  if (addressable[pos].get_effect_data() != 0)
221  continue;
222  addressable[pos].set_effect_data(1);
223  }
224  addressable.schedule_show();
225  }
226  void set_twinkle_probability(float twinkle_probability) { this->twinkle_probability_ = twinkle_probability; }
227  void set_progress_interval(uint32_t progress_interval) { this->progress_interval_ = progress_interval; }
228 
229  protected:
230  float twinkle_probability_{0.05f};
231  uint32_t progress_interval_{4};
232  uint32_t last_progress_{0};
233 };
234 
236  public:
237  explicit AddressableRandomTwinkleEffect(const std::string &name) : AddressableLightEffect(name) {}
238  void apply(AddressableLight &it, const Color &current_color) override {
239  const uint32_t now = millis();
240  uint8_t pos_add = 0;
241  if (now - this->last_progress_ > this->progress_interval_) {
242  pos_add = (now - this->last_progress_) / this->progress_interval_;
243  this->last_progress_ = now;
244  }
245  uint8_t subsine = ((8 * (now - this->last_progress_)) / this->progress_interval_) & 0b111;
246  for (auto view : it) {
247  if (view.get_effect_data() != 0) {
248  const uint8_t x = (view.get_effect_data() >> 3) & 0b11111;
249  const uint8_t color = view.get_effect_data() & 0b111;
250  const uint16_t sine = half_sin8((x << 3) | subsine);
251  if (color == 0) {
252  view = current_color * sine;
253  } else {
254  view = Color(((color >> 2) & 1) * sine, ((color >> 1) & 1) * sine, ((color >> 0) & 1) * sine);
255  }
256  const uint8_t new_x = x + pos_add;
257  if (new_x > 0b11111)
258  view.set_effect_data(0);
259  else
260  view.set_effect_data((new_x << 3) | color);
261  } else {
262  view = Color(0, 0, 0, 0);
263  }
264  }
265  while (random_float() < this->twinkle_probability_) {
266  const size_t pos = random_uint32() % it.size();
267  if (it[pos].get_effect_data() != 0)
268  continue;
269  const uint8_t color = random_uint32() & 0b111;
270  it[pos].set_effect_data(0b1000 | color);
271  }
272  it.schedule_show();
273  }
274  void set_twinkle_probability(float twinkle_probability) { this->twinkle_probability_ = twinkle_probability; }
275  void set_progress_interval(uint32_t progress_interval) { this->progress_interval_ = progress_interval; }
276 
277  protected:
278  float twinkle_probability_{};
279  uint32_t progress_interval_{};
280  uint32_t last_progress_{0};
281 };
282 
284  public:
285  explicit AddressableFireworksEffect(const std::string &name) : AddressableLightEffect(name) {}
286  void start() override {
287  auto &it = *this->get_addressable_();
288  it.all() = Color::BLACK;
289  }
290  void apply(AddressableLight &it, const Color &current_color) override {
291  const uint32_t now = millis();
292  if (now - this->last_update_ < this->update_interval_)
293  return;
294  this->last_update_ = now;
295  // "invert" the fade out parameter so that higher values make fade out faster
296  const uint8_t fade_out_mult = 255u - this->fade_out_rate_;
297  for (auto view : it) {
298  Color target = view.get() * fade_out_mult;
299  if (target.r < 64)
300  target *= 170;
301  view = target;
302  }
303  int last = it.size() - 1;
304  it[0].set(it[0].get() + (it[1].get() * 128));
305  for (int i = 1; i < last; i++) {
306  it[i] = (it[i - 1].get() * 64) + it[i].get() + (it[i + 1].get() * 64);
307  }
308  it[last] = it[last].get() + (it[last - 1].get() * 128);
309  if (random_float() < this->spark_probability_) {
310  const size_t pos = random_uint32() % it.size();
311  if (this->use_random_color_) {
312  it[pos] = Color::random_color();
313  } else {
314  it[pos] = current_color;
315  }
316  }
317  it.schedule_show();
318  }
319  void set_update_interval(uint32_t update_interval) { this->update_interval_ = update_interval; }
320  void set_spark_probability(float spark_probability) { this->spark_probability_ = spark_probability; }
321  void set_use_random_color(bool random_color) { this->use_random_color_ = random_color; }
322  void set_fade_out_rate(uint8_t fade_out_rate) { this->fade_out_rate_ = fade_out_rate; }
323 
324  protected:
325  uint8_t fade_out_rate_{};
326  uint32_t update_interval_{};
327  uint32_t last_update_{0};
328  float spark_probability_{};
329  bool use_random_color_{};
330 };
331 
333  public:
334  explicit AddressableFlickerEffect(const std::string &name) : AddressableLightEffect(name) {}
335  void apply(AddressableLight &it, const Color &current_color) override {
336  const uint32_t now = millis();
337  const uint8_t intensity = this->intensity_;
338  const uint8_t inv_intensity = 255 - intensity;
339  if (now - this->last_update_ < this->update_interval_)
340  return;
341 
342  this->last_update_ = now;
343  uint32_t rng_state = random_uint32();
344  for (auto var : it) {
345  rng_state = (rng_state * 0x9E3779B9) + 0x9E37;
346  const uint8_t flicker = (rng_state & 0xFF) % intensity;
347  // scale down by random factor
348  var = var.get() * (255 - flicker);
349 
350  // slowly fade back to "real" value
351  var = (var.get() * inv_intensity) + (current_color * intensity);
352  }
353  it.schedule_show();
354  }
355  void set_update_interval(uint32_t update_interval) { this->update_interval_ = update_interval; }
356  void set_intensity(float intensity) { this->intensity_ = to_uint8_scale(intensity); }
357 
358  protected:
359  uint32_t update_interval_{16};
360  uint32_t last_update_{0};
361  uint8_t intensity_{13};
362 };
363 
364 } // namespace light
365 } // namespace esphome
const char * name
Definition: stm32flash.h:78
void apply(AddressableLight &addressable, const Color &current_color) override
virtual void clear_effect_data()=0
void set_move_interval(uint32_t move_interval)
void set_effect_active(bool effect_active)
uint32_t random_uint32()
Return a random 32-bit unsigned integer.
Definition: helpers.cpp:193
uint16_t x
Definition: tt21100.cpp:17
LightOutput * get_output() const
Get the light output associated with this object.
void set_progress_interval(uint32_t progress_interval)
void set_update_interval(uint32_t update_interval)
int speed
Definition: fan.h:35
STL namespace.
uint32_t IRAM_ATTR HOT millis()
Definition: core.cpp:25
uint8_t g
Definition: color.h:18
uint16_t y
Definition: tt21100.cpp:18
uint8_t m
Definition: bl0939.h:20
static Color random_color()
Definition: color.h:134
void set_add_led_interval(uint32_t add_led_interval)
void apply(AddressableLight &it, const Color &current_color) override
void set_progress_interval(uint32_t progress_interval)
void apply(AddressableLight &it, const Color &current_color) override
virtual int32_t size() const =0
Color gradient(const Color &to_color, uint8_t amnt)
Definition: color.h:145
void apply(AddressableLight &it, const Color &current_color) override
AddressableLambdaLightEffect(const std::string &name, std::function< void(AddressableLight &, Color, bool initial_run)> f, uint32_t update_interval)
void set_twinkle_probability(float twinkle_probability)
std::vector< AddressableColorWipeEffectColor > colors_
Color color_from_light_color_values(LightColorValues val)
Convert the color information from a LightColorValues object to a Color object (does not apply bright...
void set_colors(const std::vector< AddressableColorWipeEffectColor > &colors)
uint8_t b
Definition: color.h:22
static const Color BLACK
Definition: color.h:160
This is a workaround until we can figure out a way to get the tflite-micro idf component code availab...
Definition: a01nyub.cpp:7
LightColorValues remote_values
The remote color values reported to the frontend.
Definition: light_state.h:77
uint8_t r
Definition: color.h:14
virtual void start()
Initialize this LightEffect. Will be called once after creation.
Definition: light_effect.h:17
void set_update_interval(uint32_t update_interval)
void apply(AddressableLight &it, const Color &current_color) override
std::function< void(AddressableLight &, Color, bool initial_run)> f_
void apply(AddressableLight &it, const Color &current_color) override
void apply(AddressableLight &it, const Color &current_color) override
void apply(AddressableLight &it, const Color &current_color) override
float random_float()
Return a random float between 0 and 1.
Definition: helpers.cpp:216