feat: browser simulator served by the controller, desktop build, browser bridge

- led-simulator: the rig runs the C++ led-driver as WebAssembly (sim-driver/),
  one single-threaded worker per bar, no cross-origin isolation needed. Rooms
  (one JSON per room) with an on-page editor, and a pattern gallery. The
  Python server, Pyodide boot and ring buffer are removed.
- sim-controller sim_rig.c: serves /sim/ from an embedded pack, the page's
  WebSocket and the rooms/flash API. The desktop build embeds it too.
- bridge.c: a "browser" bridge kind that carries ESP-NOW frames to the page;
  devices announced through it are marked sim.
- UI: Simulator in the Menu, split view with resize and pop-out, swipe
  between controller and rig on phones; SIM/REAL badges in Devices.
- Fades: preset pushes and Wi-Fi driver bodies always carry fade and
  beat_time, so "off" no longer inherits an earlier fade.
- Also the sequences-v2 work in progress: desktop port, bridge firmware,
  serial bridge, Wi-Fi drivers, sequence timeline, audio and API changes.
- led-driver: ESP-NOW link, beat sync, control messages, sim hooks.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
jimmyandClaude Opus 5.5 committed 2026-11-16 19:32:46 +13:00
1 parent 698c1463c0
commit 581b751904
506 files changed
+42336 -3599

No files matched your search

