/* * 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 #include #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); } }