- 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>
534 lines
15 KiB
C++
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);
|
|
}
|
|
}
|