Files
led-driver/main/presets.cpp
T
jimmyandClaude Opus 5.5 24dd5ffb15 feat: ESP-NOW link, beat sync and control messages in the C++ driver
- espnow_link, ctrl_msg and beat_sync: the reliable link, envelopes and
  beat-synced timing.
- ctrl_msg: accept an envelope with the trailing save byte.
- patterns_frame() and espnow_link_poll() split out of their tasks, so the
  WebAssembly simulator can drive one frame and one link pass from a timer.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 19:32:36 +13:00

534 lines
15 KiB
C++

/*
* SPDX-License-Identifier: Apache-2.0
*
* Named presets, stored in NVS as one JSON list (as the MicroPython presets.json), with a startup preset.
*/
#include <cstdlib>
#include <cstring>
#include "cJSON.h"
#include "esp_log.h"
#include "nvs.h"
#include "presets.h"
static const char *TAG = "presets";
static const char *NS = "presets";
static preset_t s_list[PRESETS_MAX];
static size_t s_count;
static char s_startup[32];
static char s_selected[32];
static int find(const char *name)
{
for (size_t i = 0; i < s_count; i++) {
if (strcmp(s_list[i].name, name) == 0) {
return (int)i;
}
}
return -1;
}
static cJSON *rgb_json(const uint8_t *c)
{
cJSON *a = cJSON_CreateArray();
for (int i = 0; i < 3; i++) {
cJSON_AddItemToArray(a, cJSON_CreateNumber(c[i]));
}
return a;
}
static bool read_rgb(const cJSON *a, uint8_t *out)
{
// The controller sends colours as "#RRGGBB" text
if (cJSON_IsString(a)) {
const char *s = a->valuestring[0] == '#' ? a->valuestring + 1 : a->valuestring;
char *end = nullptr;
unsigned long v = strtoul(s, &end, 16);
if (end != s + 6 || s[0] == '+' || s[0] == '-' || s[0] == ' ') {
return false;
}
out[0] = (uint8_t)(v >> 16);
out[1] = (uint8_t)((v >> 8) & 0xFF);
out[2] = (uint8_t)(v & 0xFF);
return true;
}
if (!cJSON_IsArray(a) || cJSON_GetArraySize(a) != 3) {
return false;
}
for (int i = 0; i < 3; i++) {
cJSON *v = cJSON_GetArrayItem(a, i);
if (!cJSON_IsNumber(v)) {
return false;
}
int x = v->valueint;
out[i] = (uint8_t)(x < 0 ? 0 : (x > 255 ? 255 : x));
}
return true;
}
cJSON *preset_to_json(const preset_t *p)
{
cJSON *o = cJSON_CreateObject();
cJSON_AddStringToObject(o, "name", p->name);
cJSON_AddStringToObject(o, "pattern", patterns_name(p->pattern));
cJSON *colors = cJSON_AddArrayToObject(o, "colors");
for (int i = 0; i < p->ncol; i++) {
cJSON_AddItemToArray(colors, rgb_json(p->col[i]));
}
cJSON_AddItemToObject(o, "background", rgb_json(p->bg));
cJSON_AddNumberToObject(o, "delay", p->delay);
cJSON_AddNumberToObject(o, "brightness", p->brightness);
cJSON_AddBoolToObject(o, "auto", p->autorun);
cJSON_AddBoolToObject(o, "reverse", p->reverse);
cJSON_AddNumberToObject(o, "fade", p->fade);
cJSON_AddBoolToObject(o, "beat_time", p->beat_time);
cJSON_AddNumberToObject(o, "n1", p->n[1]);
cJSON_AddNumberToObject(o, "n2", p->n[2]);
cJSON_AddNumberToObject(o, "n3", p->n[3]);
cJSON_AddNumberToObject(o, "n4", p->n[4]);
cJSON_AddNumberToObject(o, "mode", p->n[6]); // n6: the pattern's style
return o;
}
bool preset_from_json(const cJSON *o, preset_t *p)
{
if (!cJSON_IsObject(o)) {
return false;
}
cJSON *v = cJSON_GetObjectItem(o, "name");
if (cJSON_IsString(v)) {
strncpy(p->name, v->valuestring, sizeof(p->name) - 1);
p->name[sizeof(p->name) - 1] = '\0';
}
v = cJSON_GetObjectItem(o, "pattern");
if (cJSON_IsString(v)) {
int idx = patterns_index(v->valuestring);
if (idx < 0) {
return false;
}
p->pattern = idx;
}
v = cJSON_GetObjectItem(o, "colors");
if (cJSON_IsArray(v)) {
int n = cJSON_GetArraySize(v);
if (n > PATTERN_MAX_COLOURS) n = PATTERN_MAX_COLOURS;
p->ncol = 0;
for (int i = 0; i < n; i++) {
if (read_rgb(cJSON_GetArrayItem(v, i), p->col[p->ncol])) {
p->ncol++;
}
}
}
read_rgb(cJSON_GetObjectItem(o, "background"), p->bg);
v = cJSON_GetObjectItem(o, "delay");
if (cJSON_IsNumber(v)) p->delay = (uint32_t)(v->valueint < 0 ? 0 : v->valueint);
v = cJSON_GetObjectItem(o, "brightness");
if (cJSON_IsNumber(v)) p->brightness = (uint8_t)(v->valueint < 0 ? 0 : (v->valueint > 255 ? 255 : v->valueint));
v = cJSON_GetObjectItem(o, "auto");
if (cJSON_IsBool(v)) p->autorun = cJSON_IsTrue(v);
v = cJSON_GetObjectItem(o, "reverse");
if (cJSON_IsBool(v)) p->reverse = cJSON_IsTrue(v);
v = cJSON_GetObjectItem(o, "fade");
if (cJSON_IsNumber(v)) p->fade = (uint32_t)(v->valueint < 0 ? 0 : v->valueint);
v = cJSON_GetObjectItem(o, "beat_time");
if (cJSON_IsBool(v)) p->beat_time = cJSON_IsTrue(v);
static const char *keys[] = { "n1", "n2", "n3", "n4", "n5", "n6" };
for (int i = 0; i < 6; i++) {
v = cJSON_GetObjectItem(o, keys[i]);
if (cJSON_IsNumber(v)) p->n[i + 1] = v->valueint;
}
v = cJSON_GetObjectItem(o, "mode");
if (cJSON_IsNumber(v)) p->n[6] = v->valueint;
return true;
}
// One key per preset ("p00".."p63"), so a save writes one small entry instead of the whole list.
// NVS_SLOTS is the most keys any build has written; the 24 KB nvs partition holds about 50 presets.
#define NVS_SLOTS 64
static void entry_key(char *out, size_t n, size_t i)
{
snprintf(out, n, "p%02u", (unsigned)i);
}
static esp_err_t save_entry(nvs_handle_t h, size_t i)
{
cJSON *o = preset_to_json(&s_list[i]);
char *s = cJSON_PrintUnformatted(o);
cJSON_Delete(o);
if (!s) {
return ESP_ERR_NO_MEM;
}
char key[8];
entry_key(key, sizeof(key), i);
esp_err_t err = nvs_set_str(h, key, s);
cJSON_free(s);
return err;
}
// Write every preset, the count and the startup name. Erases keys past the new count and the old blob.
static esp_err_t save_list(void)
{
nvs_handle_t h;
esp_err_t err = nvs_open(NS, NVS_READWRITE, &h);
if (err != ESP_OK) {
return err;
}
for (size_t i = 0; i < s_count && err == ESP_OK; i++) {
err = save_entry(h, i);
}
for (size_t i = s_count; i < NVS_SLOTS; i++) {
char key[8];
entry_key(key, sizeof(key), i);
nvs_erase_key(h, key); // also keys left by an older build with a bigger limit
}
nvs_erase_key(h, "list"); // the single blob written by older firmware
if (err == ESP_OK) err = nvs_set_u32(h, "n", (uint32_t)s_count);
if (err == ESP_OK) err = nvs_set_str(h, "startup", s_startup);
if (err == ESP_OK) err = nvs_commit(h);
nvs_close(h);
return err;
}
// Write one preset (slot idx) and the count
static esp_err_t save_one(size_t idx)
{
nvs_handle_t h;
esp_err_t err = nvs_open(NS, NVS_READWRITE, &h);
if (err != ESP_OK) {
return err;
}
err = save_entry(h, idx);
if (err == ESP_OK) err = nvs_set_u32(h, "n", (uint32_t)s_count);
if (err == ESP_OK) err = nvs_commit(h);
nvs_close(h);
return err;
}
// The presets a new board starts with (added by presets_add_defaults, and on a board that has none saved)
static int build_defaults(preset_t *out, int max)
{
int n = 0;
auto add = [&](const char *name, const char *pattern) -> preset_t * {
if (n >= max) {
return NULL;
}
preset_t *p = &out[n++];
preset_defaults(p, patterns_index(pattern));
strncpy(p->name, name, sizeof(p->name) - 1);
p->name[sizeof(p->name) - 1] = '\0';
return p;
};
preset_t *p;
if ((p = add("Rainbow", "colour_cycle"))) {
p->n[6] = 1; // rainbow wheel
p->n[1] = 2;
p->delay = 60;
p->brightness = 160;
}
if ((p = add("Chase", "chase"))) {
p->ncol = 2;
p->col[0][0] = 255; p->col[0][1] = 80; p->col[0][2] = 0;
p->col[1][0] = 0; p->col[1][1] = 120; p->col[1][2] = 255;
p->n[1] = 4; p->n[2] = 4; p->n[3] = 1; p->n[4] = 1;
p->delay = 150;
p->brightness = 180;
}
if ((p = add("Chase Marquee", "chase"))) {
p->ncol = 1;
p->col[0][0] = 255; p->col[0][1] = 200; p->col[0][2] = 80;
p->n[1] = 3; p->n[2] = 2; p->n[3] = 1; p->n[6] = 1; // dashes that scroll
p->delay = 120;
p->brightness = 180;
}
if ((p = add("Chase Reverse", "chase"))) {
p->ncol = 2;
p->col[0][0] = 0; p->col[0][1] = 255; p->col[0][2] = 120;
p->col[1][0] = 120; p->col[1][1] = 0; p->col[1][2] = 255;
p->n[1] = 6; p->n[2] = 6; p->n[3] = -1; p->n[4] = -1; // negative steps run it backwards
p->delay = 120;
p->brightness = 180;
}
if ((p = add("Aurora", "aurora"))) {
p->n[1] = 3;
p->n[2] = 40;
p->delay = 40;
p->brightness = 150;
}
if ((p = add("Candle", "candle_glow"))) {
p->ncol = 3;
p->col[0][0] = 255; p->col[0][1] = 140; p->col[0][2] = 40;
p->col[1][0] = 255; p->col[1][1] = 200; p->col[1][2] = 120;
p->col[2][0] = 255; p->col[2][1] = 90; p->col[2][2] = 20;
p->n[1] = 4; p->n[2] = 3; p->n[3] = 90;
p->delay = 120;
p->brightness = 200;
}
if ((p = add("Twinkle", "twinkle"))) {
p->ncol = 1;
p->col[0][0] = 200; p->col[0][1] = 220; p->col[0][2] = 255;
p->bg[2] = 20;
p->n[1] = 48; p->n[2] = 128;
p->delay = 100;
p->brightness = 200;
}
if ((p = add("Flame", "flame"))) {
p->delay = 40;
p->brightness = 255;
p->n[2] = 2500;
}
if ((p = add("Sweep", "sweep"))) {
p->ncol = 2;
p->col[0][0] = 255; p->col[0][1] = 0; p->col[0][2] = 120;
p->col[1][0] = 0; p->col[1][1] = 200; p->col[1][2] = 255;
p->n[1] = 90; p->n[2] = 200; p->n[3] = 200;
p->delay = 2000;
p->brightness = 200;
}
if ((p = add("Off", "off"))) {
p->brightness = 255;
}
return n;
}
// Add the default presets whose names aren't in the list yet. Returns how many were added.
int presets_add_defaults(void)
{
preset_t defs[16];
int n = build_defaults(defs, 16);
int added = 0;
for (int i = 0; i < n; i++) {
if (find(defs[i].name) < 0 && s_count < PRESETS_MAX) {
s_list[s_count++] = defs[i];
added++;
}
}
if (added > 0) {
save_list();
}
return added;
}
// Read the one JSON list written by older firmware. Returns false if there is none.
static bool load_legacy(nvs_handle_t h)
{
size_t len = 0;
if (nvs_get_blob(h, "list", NULL, &len) != ESP_OK || len == 0) {
return false;
}
char *buf = (char *)malloc(len + 1);
if (!buf) {
return false;
}
bool ok = false;
if (nvs_get_blob(h, "list", buf, &len) == ESP_OK) {
buf[len] = '\0';
cJSON *arr = cJSON_Parse(buf);
cJSON *o;
cJSON_ArrayForEach(o, arr) {
if (s_count >= PRESETS_MAX) break;
preset_t p;
preset_defaults(&p, 0);
if (preset_from_json(o, &p) && p.name[0]) {
s_list[s_count++] = p;
}
}
cJSON_Delete(arr);
ok = true;
}
free(buf);
return ok;
}
static void load_entry(nvs_handle_t h, uint32_t i)
{
char key[8];
entry_key(key, sizeof(key), i);
size_t len = 0;
if (nvs_get_str(h, key, NULL, &len) != ESP_OK || len == 0) {
return;
}
char *buf = (char *)malloc(len);
if (!buf) {
return;
}
if (nvs_get_str(h, key, buf, &len) == ESP_OK) {
cJSON *o = cJSON_Parse(buf);
preset_t p;
preset_defaults(&p, 0);
if (o && preset_from_json(o, &p) && p.name[0] && s_count < PRESETS_MAX) {
s_list[s_count++] = p;
}
cJSON_Delete(o);
}
free(buf);
}
esp_err_t presets_init(void)
{
s_count = 0;
s_startup[0] = '\0';
s_selected[0] = '\0';
nvs_handle_t h;
if (nvs_open(NS, NVS_READONLY, &h) != ESP_OK) {
presets_add_defaults(); // a new board
return ESP_OK;
}
uint32_t n = 0;
bool have_list = nvs_get_u32(h, "n", &n) == ESP_OK;
bool legacy = false;
if (have_list) {
if (n > PRESETS_MAX) {
ESP_LOGW(TAG, "%u presets saved, room for %d: the rest are not loaded", (unsigned)n, PRESETS_MAX);
}
for (uint32_t i = 0; i < n && i < PRESETS_MAX; i++) {
load_entry(h, i);
}
} else {
legacy = load_legacy(h);
have_list = legacy;
}
size_t len = sizeof(s_startup);
if (nvs_get_str(h, "startup", s_startup, &len) != ESP_OK) {
s_startup[0] = '\0';
}
nvs_close(h);
if (legacy) {
save_list(); // move the old blob to per-preset keys
}
if (!have_list) {
presets_add_defaults(); // nothing saved yet: start with the defaults
}
ESP_LOGI(TAG, "%u presets loaded", (unsigned)s_count);
for (size_t i = 0; i < s_count; i++) {
ESP_LOGI(TAG, " [%u] %s", (unsigned)i, s_list[i].name);
}
return ESP_OK;
}
size_t presets_count(void)
{
return s_count;
}
const preset_t *presets_at(size_t i)
{
return i < s_count ? &s_list[i] : NULL;
}
static uint32_t s_dropped; // saves refused because the store was full
uint32_t presets_dropped(void)
{
return s_dropped;
}
esp_err_t presets_save(const preset_t *preset)
{
int idx = find(preset->name);
bool added = idx < 0;
if (added) {
if (s_count >= PRESETS_MAX) {
s_dropped++;
ESP_LOGW(TAG, "store full (%d presets): '%s' not saved", PRESETS_MAX, preset->name);
return ESP_ERR_NO_MEM;
}
idx = (int)s_count++;
}
s_list[idx] = *preset;
ESP_LOGI(TAG, "save '%s' (%s), %u presets", preset->name, added ? "new" : "update", (unsigned)s_count);
esp_err_t err = save_one((size_t)idx);
if (err != ESP_OK) {
s_dropped++;
ESP_LOGW(TAG, "'%s' not saved to flash: %s", preset->name, esp_err_to_name(err));
if (added) {
s_count--; // keep RAM and flash the same
}
}
return err;
}
esp_err_t presets_set_order(const char *const *names, size_t n)
{
// Static: this is too big for the HTTP server's task stack, and only that task calls it
static preset_t fresh[PRESETS_MAX];
bool used[PRESETS_MAX] = { false };
size_t m = 0;
for (size_t k = 0; k < n && m < s_count; k++) {
int idx = find(names[k]);
if (idx >= 0 && !used[idx]) {
used[idx] = true;
fresh[m++] = s_list[idx];
}
}
for (size_t i = 0; i < s_count; i++) {
if (!used[i]) {
fresh[m++] = s_list[i];
}
}
memcpy(s_list, fresh, m * sizeof(preset_t));
ESP_LOGI(TAG, "order: %u presets (was %u)", (unsigned)m, (unsigned)s_count);
s_count = m;
return save_list();
}
esp_err_t presets_delete(const char *name)
{
int idx = find(name);
if (idx < 0) {
return ESP_ERR_NOT_FOUND;
}
for (size_t i = (size_t)idx; i + 1 < s_count; i++) {
s_list[i] = s_list[i + 1];
}
s_count--;
ESP_LOGI(TAG, "delete '%s', %u presets", name, (unsigned)s_count);
if (strcmp(s_startup, name) == 0) {
s_startup[0] = '\0';
}
if (strcmp(s_selected, name) == 0) {
s_selected[0] = '\0';
}
return save_list();
}
esp_err_t presets_select(const char *name)
{
int idx = find(name);
if (idx < 0) {
return ESP_ERR_NOT_FOUND;
}
patterns_select(s_list[idx]);
strncpy(s_selected, name, sizeof(s_selected) - 1);
s_selected[sizeof(s_selected) - 1] = '\0';
return ESP_OK;
}
const char *presets_selected(void)
{
return s_selected;
}
esp_err_t presets_set_startup(const char *name)
{
if (name[0] && find(name) < 0) {
return ESP_ERR_NOT_FOUND;
}
strncpy(s_startup, name, sizeof(s_startup) - 1);
s_startup[sizeof(s_startup) - 1] = '\0';
return save_list();
}
const char *presets_startup(void)
{
return s_startup;
}
void presets_apply_startup(void)
{
if (s_startup[0] && presets_select(s_startup) == ESP_OK) {
ESP_LOGI(TAG, "Startup preset: %s", s_startup);
}
}