feat: web UI with AP, Wi-Fi client, mDNS, presets, OTA and DDP
- Wi-Fi access point led-XXXXXX plus a client network, configurable mDNS name and static client address - Preset tiles with an editor, drag to reorder, default presets, global brightness, Run and Edit modes, collapsible menu on phones - 35 patterns ported from led-driver, up to 512 LEDs, colour order, max brightness and data pin settings - Over-the-air updates (POST /ota) with rollback, and a CLI in tools/ota.py - DDP receiver on UDP 4048 with tools/ddp_test.py - LED refresh every 10 ms; lwIP sockets raised to 16 so mDNS, HTTP and DDP can run together Co-Authored-By: Claude Haiku 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
89f996096c
commit
9a04d28ecf
32 files changed
+6210
-398
No files matched your search
+398
-122
@@ -1,188 +1,464 @@
|
||||
/*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Pattern engine: runs the selected pattern once per frame into a shadow frame, crossfades from the
|
||||
* previous frame when a preset asks for it, and shows the result on the WS2812 strip.
|
||||
*/
|
||||
#include <cstdlib>
|
||||
#include <cstring>
|
||||
|
||||
#include "driver/gpio.h"
|
||||
#include "esp_heap_caps.h"
|
||||
#include "esp_log.h"
|
||||
#include "esp_timer.h"
|
||||
#include "driver/gpio.h"
|
||||
#include "freertos/FreeRTOS.h"
|
||||
#include "freertos/semphr.h"
|
||||
#include "freertos/task.h"
|
||||
|
||||
#include "effects.h"
|
||||
#include "patterns.h"
|
||||
#include "settings.h"
|
||||
#include "ws2812.h"
|
||||
|
||||
#define RMT_LED_STRIP_GPIO_NUM GPIO_NUM_10
|
||||
#define EXAMPLE_LED_NUMBERS 119
|
||||
#define FRAME_MS 20
|
||||
#define FRAME_MS 10
|
||||
|
||||
static const char *TAG = "patterns";
|
||||
|
||||
static const char *const s_names[PM_COUNT] = {
|
||||
"solid", "rainbow", "chase", "breathe", "blink", "pulse", "transition", "circle",
|
||||
typedef bool (*fx_fn)(fx_t &, st_t &);
|
||||
struct pattern_def_t {
|
||||
const char *name;
|
||||
fx_fn fn;
|
||||
};
|
||||
|
||||
// Same names as the MicroPython led-driver patterns
|
||||
static const pattern_def_t kPatterns[] = {
|
||||
{ "off", fx_off },
|
||||
{ "on", fx_on },
|
||||
{ "blink", fx_blink },
|
||||
{ "aurora", fx_aurora },
|
||||
{ "bar_graph", fx_bar_graph },
|
||||
{ "blizzard", fx_blizzard },
|
||||
{ "candle_glow", fx_candle_glow },
|
||||
{ "chase", fx_chase },
|
||||
{ "circle", fx_circle },
|
||||
{ "clock_sweep", fx_clock_sweep },
|
||||
{ "colour_cycle", fx_colour_cycle },
|
||||
{ "field_wave", fx_field_wave },
|
||||
{ "flame", fx_flame },
|
||||
{ "flicker", fx_flicker },
|
||||
{ "gradient_wipe", fx_gradient_wipe },
|
||||
{ "grow", fx_grow },
|
||||
{ "hit", fx_hit },
|
||||
{ "icicles", fx_icicles },
|
||||
{ "keyframes", fx_keyframes },
|
||||
{ "meteor", fx_meteor },
|
||||
{ "orbit", fx_orbit },
|
||||
{ "palette_morph", fx_palette_morph },
|
||||
{ "particles", fx_particles },
|
||||
{ "plasma", fx_plasma },
|
||||
{ "pulse", fx_pulse },
|
||||
{ "radiate", fx_radiate },
|
||||
{ "rain_drops", fx_rain_drops },
|
||||
{ "rime", fx_rime },
|
||||
{ "ripple", fx_ripple },
|
||||
{ "sparkle", fx_sparkle },
|
||||
{ "spin", fx_spin },
|
||||
{ "strobe_burst", fx_strobe_burst },
|
||||
{ "sweep", fx_sweep },
|
||||
{ "transition", fx_transition },
|
||||
{ "twinkle", fx_twinkle },
|
||||
};
|
||||
#define PATTERN_COUNT ((int)(sizeof(kPatterns) / sizeof(kPatterns[0])))
|
||||
|
||||
static WS2812 *s_strip;
|
||||
static SemaphoreHandle_t s_lock;
|
||||
static pattern_params_t s_p = { PM_CHASE, { 255, 0, 0 }, { 0, 0, 0 }, 1000, 16 };
|
||||
static preset_t s_cur; // the preset requested (under s_lock)
|
||||
static bool s_reset_pending; // a new pattern was selected (under s_lock)
|
||||
|
||||
const char *patterns_mode_name(pattern_mode_t m)
|
||||
static preset_t s_run; // the preset the task is running
|
||||
static fx_t s_fx; // shadow frame and timing for the running pattern
|
||||
st_t g_st; // state of the running pattern
|
||||
|
||||
// Crossfade: the last frame shown, and the frame it fades from
|
||||
static rgb *s_shown; // last frame shown (s_cap entries)
|
||||
static rgb *s_from; // frame the crossfade starts from
|
||||
static int s_cap; // LEDs the buffers are sized for
|
||||
static bool s_fading;
|
||||
|
||||
// DDP: pixels sent by a controller. While they keep arriving they replace the pattern.
|
||||
#define DDP_TIMEOUT_MS 2000
|
||||
static uint8_t s_ddp[FX_LEDS_MAX * 3];
|
||||
static uint32_t s_ddp_last_ms; // 0: never
|
||||
static bool s_ddp_was;
|
||||
static uint32_t s_ddp_packets;
|
||||
static uint32_t s_ddp_frames; // frames completed (PUSH seen)
|
||||
static uint32_t s_ddp_sum; // checksum of the last completed frame
|
||||
static uint32_t s_ddp_log_ms; // last serial summary
|
||||
static uint8_t s_max_brightness = 255;
|
||||
static uint8_t s_global = 255;
|
||||
static uint32_t s_fade_t0;
|
||||
static uint32_t s_fade_ms;
|
||||
|
||||
int patterns_count(void)
|
||||
{
|
||||
return (m >= 0 && m < PM_COUNT) ? s_names[m] : "";
|
||||
return PATTERN_COUNT;
|
||||
}
|
||||
|
||||
pattern_mode_t patterns_mode_from_name(const char *name)
|
||||
const char *patterns_name(int i)
|
||||
{
|
||||
for (int i = 0; i < PM_COUNT; i++) {
|
||||
if (strcmp(name, s_names[i]) == 0) {
|
||||
return (pattern_mode_t)i;
|
||||
return (i >= 0 && i < PATTERN_COUNT) ? kPatterns[i].name : "";
|
||||
}
|
||||
|
||||
int patterns_index(const char *name)
|
||||
{
|
||||
for (int i = 0; i < PATTERN_COUNT; i++) {
|
||||
if (strcmp(name, kPatterns[i].name) == 0) {
|
||||
return i;
|
||||
}
|
||||
}
|
||||
return PM_COUNT;
|
||||
return -1;
|
||||
}
|
||||
|
||||
void patterns_set(const pattern_params_t &p)
|
||||
void preset_defaults(preset_t *p, int pattern)
|
||||
{
|
||||
pattern_params_t q = p;
|
||||
if (q.speed_ms < 10) q.speed_ms = 10;
|
||||
if (q.speed_ms > 10000) q.speed_ms = 10000;
|
||||
if (q.mode >= PM_COUNT) q.mode = PM_SOLID;
|
||||
memset(p, 0, sizeof(*p));
|
||||
p->pattern = pattern;
|
||||
p->ncol = 0;
|
||||
p->delay = 100;
|
||||
p->brightness = 127;
|
||||
p->autorun = true;
|
||||
p->reverse = false;
|
||||
p->fade = 0;
|
||||
p->beat_time = false;
|
||||
}
|
||||
|
||||
// Keep a preset within the ranges the patterns expect
|
||||
static void sanitize(preset_t *p)
|
||||
{
|
||||
if (p->pattern < 0 || p->pattern >= PATTERN_COUNT) {
|
||||
p->pattern = 0;
|
||||
}
|
||||
if (p->delay < 10) p->delay = 10;
|
||||
if (p->delay > 10000) p->delay = 10000;
|
||||
if (p->ncol < 0) p->ncol = 0;
|
||||
if (p->ncol > PATTERN_MAX_COLOURS) p->ncol = PATTERN_MAX_COLOURS;
|
||||
if (p->fade > 10000) p->fade = 10000;
|
||||
for (int i = 1; i <= 6; i++) {
|
||||
if (p->n[i] < 0) p->n[i] = 0;
|
||||
if (p->n[i] > 100000) p->n[i] = 100000;
|
||||
}
|
||||
}
|
||||
|
||||
// Live update: a change of pattern restarts it (with a crossfade if the preset asks); other changes
|
||||
// take effect straight away, keeping the pattern's place
|
||||
void patterns_set(const preset_t &p)
|
||||
{
|
||||
preset_t q = p;
|
||||
sanitize(&q);
|
||||
xSemaphoreTake(s_lock, portMAX_DELAY);
|
||||
s_p = q;
|
||||
bool changed = q.pattern != s_cur.pattern;
|
||||
s_cur = q;
|
||||
if (changed) {
|
||||
s_reset_pending = true;
|
||||
}
|
||||
xSemaphoreGive(s_lock);
|
||||
}
|
||||
|
||||
pattern_params_t patterns_get(void)
|
||||
// Select a preset: always restarts the pattern, crossfading in from the frame on the strip
|
||||
void patterns_select(const preset_t &p)
|
||||
{
|
||||
preset_t q = p;
|
||||
sanitize(&q);
|
||||
xSemaphoreTake(s_lock, portMAX_DELAY);
|
||||
s_cur = q;
|
||||
s_reset_pending = true;
|
||||
xSemaphoreGive(s_lock);
|
||||
}
|
||||
|
||||
void patterns_set_global(uint8_t level)
|
||||
{
|
||||
xSemaphoreTake(s_lock, portMAX_DELAY);
|
||||
pattern_params_t p = s_p;
|
||||
s_global = level;
|
||||
xSemaphoreGive(s_lock);
|
||||
return p;
|
||||
}
|
||||
|
||||
// Linear blend from a (k=0) to b (k=255)
|
||||
static void lerp(const uint8_t *a, const uint8_t *b, uint32_t k, uint8_t *out)
|
||||
uint8_t patterns_get_global(void)
|
||||
{
|
||||
for (int i = 0; i < 3; i++) {
|
||||
out[i] = (uint8_t)(a[i] + ((int)b[i] - a[i]) * (int)k / 255);
|
||||
}
|
||||
xSemaphoreTake(s_lock, portMAX_DELAY);
|
||||
uint8_t v = s_global;
|
||||
xSemaphoreGive(s_lock);
|
||||
return v;
|
||||
}
|
||||
|
||||
// Draw one frame of the pattern at time t (ms since the start of the pattern)
|
||||
static void render(const pattern_params_t &p, uint32_t t, WS2812 &s)
|
||||
void patterns_get(preset_t *out)
|
||||
{
|
||||
const size_t n = s.size();
|
||||
const uint32_t sp = p.speed_ms;
|
||||
uint8_t col[3];
|
||||
xSemaphoreTake(s_lock, portMAX_DELAY);
|
||||
*out = s_cur;
|
||||
xSemaphoreGive(s_lock);
|
||||
}
|
||||
|
||||
switch (p.mode) {
|
||||
case PM_SOLID:
|
||||
s.fill(p.c1[0], p.c1[1], p.c1[2]);
|
||||
break;
|
||||
static uint32_t now_ms(void)
|
||||
{
|
||||
return (uint32_t)(esp_timer_get_time() / 1000);
|
||||
}
|
||||
|
||||
case PM_RAINBOW: {
|
||||
uint32_t off = (t / sp) % 360;
|
||||
for (size_t i = 0; i < n; i++) {
|
||||
uint32_t r, g, b;
|
||||
WS2812::hsv2rgb((i * 360 / n + off) % 360, 100, 100, &r, &g, &b);
|
||||
s.set(i, r, g, b);
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
case PM_CHASE: {
|
||||
// Every third LED lit, moving one step per speed_ms; hue shifts each full cycle
|
||||
uint32_t step = t / sp;
|
||||
uint32_t phase = step % 3;
|
||||
uint32_t off = ((step / 3) * 60) % 360;
|
||||
s.fill(0, 0, 0);
|
||||
for (size_t j = phase; j < n; j += 3) {
|
||||
uint32_t r, g, b;
|
||||
WS2812::hsv2rgb((j * 360 / n + off) % 360, 100, 100, &r, &g, &b);
|
||||
s.set(j, r, g, b);
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
case PM_BREATHE: {
|
||||
uint32_t period = sp * 2 < 500 ? 500 : sp * 2;
|
||||
uint32_t ph = t % period;
|
||||
uint32_t k = ph * 2 < period ? (ph * 2 * 255) / period : ((period - ph) * 2 * 255) / period;
|
||||
lerp(p.c2, p.c1, k, col);
|
||||
s.fill(col[0], col[1], col[2]);
|
||||
break;
|
||||
}
|
||||
|
||||
case PM_BLINK:
|
||||
if ((t / sp) % 2 == 0) {
|
||||
s.fill(p.c1[0], p.c1[1], p.c1[2]);
|
||||
// Show the shadow frame, crossfading from the previous frame while a fade runs
|
||||
static void output(uint32_t now)
|
||||
{
|
||||
int s_scale = s_global * s_max_brightness / 255; // global brightness under the ceiling
|
||||
int k = -1;
|
||||
if (s_fading) {
|
||||
uint32_t el = now - s_fade_t0;
|
||||
if (el >= s_fade_ms) {
|
||||
s_fading = false;
|
||||
} else {
|
||||
s.fill(p.c2[0], p.c2[1], p.c2[2]);
|
||||
k = (int)((el * 256) / s_fade_ms);
|
||||
}
|
||||
break;
|
||||
|
||||
case PM_PULSE: {
|
||||
// Attack over the first 10% of the period, then a linear decay back to c2
|
||||
uint32_t period = sp * 2 < 200 ? 200 : sp * 2;
|
||||
uint32_t frac = ((t % period) * 1000) / period;
|
||||
uint32_t k = frac < 100 ? frac * 255 / 100 : (1000 - frac) * 255 / 900;
|
||||
lerp(p.c2, p.c1, k, col);
|
||||
s.fill(col[0], col[1], col[2]);
|
||||
break;
|
||||
}
|
||||
|
||||
case PM_TRANSITION: {
|
||||
// c1 -> c2 over speed_ms, then back again
|
||||
uint32_t period = 2 * sp;
|
||||
uint32_t ph = t % period;
|
||||
uint32_t k = ph < sp ? ph * 255 / sp : (period - ph) * 255 / sp;
|
||||
lerp(p.c1, p.c2, k, col);
|
||||
s.fill(col[0], col[1], col[2]);
|
||||
break;
|
||||
}
|
||||
|
||||
case PM_CIRCLE: {
|
||||
// A segment a third of the strip long, moving around the ring
|
||||
size_t head = (t / sp) % n;
|
||||
size_t len = n / 3 < 1 ? 1 : n / 3;
|
||||
for (size_t i = 0; i < n; i++) {
|
||||
size_t dist = (head + n - i) % n;
|
||||
if (dist < len) {
|
||||
s.set(i, p.c1[0], p.c1[1], p.c1[2]);
|
||||
} else {
|
||||
s.set(i, p.c2[0], p.c2[1], p.c2[2]);
|
||||
}
|
||||
for (int i = 0; i < s_fx.n; i++) {
|
||||
rgb c = s_fx.px[i];
|
||||
c.r = c.r * s_scale / 255;
|
||||
c.g = c.g * s_scale / 255;
|
||||
c.b = c.b * s_scale / 255;
|
||||
if (k >= 0) {
|
||||
rgb a = s_from[i];
|
||||
c.r = (a.r * (256 - k) + c.r * k) >> 8;
|
||||
c.g = (a.g * (256 - k) + c.g * k) >> 8;
|
||||
c.b = (a.b * (256 - k) + c.b * k) >> 8;
|
||||
}
|
||||
break;
|
||||
s_strip->set(i, c.r, c.g, c.b);
|
||||
s_shown[i] = c;
|
||||
}
|
||||
|
||||
default:
|
||||
break;
|
||||
esp_err_t err = s_strip->write();
|
||||
if (err != ESP_OK) {
|
||||
ESP_LOGW(TAG, "LED write failed: %s", esp_err_to_name(err));
|
||||
}
|
||||
}
|
||||
|
||||
// ---- per-LED buffers --------------------------------------------------------------------------
|
||||
|
||||
bool frame_alloc(int n)
|
||||
{
|
||||
if (n < 1) n = 1;
|
||||
if (n > FX_LEDS_MAX) n = FX_LEDS_MAX;
|
||||
void *fresh[12] = {
|
||||
calloc(n, sizeof(rgb)), calloc(n, sizeof(rgb)), calloc(n, sizeof(rgb)),
|
||||
calloc(n, sizeof(int)), calloc(n, sizeof(float)), calloc(n, sizeof(int)),
|
||||
calloc(n, 1), calloc(n, 1),
|
||||
calloc(n, sizeof(int)), calloc(n, sizeof(int)),
|
||||
calloc(n, sizeof(int)), calloc(n, sizeof(int)),
|
||||
};
|
||||
for (int k = 0; k < 12; k++) {
|
||||
if (!fresh[k]) {
|
||||
for (int j = 0; j < 12; j++) free(fresh[j]);
|
||||
ESP_LOGE(TAG, "Out of memory for %d LEDs", n);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
free(s_fx.px);
|
||||
free(s_shown);
|
||||
free(s_from);
|
||||
free(g_st.glow);
|
||||
free(g_st.m);
|
||||
free(g_st.shade);
|
||||
free(g_st.on);
|
||||
free(g_st.next_on);
|
||||
free(g_st.col_i);
|
||||
free(g_st.next_ci);
|
||||
free(g_st.light);
|
||||
free(g_st.dark);
|
||||
s_fx.px = (rgb *)fresh[0];
|
||||
s_shown = (rgb *)fresh[1];
|
||||
s_from = (rgb *)fresh[2];
|
||||
g_st.glow = (int *)fresh[3];
|
||||
g_st.m = (float *)fresh[4];
|
||||
g_st.shade = (int *)fresh[5];
|
||||
g_st.on = (uint8_t *)fresh[6];
|
||||
g_st.next_on = (uint8_t *)fresh[7];
|
||||
g_st.col_i = (int *)fresh[8];
|
||||
g_st.next_ci = (int *)fresh[9];
|
||||
g_st.light = (int *)fresh[10];
|
||||
g_st.dark = (int *)fresh[11];
|
||||
s_cap = n;
|
||||
return true;
|
||||
}
|
||||
|
||||
void st_reset(void)
|
||||
{
|
||||
int *glow = g_st.glow, *shade = g_st.shade, *col_i = g_st.col_i, *next_ci = g_st.next_ci;
|
||||
int *light = g_st.light, *dark = g_st.dark;
|
||||
float *m = g_st.m;
|
||||
uint8_t *on = g_st.on, *next_on = g_st.next_on;
|
||||
memset(&g_st, 0, sizeof(g_st));
|
||||
g_st.glow = glow;
|
||||
g_st.shade = shade;
|
||||
g_st.col_i = col_i;
|
||||
g_st.next_ci = next_ci;
|
||||
g_st.light = light;
|
||||
g_st.dark = dark;
|
||||
g_st.m = m;
|
||||
g_st.on = on;
|
||||
g_st.next_on = next_on;
|
||||
memset(glow, 0, s_cap * sizeof(int));
|
||||
memset(shade, 0, s_cap * sizeof(int));
|
||||
memset(col_i, 0, s_cap * sizeof(int));
|
||||
memset(next_ci, 0, s_cap * sizeof(int));
|
||||
memset(light, 0, s_cap * sizeof(int));
|
||||
memset(dark, 0, s_cap * sizeof(int));
|
||||
memset(m, 0, s_cap * sizeof(float));
|
||||
memset(on, 0, s_cap);
|
||||
memset(next_on, 0, s_cap);
|
||||
}
|
||||
|
||||
// The whole frame (pattern and output) runs under s_lock, so the buffers can't be replaced mid-frame
|
||||
static void patterns_task(void *arg)
|
||||
{
|
||||
(void)arg;
|
||||
const uint32_t t0 = (uint32_t)(esp_timer_get_time() / 1000);
|
||||
s_fx.pr = &s_run;
|
||||
while (true) {
|
||||
pattern_params_t p = patterns_get();
|
||||
uint32_t now = (uint32_t)(esp_timer_get_time() / 1000);
|
||||
s_strip->setBrightness(p.brightness);
|
||||
render(p, now - t0, *s_strip);
|
||||
esp_err_t err = s_strip->write();
|
||||
if (err != ESP_OK) {
|
||||
ESP_LOGW(TAG, "LED write failed: %s", esp_err_to_name(err));
|
||||
xSemaphoreTake(s_lock, portMAX_DELAY);
|
||||
bool reset = s_reset_pending;
|
||||
s_reset_pending = false;
|
||||
s_run = s_cur;
|
||||
uint32_t now = now_ms();
|
||||
bool ddp_on = s_ddp_last_ms != 0 && now - s_ddp_last_ms < DDP_TIMEOUT_MS;
|
||||
if (!ddp_on && s_ddp_was) {
|
||||
reset = true; // the pattern starts again when the pixels stop
|
||||
}
|
||||
s_ddp_was = ddp_on;
|
||||
if (reset) {
|
||||
if (s_run.fade > 0) {
|
||||
memcpy(s_from, s_shown, s_fx.n * sizeof(rgb));
|
||||
s_fading = true;
|
||||
s_fade_t0 = now;
|
||||
s_fade_ms = s_run.fade;
|
||||
} else {
|
||||
s_fading = false;
|
||||
}
|
||||
st_reset();
|
||||
g_st.t0 = now;
|
||||
}
|
||||
s_fx.now = now;
|
||||
s_fx.t = now - g_st.t0;
|
||||
if (ddp_on) {
|
||||
for (int i = 0; i < s_fx.n; i++) {
|
||||
s_fx.px[i] = { s_ddp[3 * i], s_ddp[3 * i + 1], s_ddp[3 * i + 2] };
|
||||
}
|
||||
} else if (!g_st.done) {
|
||||
if (kPatterns[s_run.pattern].fn(s_fx, g_st)) {
|
||||
g_st.done = true;
|
||||
}
|
||||
}
|
||||
output(now);
|
||||
xSemaphoreGive(s_lock);
|
||||
vTaskDelay(pdMS_TO_TICKS(FRAME_MS));
|
||||
}
|
||||
}
|
||||
|
||||
void patterns_start(void)
|
||||
static int clamp_leds(int n)
|
||||
{
|
||||
return n < 1 ? 1 : (n > FX_LEDS_MAX ? FX_LEDS_MAX : n);
|
||||
}
|
||||
|
||||
void patterns_start(const hw_cfg_t &hw)
|
||||
{
|
||||
s_lock = xSemaphoreCreateMutex();
|
||||
s_strip = new WS2812(RMT_LED_STRIP_GPIO_NUM, EXAMPLE_LED_NUMBERS);
|
||||
xTaskCreate(patterns_task, "patterns", 4096, NULL, 5, NULL);
|
||||
ESP_LOGI(TAG, "Started %d LEDs on GPIO %d", EXAMPLE_LED_NUMBERS, (int)RMT_LED_STRIP_GPIO_NUM);
|
||||
preset_defaults(&s_cur, 0);
|
||||
preset_defaults(&s_run, 0);
|
||||
s_cur.pattern = patterns_index("chase");
|
||||
s_cur.delay = 1000;
|
||||
s_cur.brightness = 16;
|
||||
s_cur.col[0][0] = 255;
|
||||
s_reset_pending = true;
|
||||
|
||||
int n = clamp_leds(hw.num_leds);
|
||||
if (!frame_alloc(n)) {
|
||||
ESP_ERROR_CHECK(ESP_ERR_NO_MEM);
|
||||
}
|
||||
s_fx.n = n;
|
||||
s_max_brightness = hw.max_brightness;
|
||||
s_global = hw.global_brightness;
|
||||
s_strip = new WS2812((gpio_num_t)hw.pin, n);
|
||||
s_strip->setOrder(hw.order);
|
||||
s_strip->setBrightness(255); // brightness is applied per colour by the patterns
|
||||
xTaskCreate(patterns_task, "patterns", 6144, NULL, 5, NULL);
|
||||
ESP_LOGI(TAG, "Started %d LEDs on GPIO %d (%s), %d patterns", n, hw.pin, hw.order, PATTERN_COUNT);
|
||||
}
|
||||
|
||||
// Change the strip: count, byte order and brightness ceiling. The buffers and the driver are replaced
|
||||
// under the lock the frame runs under; on out-of-memory the old strip is kept.
|
||||
esp_err_t patterns_set_hardware(const hw_cfg_t &hw)
|
||||
{
|
||||
int n = clamp_leds(hw.num_leds);
|
||||
xSemaphoreTake(s_lock, portMAX_DELAY);
|
||||
if (!frame_alloc(n)) {
|
||||
xSemaphoreGive(s_lock);
|
||||
return ESP_ERR_NO_MEM;
|
||||
}
|
||||
s_fx.n = n;
|
||||
delete s_strip;
|
||||
s_strip = new WS2812((gpio_num_t)hw.pin, n);
|
||||
s_strip->setOrder(hw.order);
|
||||
s_strip->setBrightness(255);
|
||||
s_max_brightness = hw.max_brightness;
|
||||
s_fading = false;
|
||||
s_reset_pending = true;
|
||||
xSemaphoreGive(s_lock);
|
||||
ESP_LOGI(TAG, "LED strip: %d LEDs on GPIO %d, %s, max brightness %u, free heap %u", n, hw.pin, hw.order,
|
||||
(unsigned)hw.max_brightness, (unsigned)esp_get_free_heap_size());
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
// ---- DDP ---------------------------------------------------------------------------------------
|
||||
|
||||
void patterns_ddp_write(uint32_t offset, const uint8_t *data, size_t len, bool push)
|
||||
{
|
||||
xSemaphoreTake(s_lock, portMAX_DELAY);
|
||||
size_t cap = (size_t)s_fx.n * 3;
|
||||
if (offset < cap) {
|
||||
if (offset + len > cap) {
|
||||
len = cap - offset;
|
||||
}
|
||||
memcpy(s_ddp + offset, data, len);
|
||||
}
|
||||
uint32_t now = now_ms();
|
||||
s_ddp_last_ms = now | 1; // never 0
|
||||
s_ddp_packets++;
|
||||
if (push) {
|
||||
s_ddp_frames++;
|
||||
uint32_t sum = 0;
|
||||
for (size_t i = 0; i < cap; i++) {
|
||||
sum += s_ddp[i];
|
||||
}
|
||||
s_ddp_sum = sum;
|
||||
// Summary on the serial log, at most twice a second, so the test can check what was shown
|
||||
if (now - s_ddp_log_ms >= 500) {
|
||||
s_ddp_log_ms = now;
|
||||
ESP_LOGI(TAG, "DDP frames=%u packets=%u sum=%u led0=%u,%u,%u led_last=%u,%u,%u",
|
||||
(unsigned)s_ddp_frames, (unsigned)s_ddp_packets, (unsigned)s_ddp_sum,
|
||||
s_ddp[0], s_ddp[1], s_ddp[2],
|
||||
s_ddp[cap - 3], s_ddp[cap - 2], s_ddp[cap - 1]);
|
||||
}
|
||||
}
|
||||
xSemaphoreGive(s_lock);
|
||||
}
|
||||
|
||||
void patterns_ddp_status(bool *active, uint32_t *packets)
|
||||
{
|
||||
xSemaphoreTake(s_lock, portMAX_DELAY);
|
||||
*active = s_ddp_last_ms != 0 && now_ms() - s_ddp_last_ms < DDP_TIMEOUT_MS;
|
||||
*packets = s_ddp_packets;
|
||||
xSemaphoreGive(s_lock);
|
||||
}
|
||||
|
||||
void patterns_shown_pixel(int i, uint8_t out[3])
|
||||
{
|
||||
xSemaphoreTake(s_lock, portMAX_DELAY);
|
||||
if (i >= 0 && i < s_fx.n) {
|
||||
out[0] = (uint8_t)s_shown[i].r;
|
||||
out[1] = (uint8_t)s_shown[i].g;
|
||||
out[2] = (uint8_t)s_shown[i].b;
|
||||
}
|
||||
xSemaphoreGive(s_lock);
|
||||
}
|
||||
|
||||
Reference in new issue
Block a user