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:
1 parent
698c1463c0
commit
581b751904
506 files changed
+42336
-3599
No files matched your search
@@ -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)
|
||||
@@ -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));
|
||||
}
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
@@ -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)
|
||||
{
|
||||
}
|
||||
|
||||
Reference in new issue
Block a user