+11 -3
View File
@@ -1,6 +1,14 @@
idf_component_register(SRCS "sim_main.c" "sim_stubs.c" "sim_timer.c"
INCLUDE_DIRS "include"
REQUIRES esp_http_server esp_timer esp_event json main freertos)
idf_component_register(SRCS "sim_main.c" "sim_stubs.c" "sim_timer.c" "sim_rig.c"
INCLUDE_DIRS "include" "."
REQUIRES esp_http_server esp_timer esp_event cjson main freertos)
target_link_libraries(${COMPONENT_LIB} INTERFACE m)
# main's objects need esp_timer and libm, which come after it on the link line: link sim (and libm) last
target_link_libraries(__idf_main INTERFACE ${COMPONENT_LIB} m)
# The simulated rig's page and drivers (tools/build_sim_web.sh), served at /sim/. Without it the program still
# builds: an empty pack, and /sim/ says how to build the rig.
set(SIM_PACK ${COMPONENT_DIR}/../../../www_dist/sim.pack)
if(NOT EXISTS ${SIM_PACK})
file(WRITE ${SIM_PACK} "WWW1")
endif()
target_add_binary_data(${COMPONENT_LIB} ${SIM_PACK} BINARY)
+43 -16
View File
@@ -1,11 +1,12 @@
/*
* led-controller on the host (ESP-IDF linux target), for led-simulator.
* led-controller on the host (ESP-IDF linux target, and the desktop build), with the simulated rig.
*
* The same firmware sources as the board, minus the hardware: no Ethernet, Wi-Fi, mic or OTA.
* ESP-NOW frames go to the UDP bridge (led-simulator/bridge_sim.py) instead of the radio.
* ESP-NOW frames go to the bridges in settings instead of the radio. With none set, that is the "browser"
* bridge: the rig page this program serves at /sim/ (sim_rig.c), where every bar is the C++ led-driver.
*
* Environment:
* LED_SIM_BRIDGE simulator address, default 127.0.0.1:8766 (overrides settings "bridge")
* LED_SIM_BRIDGE one bridge address, overriding settings "bridges": "browser", host:port or /dev/...
* LED_SIM_HTTP_PORT web UI / API port, default 8080
* The store is the /db directory (mount a volume there to keep it).
*/
@@ -27,10 +28,12 @@
#include "engine.h"
#include "espnow_tx.h"
#include "bridge.h"
#include "wifi_drv.h"
#include "mic.h"
#include "ota.h"
#include "rel.h"
#include "seqplay.h"
#include "sim_rig.h"
#include "store.h"
#include "web.h"
#include "ws.h"
@@ -42,28 +45,35 @@ static esp_err_t status_get_handler(httpd_req_t *req)
beat_info_t bi;
espnow_stats_t es;
rel_stats_t rs;
char buf[1024];
char buf[3072];
char first_bridge[BRIDGE_ADDR_MAX] = "";
char bridge_addrs[BRIDGE_MAX_LINKS][BRIDGE_ADDR_MAX];
if (bridge_list(bridge_addrs, BRIDGE_MAX_LINKS) > 0) {
snprintf(first_bridge, sizeof(first_bridge), "%s", bridge_addrs[0]);
}
char bridges_json[1024];
bridge_status_json(bridges_json, sizeof(bridges_json));
beat_get_info(&bi);
espnow_tx_stats(&es);
rel_stats(&rs);
const char *br = bridge_addr();
snprintf(buf, sizeof(buf),
"{\"sim\":true,\"bridge\":\"%s\",\"ap\":false,\"ip\":\"127.0.0.1\",\"mac\":\"02:51:4d:00:00:00\",\"uptime_s\":%lld,"
"{\"sim\":true,\"bridge\":\"%s\",\"bridges\":%s,\"ap\":false,\"ip\":\"127.0.0.1\",\"mac\":\"02:51:4d:00:00:00\",\"uptime_s\":%lld,"
"\"reset_reason\":\"power_on\",\"free_heap\":0,\"free_internal\":0,"
"\"mic_rms_dbfs\":-120.0,\"mic_peak_dbfs\":-120.0,\"mic_spl_db\":0.0,"
"\"bpm\":%.1f,\"beat_confidence\":%.2f,\"beat_locked\":%s,\"beats\":%lu,\"onsets\":%lu,"
"\"meter\":%d,\"bar_beat\":%d,\"bar_sure\":%s,\"downbeats\":%lu,"
"\"espnow\":{\"beats_sent\":%lu,\"beat_send_fail\":%lu,\"bulk_sent\":%lu,"
"\"bulk_retries\":%lu,\"bulk_failed\":%lu,\"sim_dropped\":%lu},"
"\"link\":{\"ver\":%u,\"acked\":%lu,\"ack_timeouts\":%lu,\"retransmits\":%lu,\"resyncs\":%lu,\"digests\":%lu}}",
br ? br : "", (long long)(esp_timer_get_time() / 1000000),
"\"link\":{\"ver\":%u,\"acked\":%lu,\"ack_timeouts\":%lu,\"retransmits\":%lu,\"resyncs\":%lu,\"digests\":%lu},"
"\"bridge_links\":%s}",
first_bridge, bridges_json, (long long)(esp_timer_get_time() / 1000000),
bi.bpm, bi.confidence, bi.locked ? "true" : "false", (unsigned long)bi.beat_count,
(unsigned long)bi.onset_count, bi.meter, bi.bar_beat, bi.bar_sure ? "true" : "false",
(unsigned long)bi.downbeat_count,
(unsigned long)es.beats_sent, (unsigned long)es.beat_send_fail, (unsigned long)es.bulk_sent,
(unsigned long)es.bulk_retries, (unsigned long)es.bulk_failed, (unsigned long)es.sim_dropped, rel_ver(),
(unsigned long)rs.acked, (unsigned long)rs.ack_timeouts, (unsigned long)rs.retransmits,
(unsigned long)rs.resyncs, (unsigned long)rs.digests);
(unsigned long)rs.resyncs, (unsigned long)rs.digests, bridges_json);
httpd_resp_set_type(req, "application/json");
return httpd_resp_sendstr(req, buf);
}
@@ -76,10 +86,12 @@ static void start_webserver(void)
config.server_port = port ? atoi(port) : 8080;
config.ctrl_port = config.server_port + 10000;
config.uri_match_fn = httpd_uri_match_wildcard;
config.max_uri_handlers = 80;
config.max_uri_handlers = 96;
config.stack_size = 32768; // in StackType_t words on linux (8 bytes); the depth type is 16-bit
config.lru_purge_enable = true;
config.max_open_sockets = 12;
// The board's limit (lwIP) does not apply here: the rig page alone opens several connections per bar while
// its drivers load (the worker scripts, the wasm), on top of the controller's own UI. Under CONFIG_LWIP_MAX_SOCKETS - 3.
config.max_open_sockets = 48;
config.backlog_conn = 10;
if (httpd_start(&server, &config) != ESP_OK) {
ESP_LOGE(TAG, "HTTP server start failed on port %d", config.server_port);
@@ -87,13 +99,15 @@ static void start_webserver(void)
}
const httpd_uri_t status_uri = { .uri = "/status", .method = HTTP_GET, .handler = status_get_handler };
httpd_register_uri_handler(server, &status_uri);
sim_rig_register(server);
web_register(server);
audio_register(server);
audio_api_register(server);
ota_register(server);
api_register(server);
ws_register(server);
ESP_LOGI(TAG, "web UI and API on http://localhost:%d/", config.server_port);
ESP_LOGI(TAG, "web UI and API on http://localhost:%d/, the simulated rig on http://localhost:%d/sim/",
config.server_port, config.server_port);
}
static const char *settings_str(const char *key)
@@ -107,17 +121,30 @@ void app_main(void)
signal(SIGPIPE, SIG_IGN); // a browser that hangs up mid-reply is an error return, as on lwip, not a kill
ESP_ERROR_CHECK(store_init());
ESP_ERROR_CHECK(esp_event_loop_create_default());
const char *br = getenv("LED_SIM_BRIDGE");
if (!br || !br[0]) {
br = settings_str("bridge");
char bridges[BRIDGE_MAX_LINKS][BRIDGE_ADDR_MAX];
size_t nb = 0;
const char *env = getenv("LED_SIM_BRIDGE");
if (env && env[0]) {
snprintf(bridges[0], sizeof(bridges[0]), "%s", env);
nb = 1;
} else {
nb = store_bridges(bridges, BRIDGE_MAX_LINKS);
}
espnow_tx_set_bridge(br ? br : "127.0.0.1:8766");
if (nb == 0) {
snprintf(bridges[0], sizeof(bridges[0]), "%s", BRIDGE_BROWSER); // the rig page at /sim/
nb = 1;
}
espnow_tx_set_bridges(bridges, nb);
ESP_ERROR_CHECK(espnow_tx_init(NULL, NULL));
start_webserver();
wifi_drv_start_discovery(); // desktop: finds Wi-Fi drivers over mDNS; a no-op on the simulator
ESP_ERROR_CHECK(rel_init());
ESP_ERROR_CHECK(engine_init());
ESP_ERROR_CHECK(mic_start());
ESP_ERROR_CHECK(seqplay_init());
#ifdef LED_DESKTOP_ALSA
audio_api_resume_mic();
#endif
for (;;) {
vTaskDelay(pdMS_TO_TICKS(1000));
}
+999
View File
@@ -0,0 +1,999 @@
/*
* The simulated rig, served by the host build: see sim_rig.h.
*
* GET /sim/ the rig page; /sim/gallery the pattern gallery; /sim/<file> its files
* (sim.pack, embedded: led-simulator/web and the built wasm). The drivers run
* without threads, so the page needs no cross-origin isolation: any address works
* WS /sim/ws the page's radio. One page at a time: a new one takes over.
* page -> here binary src_mac(6) + ESP-NOW packet a driver transmitted (bridge_browser_rx)
* here -> page binary dst_mac(6) + ESP-NOW packet the controller transmitted (sim_rig_tx)
* page -> here text {"t":"flash","mac":"..","data":"<NVS JSON>"} a driver committed its flash
* here -> page text {"t":"takeover"} another page opened the rig
* GET /sim/api/config the active room, its strips, the room list and the bridge
* GET /sim/api/flash/<mac> a strip's NVS store, brought in line with its room (num_leds, channel)
* GET /sim/api/rooms {current, rooms}
* POST /sim/api/rooms {name, width, depth, copy_from?}: a new room
* GET|PUT|DELETE /sim/api/rooms/<name>
* POST /sim/api/room {name}: switch the rig to that room
* GET /sim/api/next-mac?taken= a MAC no room uses
*
* Rooms follow the stage maps of the qlcplus simulator: one JSON file per room in <db>/sim/rooms/, a size in
* metres, strip types ("definitions") and "fixtures" keyed by id, each one LED bar: x, y (metres) is pixel 0,
* "direction" the way it runs (degrees clockwise from +y), "mac" the driver. Each bar's flash is
* <db>/sim/flash/<mac>.json, so a bar keeps its presets in every room it appears in.
*/
#include "sim_rig.h"
#include <ctype.h>
#include <dirent.h>
#include <errno.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include "api_util.h"
#include "bridge.h"
#include "cJSON.h"
#include "esp_log.h"
#include "freertos/FreeRTOS.h"
#include "freertos/semphr.h"
#include "store.h"
static const char *TAG = "sim_rig";
#define MAX_FIXTURES 64
#define MAX_LEDS 512 // FX_LEDS_MAX in led-driver/main/effects.h
#define FLASH_MAX (512 * 1024)
#define FRAME_MAX (FLASH_MAX + 1024)
#define DEFAULT_PITCH_M (1.0 / 60) // 60 LEDs per metre
#define BRIDGE_SIM_MAC "02:51:4d:00:00:00"
#define MAC_PREFIX "02:51:4d"
#define ORIGIN_TEXT "X=0 at the room centre, +X right; Y=0 at the front edge, +Y up the screen; headings clockwise from +Y"
#define WIFI_CHANNEL 5
/* ------------------------------------------------------------------ the embedded page */
// sim.pack: the same format as www.pack (see main/web.c): "WWW1", then per file u16 name length, u32 data
// length, the name, the gzipped data; a zero name length ends it. Built by tools/build_sim_web.sh.
extern const uint8_t sim_pack_start[] asm("_binary_sim_pack_start");
extern const uint8_t sim_pack_end[] asm("_binary_sim_pack_end");
static bool find_file(const char *path, const uint8_t **data, uint32_t *len)
{
const uint8_t *p = sim_pack_start, *end = sim_pack_end;
if (end - p < 6 || memcmp(p, "WWW1", 4) != 0) {
return false;
}
p += 4;
size_t want = strlen(path);
while (end - p >= 6) {
uint16_t nlen;
uint32_t dlen;
memcpy(&nlen, p, 2);
memcpy(&dlen, p + 2, 4);
if (nlen == 0 || end - p < 6 + nlen + (ptrdiff_t)dlen) {
return false;
}
const uint8_t *name = p + 6, *body = name + nlen;
if (nlen == want && memcmp(name, path, want) == 0) {
*data = body;
*len = dlen;
return true;
}
p = body + dlen;
}
return false;
}
static const char *mime_for(const char *path)
{
static const struct {
const char *ext, *type;
} M[] = {
{ ".html", "text/html; charset=utf-8" }, { ".mjs", "text/javascript; charset=utf-8" },
{ ".js", "text/javascript; charset=utf-8" }, { ".css", "text/css; charset=utf-8" },
{ ".wasm", "application/wasm" }, { ".json", "application/json" },
};
const char *dot = strrchr(path, '.');
for (size_t i = 0; dot && i < sizeof(M) / sizeof(M[0]); i++) {
if (!strcmp(dot, M[i].ext)) {
return M[i].type;
}
}
return "application/octet-stream";
}
static esp_err_t send_file(httpd_req_t *req, const char *path)
{
const uint8_t *data;
uint32_t len;
if (strstr(path, "..")) {
return httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST, "bad path");
}
if (!find_file(path, &data, &len)) {
if (!find_file("index.html", &data, &len)) {
httpd_resp_set_type(req, "text/plain");
return httpd_resp_sendstr(req, "The simulated rig is not in this build: run `make sim-wasm`, then rebuild "
"(make sim-web, or make desktop).");
}
return httpd_resp_send_404(req);
}
httpd_resp_set_hdr(req, "Cache-Control", "no-cache");
httpd_resp_set_type(req, mime_for(path));
httpd_resp_set_hdr(req, "Content-Encoding", "gzip");
return httpd_resp_send(req, (const char *)data, len);
}
static esp_err_t page_handler(httpd_req_t *req)
{
if (!strcmp(req->uri, "/sim")) {
httpd_resp_set_status(req, "302 Found");
httpd_resp_set_hdr(req, "Location", "/sim/");
return httpd_resp_send(req, NULL, 0);
}
char path[96];
const char *rel = req->uri + 5; // after "/sim/"
size_t n = strcspn(rel, "?");
if (n >= sizeof(path) - 6) {
return httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST, "uri too long");
}
memcpy(path, rel, n);
path[n] = 0;
if (!path[0]) {
snprintf(path, sizeof(path), "index.html");
} else if (!strcmp(path, "gallery")) {
snprintf(path, sizeof(path), "gallery.html");
}
return send_file(req, path);
}
/* ------------------------------------------------------------------ files under <db>/sim */
static SemaphoreHandle_t s_mu; // rooms, flash files, the active room
static const char *db_root(void)
{
const char *d = getenv("LED_SIM_DB");
return d && d[0] ? d : "/db";
}
static void sim_path(char *out, size_t n, const char *sub, const char *name, const char *ext)
{
snprintf(out, n, "%s/sim/%s%s%s%s", db_root(), sub, sub[0] ? "/" : "", name, ext);
}
static void ensure_dirs(void)
{
char p[300];
snprintf(p, sizeof(p), "%s/sim", db_root());
mkdir(p, 0755);
snprintf(p, sizeof(p), "%s/sim/rooms", db_root());
mkdir(p, 0755);
snprintf(p, sizeof(p), "%s/sim/flash", db_root());
mkdir(p, 0755);
}
static char *read_text(const char *path, size_t max)
{
FILE *f = fopen(path, "rb");
if (!f) {
return NULL;
}
fseek(f, 0, SEEK_END);
long size = ftell(f);
fseek(f, 0, SEEK_SET);
char *buf = NULL;
if (size >= 0 && (size_t)size <= max && (buf = malloc((size_t)size + 1))) {
size_t got = fread(buf, 1, (size_t)size, f);
buf[got] = 0;
}
fclose(f);
return buf;
}
static cJSON *read_json(const char *path)
{
char *t = read_text(path, FLASH_MAX);
cJSON *o = t ? cJSON_Parse(t) : NULL;
free(t);
if (!cJSON_IsObject(o)) {
cJSON_Delete(o);
return NULL;
}
return o;
}
static bool write_text(const char *path, const char *text)
{
char tmp[310];
snprintf(tmp, sizeof(tmp), "%s.tmp", path);
FILE *f = fopen(tmp, "wb");
if (!f) {
return false;
}
size_t len = strlen(text);
bool ok = fwrite(text, 1, len, f) == len;
ok = fclose(f) == 0 && ok;
return ok && rename(tmp, path) == 0;
}
static bool write_json(const char *path, const cJSON *o, bool pretty)
{
char *t = pretty ? cJSON_Print(o) : cJSON_PrintUnformatted(o);
bool ok = t && write_text(path, t);
free(t);
return ok;
}
/* ------------------------------------------------------------------ rooms */
static bool name_ok(const char *s, size_t max, const char *extra)
{
size_t n = s ? strlen(s) : 0;
if (n == 0 || n > max) {
return false;
}
for (size_t i = 0; i < n; i++) {
if (!isalnum((unsigned char)s[i]) && !strchr(extra, s[i])) {
return false;
}
}
return true;
}
static bool room_name_ok(const char *s)
{
return name_ok(s, 40, "-_");
}
static bool id_ok(const char *s)
{
return name_ok(s, 40, "-_.#");
}
static bool mac_ok(const char *s)
{
if (!s || strlen(s) != 17) {
return false;
}
for (int i = 0; i < 17; i++) {
if (i % 3 == 2 ? s[i] != ':' : !isxdigit((unsigned char)s[i])) {
return false;
}
}
return strcasecmp(s, "ff:ff:ff:ff:ff:ff") && strcasecmp(s, BRIDGE_SIM_MAC);
}
static double round_to(double v, double step)
{
return round(v / step) * step;
}
static double wrap_deg(double d)
{
d = fmod(d, 360.0);
if (d <= -180) {
d += 360;
} else if (d > 180) {
d -= 360;
}
return d;
}
// The number at key in o, within lo..hi; else *err is set
static double num_in(const cJSON *o, const char *key, double def, double lo, double hi, const char *what,
char *err, size_t errn)
{
const cJSON *v = cJSON_GetObjectItem(o, key);
if (!v || cJSON_IsNull(v)) {
return def;
}
if (!cJSON_IsNumber(v) || !isfinite(v->valuedouble) || v->valuedouble < lo || v->valuedouble > hi) {
if (!err[0]) {
snprintf(err, errn, "%s must be a number from %g to %g", what, lo, hi);
}
return def;
}
return v->valuedouble;
}
// The room in canonical form (a new object), or NULL with the reason in err
static cJSON *validate_room(const cJSON *raw, const char *name, char *err, size_t errn)
{
err[0] = 0;
if (!cJSON_IsObject(raw)) {
snprintf(err, errn, "a room is a JSON object");
return NULL;
}
cJSON *room = cJSON_CreateObject();
const cJSON *nm = cJSON_GetObjectItem(raw, "name");
cJSON_AddStringToObject(room, "name", cJSON_IsString(nm) && nm->valuestring[0] ? nm->valuestring : name);
cJSON_AddStringToObject(room, "units", "metres");
cJSON_AddNumberToObject(room, "width", round_to(num_in(raw, "width", 6, 0.5, 200, "width", err, errn), 0.001));
cJSON_AddNumberToObject(room, "depth", round_to(num_in(raw, "depth", 4, 0.5, 200, "depth", err, errn), 0.001));
const cJSON *org = cJSON_GetObjectItem(raw, "origin");
cJSON_AddStringToObject(room, "origin",
cJSON_IsString(org) && org->valuestring[0] && strlen(org->valuestring) < 300 ? org->valuestring
: ORIGIN_TEXT);
const cJSON *defs_in = cJSON_GetObjectItem(raw, "definitions"), *d;
cJSON *defs = cJSON_AddObjectToObject(room, "definitions");
if (!cJSON_IsObject(defs_in) || !cJSON_GetArraySize(defs_in)) {
snprintf(err, errn, "a room needs at least one strip type in definitions");
}
cJSON_ArrayForEach(d, defs_in)
{
if (err[0]) {
break;
}
if (!id_ok(d->string) || !cJSON_IsObject(d)) {
snprintf(err, errn, "strip type names are 1-40 letters, digits or -_.#, each an object");
break;
}
char what[80];
snprintf(what, sizeof(what), "%s leds", d->string);
double leds = num_in(d, "leds", -1, 1, MAX_LEDS, what, err, errn);
if (leds < 0 && !err[0]) {
snprintf(err, errn, "%s needs leds", d->string);
}
snprintf(what, sizeof(what), "%s pitch_m", d->string);
double pitch = num_in(d, "pitch_m", DEFAULT_PITCH_M, 0.001, 1, what, err, errn);
cJSON *o = cJSON_AddObjectToObject(defs, d->string);
cJSON_AddNumberToObject(o, "leds", (int)leds);
cJSON_AddNumberToObject(o, "pitch_m", round_to(pitch, 0.00001));
}
const cJSON *fx_in = cJSON_GetObjectItem(raw, "fixtures"), *f;
cJSON *fixtures = cJSON_AddObjectToObject(room, "fixtures");
if (!err[0] && fx_in && !cJSON_IsObject(fx_in)) {
snprintf(err, errn, "fixtures must be an object keyed by id");
}
if (!err[0] && cJSON_GetArraySize(fx_in) > MAX_FIXTURES) {
snprintf(err, errn, "at most %d strips in a room", MAX_FIXTURES);
}
cJSON_ArrayForEach(f, fx_in)
{
if (err[0]) {
break;
}
const char *fid = f->string;
if (!id_ok(fid) || !cJSON_IsObject(f)) {
snprintf(err, errn, "strip ids are 1-40 letters, digits or -_.#, each an object");
break;
}
const cJSON *def = cJSON_GetObjectItem(f, "def"), *mac = cJSON_GetObjectItem(f, "mac");
const cJSON *label = cJSON_GetObjectItem(f, "label");
if (!cJSON_IsString(def) || !cJSON_GetObjectItem(defs, def->valuestring)) {
snprintf(err, errn, "strip %s: unknown strip type", fid);
break;
}
if (!cJSON_IsString(mac) || !mac_ok(mac->valuestring)) {
snprintf(err, errn, "strip %s: mac must be like 02:51:4d:00:00:01", fid);
break;
}
char m[18];
snprintf(m, sizeof(m), "%s", mac->valuestring);
for (char *c = m; *c; c++) {
*c = (char)tolower((unsigned char)*c);
}
const cJSON *other;
cJSON_ArrayForEach(other, fixtures)
{
const cJSON *om = cJSON_GetObjectItem(other, "mac");
if (cJSON_IsString(om) && !strcmp(om->valuestring, m)) {
snprintf(err, errn, "strip %s: mac %s is used twice in this room", fid, m);
}
}
if (err[0]) {
break;
}
char what[80];
cJSON *o = cJSON_AddObjectToObject(fixtures, fid);
char lab[48];
snprintf(lab, sizeof(lab), "%s", cJSON_IsString(label) && label->valuestring[0] ? label->valuestring : fid);
cJSON_AddStringToObject(o, "label", lab);
cJSON_AddStringToObject(o, "def", def->valuestring);
cJSON_AddStringToObject(o, "mac", m);
snprintf(what, sizeof(what), "%s x", fid);
cJSON_AddNumberToObject(o, "x", round_to(num_in(f, "x", 0, -1000, 1000, what, err, errn), 0.001));
snprintf(what, sizeof(what), "%s y", fid);
cJSON_AddNumberToObject(o, "y", round_to(num_in(f, "y", 0, -1000, 1000, what, err, errn), 0.001));
snprintf(what, sizeof(what), "%s direction", fid);
cJSON_AddNumberToObject(o, "direction",
round_to(wrap_deg(num_in(f, "direction", 90, -3600, 3600, what, err, errn)), 0.1));
const cJSON *leds = cJSON_GetObjectItem(f, "leds");
if (leds && !cJSON_IsNull(leds)) {
snprintf(what, sizeof(what), "%s leds", fid);
cJSON_AddNumberToObject(o, "leds", (int)num_in(f, "leds", 1, 1, MAX_LEDS, what, err, errn));
}
}
if (err[0]) {
cJSON_Delete(room);
return NULL;
}
return room;
}
// The original rig: 16 bars of 119 LEDs in 2 columns x 8 rows, pixel 0 at the centre line
static cJSON *default_room(void)
{
const int rows = 8, cols = 2, leds = 119;
const double pitch = DEFAULT_PITCH_M, length = leds * pitch, gap = 0.2, row_h = 0.3;
const double span = cols * length + (cols - 1) * gap;
const double width = round_to(span + 1.0, 0.01), depth = round_to(rows * row_h + 0.6, 0.01);
cJSON *raw = cJSON_CreateObject();
cJSON_AddStringToObject(raw, "name", "default");
cJSON_AddNumberToObject(raw, "width", width);
cJSON_AddNumberToObject(raw, "depth", depth);
cJSON *defs = cJSON_AddObjectToObject(raw, "definitions");
cJSON *def = cJSON_AddObjectToObject(defs, "bar-119");
cJSON_AddNumberToObject(def, "leds", leds);
cJSON_AddNumberToObject(def, "pitch_m", pitch);
cJSON *fx = cJSON_AddObjectToObject(raw, "fixtures");
for (int i = 0; i < rows * cols; i++) {
int row = i / cols, col = i % cols;
bool reversed = col < cols / 2; // left of the centre line: runs leftwards from its right end
double left = -span / 2 + col * (length + gap);
char label[16], mac[18];
snprintf(label, sizeof(label), "sim-%02d", i + 1);
snprintf(mac, sizeof(mac), MAC_PREFIX ":00:00:%02x", i + 1);
cJSON *f = cJSON_AddObjectToObject(fx, label);
cJSON_AddStringToObject(f, "label", label);
cJSON_AddStringToObject(f, "def", "bar-119");
cJSON_AddStringToObject(f, "mac", mac);
cJSON_AddNumberToObject(f, "x", reversed ? left + length : left);
cJSON_AddNumberToObject(f, "y", depth - 0.3 - (row + 0.5) * row_h);
cJSON_AddNumberToObject(f, "direction", reversed ? -90 : 90);
}
char err[160];
cJSON *room = validate_room(raw, "default", err, sizeof(err));
cJSON_Delete(raw);
return room;
}
// Room names, sorted, as a new JSON array
static cJSON *room_names(void)
{
char dir[300];
snprintf(dir, sizeof(dir), "%s/sim/rooms", db_root());
char names[64][41];
int n = 0;
DIR *dp = opendir(dir);
struct dirent *e;
while (dp && (e = readdir(dp)) && n < 64) {
size_t len = strlen(e->d_name);
if (len > 5 && len - 5 <= 40 && !strcmp(e->d_name + len - 5, ".json")) {
memcpy(names[n], e->d_name, len - 5);
names[n][len - 5] = 0;
if (room_name_ok(names[n])) {
n++;
}
}
}
if (dp) {
closedir(dp);
}
qsort(names, (size_t)n, sizeof(names[0]), (int (*)(const void *, const void *))strcmp);
cJSON *a = cJSON_CreateArray();
for (int i = 0; i < n; i++) {
cJSON_AddItemToArray(a, cJSON_CreateString(names[i]));
}
return a;
}
static bool room_exists(const char *name)
{
char p[300];
sim_path(p, sizeof(p), "rooms", name, ".json");
struct stat st;
return stat(p, &st) == 0;
}
static cJSON *load_room(const char *name, char *err, size_t errn)
{
char p[300];
sim_path(p, sizeof(p), "rooms", name, ".json");
cJSON *raw = read_json(p);
if (!raw) {
snprintf(err, errn, "no room named %s", name);
return NULL;
}
cJSON *room = validate_room(raw, name, err, errn);
cJSON_Delete(raw);
return room;
}
static bool save_room(const char *name, const cJSON *room)
{
char p[300];
sim_path(p, sizeof(p), "rooms", name, ".json");
return write_json(p, room, true);
}
static char s_room[41] = "default"; // the active room
static void save_active(void)
{
char p[300];
sim_path(p, sizeof(p), "", "sim", ".json");
cJSON *o = cJSON_CreateObject();
cJSON_AddStringToObject(o, "room", s_room);
write_json(p, o, true);
cJSON_Delete(o);
}
// First use: the default room; then the saved active room if it still exists, else the first one
static void load_active(void)
{
ensure_dirs();
cJSON *names = room_names();
if (!cJSON_GetArraySize(names)) {
cJSON *room = default_room();
if (room && save_room("default", room)) {
ESP_LOGI(TAG, "made the default room (16 bars)");
}
cJSON_Delete(room);
cJSON_Delete(names);
names = room_names();
}
char p[300];
sim_path(p, sizeof(p), "", "sim", ".json");
cJSON *st = read_json(p);
const cJSON *r = st ? cJSON_GetObjectItem(st, "room") : NULL;
if (cJSON_IsString(r) && room_name_ok(r->valuestring) && room_exists(r->valuestring)) {
snprintf(s_room, sizeof(s_room), "%s", r->valuestring);
} else if (cJSON_GetArraySize(names)) {
snprintf(s_room, sizeof(s_room), "%s", cJSON_GetArrayItem(names, 0)->valuestring);
}
cJSON_Delete(st);
cJSON_Delete(names);
}
static int fixture_leds(const cJSON *room, const cJSON *f)
{
const cJSON *l = cJSON_GetObjectItem(f, "leds");
if (cJSON_IsNumber(l)) {
return l->valueint;
}
const cJSON *def = cJSON_GetObjectItem(cJSON_GetObjectItem(room, "definitions"),
cJSON_GetObjectItem(f, "def")->valuestring);
return cJSON_GetObjectItem(def, "leds")->valueint;
}
// The strip with this MAC in the room, or NULL
static const cJSON *fixture_by_mac(const cJSON *room, const char *mac12)
{
const cJSON *f;
cJSON_ArrayForEach(f, cJSON_GetObjectItem(room, "fixtures"))
{
const char *m = cJSON_GetObjectItem(f, "mac")->valuestring;
char h[13];
int k = 0;
for (const char *c = m; *c && k < 12; c++) {
if (*c != ':') {
h[k++] = *c;
}
}
h[k] = 0;
if (!strcmp(h, mac12)) {
return f;
}
}
return NULL;
}
/* ------------------------------------------------------------------ the page's link */
static httpd_handle_t s_hd;
static int s_page_fd = -1;
static SemaphoreHandle_t s_tx_mu; // one frame at a time to the page
static bool page_open_locked(void)
{
if (s_page_fd >= 0 && httpd_ws_get_fd_info(s_hd, s_page_fd) != HTTPD_WS_CLIENT_WEBSOCKET) {
s_page_fd = -1;
}
return s_page_fd >= 0;
}
bool sim_rig_page_open(void)
{
if (!s_tx_mu) {
return false;
}
xSemaphoreTake(s_tx_mu, portMAX_DELAY);
bool open = page_open_locked();
xSemaphoreGive(s_tx_mu);
return open;
}
static bool send_frame(int fd, httpd_ws_type_t type, const uint8_t *data, size_t len)
{
httpd_ws_frame_t f = { .type = type, .payload = (uint8_t *)data, .len = len, .final = true };
return httpd_ws_send_frame_async(s_hd, fd, &f) == ESP_OK;
}
// Called by bridge.c for the "browser" bridge: dst_mac(6) + packet
bool sim_rig_tx(const uint8_t *frame, size_t len)
{
if (!s_tx_mu) {
return false;
}
xSemaphoreTake(s_tx_mu, portMAX_DELAY);
bool ok = page_open_locked() && send_frame(s_page_fd, HTTPD_WS_TYPE_BINARY, frame, len);
if (!ok) {
s_page_fd = page_open_locked() ? s_page_fd : -1;
}
xSemaphoreGive(s_tx_mu);
return ok;
}
static esp_err_t ws_open(httpd_req_t *req)
{
int fd = httpd_req_to_sockfd(req);
xSemaphoreTake(s_tx_mu, portMAX_DELAY);
int old = page_open_locked() ? s_page_fd : -1;
s_page_fd = fd;
if (old >= 0 && old != fd) {
static const char msg[] = "{\"t\":\"takeover\"}";
send_frame(old, HTTPD_WS_TYPE_TEXT, (const uint8_t *)msg, sizeof(msg) - 1);
httpd_sess_trigger_close(s_hd, old);
}
xSemaphoreGive(s_tx_mu);
ESP_LOGI(TAG, "rig page connected");
return ESP_OK;
}
static void save_flash(const char *text)
{
cJSON *m = cJSON_Parse(text);
const cJSON *t = cJSON_GetObjectItem(m, "t"), *mac = cJSON_GetObjectItem(m, "mac"), *d = cJSON_GetObjectItem(m, "data");
char h[13];
if (cJSON_IsString(t) && !strcmp(t->valuestring, "flash") && api_mac(mac, h) && cJSON_IsString(d)) {
cJSON *nvs = cJSON_Parse(d->valuestring);
if (cJSON_IsObject(nvs)) {
char p[300];
sim_path(p, sizeof(p), "flash", h, ".json");
xSemaphoreTake(s_mu, portMAX_DELAY);
write_text(p, d->valuestring);
xSemaphoreGive(s_mu);
}
cJSON_Delete(nvs);
}
cJSON_Delete(m);
}
static esp_err_t ws_handler(httpd_req_t *req)
{
if (req->method == HTTP_GET) { // only a plain GET gets here; the upgrade is answered by httpd
httpd_resp_set_status(req, "426 Upgrade Required");
return httpd_resp_sendstr(req, "websocket only");
}
httpd_ws_frame_t f = { 0 };
esp_err_t err = httpd_ws_recv_frame(req, &f, 0);
if (err != ESP_OK) {
return err;
}
if (f.len == 0 || (f.type != HTTPD_WS_TYPE_BINARY && f.type != HTTPD_WS_TYPE_TEXT)) {
return ESP_OK;
}
if (f.len > FRAME_MAX) {
return ESP_FAIL;
}
uint8_t *buf = malloc(f.len + 1);
if (!buf) {
return ESP_ERR_NO_MEM;
}
f.payload = buf;
err = httpd_ws_recv_frame(req, &f, f.len);
if (err == ESP_OK) {
buf[f.len] = 0;
if (f.type == HTTPD_WS_TYPE_BINARY) {
if (f.len > 6 && f.len <= 6 + 250) {
bridge_browser_rx(buf, (int)f.len);
}
} else {
save_flash((const char *)buf);
}
}
free(buf);
return err;
}
/* ------------------------------------------------------------------ the API */
static cJSON *config_json(void)
{
char err[160];
cJSON *o = cJSON_CreateObject();
cJSON *b = cJSON_AddObjectToObject(o, "bridge");
cJSON_AddStringToObject(b, "name", "rig");
cJSON_AddStringToObject(b, "mac", BRIDGE_SIM_MAC);
cJSON_AddBoolToObject(b, "running", bridge_has_browser());
cJSON *d = cJSON_AddObjectToObject(o, "drivers");
cJSON_AddStringToObject(d, "name", "sim-{n:02d}");
cJSON_AddNumberToObject(d, "fps", 30);
cJSON_AddNumberToObject(d, "boot_concurrency", 4);
cJSON_AddStringToObject(o, "room_name", s_room);
cJSON_AddItemToObject(o, "rooms", room_names());
cJSON *room = load_room(s_room, err, sizeof(err));
if (!room) {
room = default_room();
}
cJSON_AddItemToObject(o, "room", room);
return o;
}
// GET /sim/api/flash/<mac>: the bar's NVS store, created on first boot and kept in line with the room
static esp_err_t flash_get(httpd_req_t *req, const char *mac_in)
{
cJSON *k = cJSON_CreateString(mac_in);
char h[13];
bool ok = api_mac(k, h);
cJSON_Delete(k);
if (!ok) {
return api_error(req, "400 Bad Request", "not a MAC");
}
char err[160], p[300];
sim_path(p, sizeof(p), "flash", h, ".json");
cJSON *room = load_room(s_room, err, sizeof(err));
const cJSON *f = room ? fixture_by_mac(room, h) : NULL;
cJSON *nvs = read_json(p);
if (!nvs) {
nvs = cJSON_CreateObject();
}
cJSON *led = cJSON_GetObjectItem(nvs, "led");
if (!cJSON_IsObject(led)) {
cJSON_DeleteItemFromObject(nvs, "led");
led = cJSON_AddObjectToObject(nvs, "led");
}
// NVS keys and types as led-driver/main/settings.cpp writes them: [type, value]
#define NVS_SET(key, type, val) \
do { \
cJSON *pair = cJSON_CreateArray(); \
cJSON_AddItemToArray(pair, cJSON_CreateString(type)); \
cJSON_AddItemToArray(pair, val); \
cJSON_DeleteItemFromObject(led, key); \
cJSON_AddItemToObject(led, key, pair); \
} while (0)
const cJSON *host = cJSON_GetObjectItem(led, "hostname");
if (!(cJSON_IsArray(host) && cJSON_IsString(cJSON_GetArrayItem(host, 1)))) {
NVS_SET("hostname", "str", cJSON_CreateString(f ? cJSON_GetObjectItem(f, "label")->valuestring : "led"));
}
if (f) {
NVS_SET("num_leds", "i32", cJSON_CreateNumber(fixture_leds(room, f))); // physical: the room decides it
}
NVS_SET("espnow_ch", "i64", cJSON_CreateNumber(WIFI_CHANNEL));
NVS_SET("espnow", "str", cJSON_CreateString("on"));
#undef NVS_SET
xSemaphoreTake(s_mu, portMAX_DELAY);
write_json(p, nvs, false);
xSemaphoreGive(s_mu);
cJSON_Delete(room);
return api_json(req, "200 OK", nvs, true);
}
static void next_mac(const char *taken, char out[18])
{
cJSON *names = room_names(), *n;
char err[160];
// every MAC any room uses, plus the ones the page has not saved yet
size_t cap = 4096, len = 0;
char *all = calloc(1, cap);
cJSON_ArrayForEach(n, names)
{
cJSON *room = load_room(n->valuestring, err, sizeof(err));
const cJSON *f, *fixtures = room ? cJSON_GetObjectItem(room, "fixtures") : NULL;
cJSON_ArrayForEach(f, fixtures)
{
const char *m = cJSON_GetObjectItem(f, "mac")->valuestring;
if (all && len + 20 < cap) {
len += (size_t)snprintf(all + len, cap - len, "%s,", m);
}
}
cJSON_Delete(room);
}
cJSON_Delete(names);
for (int i = 1; i < 0xFFFF; i++) {
snprintf(out, 18, MAC_PREFIX ":00:%02x:%02x", i >> 8, i & 0xFF);
if ((!all || !strstr(all, out)) && (!taken || !strstr(taken, out))) {
break;
}
}
free(all);
}
static esp_err_t rooms_info(httpd_req_t *req)
{
cJSON *o = cJSON_CreateObject();
cJSON_AddStringToObject(o, "current", s_room);
cJSON_AddItemToObject(o, "rooms", room_names());
return api_json(req, "200 OK", o, true);
}
static esp_err_t api_handler(httpd_req_t *req)
{
// /sim/api/<a>/<b>
char a[32] = "", b[64] = "";
const char *rest = req->uri + strlen("/sim/api/");
size_t na = strcspn(rest, "/?");
if (na >= sizeof(a)) {
return api_error(req, "404 Not Found", "no such endpoint");
}
memcpy(a, rest, na);
if (rest[na] == '/') {
size_t nb = strcspn(rest + na + 1, "/?");
if (nb >= sizeof(b) || rest[na + 1 + nb] == '/') {
return api_error(req, "404 Not Found", "no such endpoint");
}
memcpy(b, rest + na + 1, nb);
}
const int m = req->method;
char err[200];
esp_err_t ret;
xSemaphoreTake(s_mu, portMAX_DELAY);
if (!strcmp(a, "config") && !b[0] && m == HTTP_GET) {
ret = api_json(req, "200 OK", config_json(), true);
} else if (!strcmp(a, "flash") && b[0] && m == HTTP_GET) {
xSemaphoreGive(s_mu); // flash_get takes it for the write
return flash_get(req, b);
} else if (!strcmp(a, "next-mac") && m == HTTP_GET) {
char q[600] = "", taken[600] = "", mac[18];
if (httpd_req_get_url_query_str(req, q, sizeof(q)) == ESP_OK) {
httpd_query_key_value(q, "taken", taken, sizeof(taken));
}
for (char *c = taken; *c; c++) { // %3A and %2C from encodeURIComponent; MACs compare in lower case
*c = (char)tolower((unsigned char)*c);
if (c[0] == '%' && c[1] == '3' && (c[2] == 'A' || c[2] == 'a')) {
c[0] = ':';
memmove(c + 1, c + 3, strlen(c + 3) + 1);
} else if (c[0] == '%' && c[1] == '2' && (c[2] == 'C' || c[2] == 'c')) {
c[0] = ',';
memmove(c + 1, c + 3, strlen(c + 3) + 1);
}
}
next_mac(taken, mac);
cJSON *o = cJSON_CreateObject();
cJSON_AddStringToObject(o, "mac", mac);
ret = api_json(req, "200 OK", o, true);
} else if (!strcmp(a, "rooms") && !b[0] && m == HTTP_GET) {
ret = rooms_info(req);
} else if (!strcmp(a, "rooms") && !b[0] && m == HTTP_POST) {
cJSON *body = api_body(req);
if (!body) {
ret = ESP_OK;
} else {
const cJSON *nm = cJSON_GetObjectItem(body, "name"), *src = cJSON_GetObjectItem(body, "copy_from");
cJSON *room = NULL;
if (!cJSON_IsString(nm) || !room_name_ok(nm->valuestring)) {
ret = api_error(req, "400 Bad Request", "room names are 1-40 letters, digits, - or _");
} else if (room_exists(nm->valuestring)) {
ret = api_error(req, "409 Conflict", "a room with that name already exists");
} else if (cJSON_IsString(src) && !(room_name_ok(src->valuestring) &&
(room = load_room(src->valuestring, err, sizeof(err))))) {
ret = api_error(req, "400 Bad Request", "no room to copy with that name");
} else {
if (!room) {
room = cJSON_CreateObject();
cJSON *defs = cJSON_AddObjectToObject(room, "definitions");
cJSON *d = cJSON_AddObjectToObject(defs, "bar-119");
cJSON_AddNumberToObject(d, "leds", 119);
cJSON_AddNumberToObject(d, "pitch_m", DEFAULT_PITCH_M);
cJSON_AddObjectToObject(room, "fixtures");
}
api_set(room, "name", cJSON_CreateString(nm->valuestring));
const cJSON *w = cJSON_GetObjectItem(body, "width"), *dp = cJSON_GetObjectItem(body, "depth");
if (cJSON_IsNumber(w)) {
api_set(room, "width", cJSON_CreateNumber(w->valuedouble));
}
if (cJSON_IsNumber(dp)) {
api_set(room, "depth", cJSON_CreateNumber(dp->valuedouble));
}
cJSON *ok = validate_room(room, nm->valuestring, err, sizeof(err));
if (!ok) {
ret = api_error(req, "400 Bad Request", err);
} else if (!save_room(nm->valuestring, ok)) {
ret = api_error(req, "500 Internal Server Error", "could not write the room");
cJSON_Delete(ok);
} else {
cJSON *o = cJSON_CreateObject();
cJSON_AddItemToObject(o, "room", ok);
cJSON_AddStringToObject(o, "current", s_room);
cJSON_AddItemToObject(o, "rooms", room_names());
ret = api_json(req, "200 OK", o, true);
}
}
cJSON_Delete(room);
cJSON_Delete(body);
}
} else if (!strcmp(a, "rooms") && b[0]) {
if (!room_name_ok(b)) {
ret = api_error(req, "400 Bad Request", "room names are 1-40 letters, digits, - or _");
} else if (!room_exists(b)) {
ret = api_error(req, "404 Not Found", "no room with that name");
} else if (m == HTTP_GET) {
cJSON *room = load_room(b, err, sizeof(err));
ret = room ? api_json(req, "200 OK", room, true) : api_error(req, "500 Internal Server Error", err);
} else if (m == HTTP_PUT) {
cJSON *body = api_body(req);
cJSON *room = body ? validate_room(body, b, err, sizeof(err)) : NULL;
if (!body) {
ret = ESP_OK;
} else if (!room) {
ret = api_error(req, "400 Bad Request", err);
} else if (!save_room(b, room)) {
ret = api_error(req, "500 Internal Server Error", "could not write the room");
cJSON_Delete(room);
} else {
cJSON *o = cJSON_CreateObject();
cJSON_AddItemToObject(o, "room", room);
ret = api_json(req, "200 OK", o, true);
}
cJSON_Delete(body);
} else if (m == HTTP_DELETE) {
char p[300];
sim_path(p, sizeof(p), "rooms", b, ".json");
if (!strcmp(b, s_room)) {
ret = api_error(req, "409 Conflict", "switch to another room before deleting this one");
} else if (remove(p) != 0) {
ret = api_error(req, "500 Internal Server Error", "could not delete the room");
} else {
ret = rooms_info(req);
}
} else {
ret = api_error(req, "405 Method Not Allowed", "GET, PUT or DELETE");
}
} else if (!strcmp(a, "room") && !b[0] && m == HTTP_POST) {
cJSON *body = api_body(req);
const cJSON *nm = body ? cJSON_GetObjectItem(body, "name") : NULL;
if (!body) {
ret = ESP_OK;
} else if (!cJSON_IsString(nm) || !room_name_ok(nm->valuestring) || !room_exists(nm->valuestring)) {
ret = api_error(req, "400 Bad Request", "no room with that name");
} else {
snprintf(s_room, sizeof(s_room), "%s", nm->valuestring);
save_active();
ESP_LOGI(TAG, "room: %s", s_room);
ret = api_json(req, "200 OK", config_json(), true);
}
cJSON_Delete(body);
} else {
ret = api_error(req, "404 Not Found", "no such endpoint");
}
xSemaphoreGive(s_mu);
return ret;
}
/* ------------------------------------------------------------------ registration */
esp_err_t sim_rig_register(httpd_handle_t server)
{
s_hd = server;
s_mu = xSemaphoreCreateMutex();
s_tx_mu = xSemaphoreCreateMutex();
if (!s_mu || !s_tx_mu) {
return ESP_ERR_NO_MEM;
}
load_active();
const httpd_uri_t ws = { .uri = "/sim/ws", .method = HTTP_GET, .handler = ws_handler, .is_websocket = true,
.handle_ws_control_frames = false, .ws_post_handshake_cb = ws_open };
esp_err_t err = httpd_register_uri_handler(server, &ws);
static const httpd_method_t METHODS[] = { HTTP_GET, HTTP_POST, HTTP_PUT, HTTP_DELETE };
for (size_t i = 0; i < 4 && err == ESP_OK; i++) {
const httpd_uri_t u = { .uri = "/sim/api/*", .method = METHODS[i], .handler = api_handler };
err = httpd_register_uri_handler(server, &u);
}
const httpd_uri_t root = { .uri = "/sim", .method = HTTP_GET, .handler = page_handler };
const httpd_uri_t files = { .uri = "/sim/*", .method = HTTP_GET, .handler = page_handler };
if (err == ESP_OK) {
err = httpd_register_uri_handler(server, &root);
}
if (err == ESP_OK) {
err = httpd_register_uri_handler(server, &files);
}
if (err != ESP_OK) {
ESP_LOGE(TAG, "register: %s", esp_err_to_name(err));
} else {
ESP_LOGI(TAG, "simulated rig on /sim/ (room %s)", s_room);
}
return err;
}
+13
View File
@@ -0,0 +1,13 @@
/*
* The simulated rig, served by the host build (desktop and sim-controller): the page at /sim/, where every
* LED bar is the C++ led-driver built to WebAssembly (sim-driver/), and the "browser" bridge that carries the
* controller's ESP-NOW frames to those drivers over the page's WebSocket. Rooms and each bar's flash are kept
* under <db>/sim/.
*/
#pragma once
#include "esp_err.h"
#include "esp_http_server.h"
// Register /sim, /sim/ws, /sim/api/* and /sim/* (call before any catch-all handler)
esp_err_t sim_rig_register(httpd_handle_t server);
@@ -13,6 +13,7 @@ esp_err_t esp_vfs_littlefs_register(const esp_vfs_littlefs_conf_t *conf)
return ESP_OK;
}
#ifndef LED_DESKTOP_ALSA
// No microphone: audio stays stopped, so the simulated-BPM clock times sequences
esp_err_t mic_start(void)
{
@@ -43,6 +44,8 @@ void mic_stream_close(void)
{
}
#endif // LED_DESKTOP_ALSA
void ota_confirm_later(void)
{
}