Groups (registry of driver MACs, optionally scoped to a profile) become
the drivers' group membership, alongside z<zone id> for zones that still
name drivers. Zones play to their group_ids. Group and device routes for
driver config, brightness (global x groups x device x zone) and identify.
The push path takes main's message shape: select as a list, groups as a
filter (one GROUP_CMD per group, or JSON when a preset has a background),
short keys so JSON fits a frame.
Sequences follow main: lanes of {preset_id, beats} steps played to each
lane's groups, advanced by the mic's beats or a clock at
audio_simulated_bpm; a switch waits for the next beat or downbeat; sync-
phase, stop (clears the zone's drivers) and status. This replaces the
time-based per-zone sequencer and scene playback, as in main.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
701 lines
24 KiB
C
701 lines
24 KiB
C
// LED driver registry: the v1 app's controllers/device.py and models/device.py. Devices are keyed by
|
||
// their MAC (12 lowercase hex digits).
|
||
|
||
#include <ctype.h>
|
||
#include <stdio.h>
|
||
#include <stdlib.h>
|
||
#include <string.h>
|
||
#include "api_util.h"
|
||
#include "engine.h"
|
||
#include "freertos/FreeRTOS.h"
|
||
#include "freertos/task.h"
|
||
#include "esp_random.h"
|
||
#include "esp_timer.h"
|
||
#include "espnow_tx.h"
|
||
#include "rel.h"
|
||
#include "store.h"
|
||
|
||
#define IDENTIFY_OFF_MS 2000
|
||
|
||
// Trimmed copy of a string field; false when missing or blank
|
||
static bool trimmed(const cJSON *v, char *buf, size_t len)
|
||
{
|
||
buf[0] = 0;
|
||
if (!cJSON_IsString(v)) {
|
||
return false;
|
||
}
|
||
const char *s = v->valuestring;
|
||
while (isspace((unsigned char)*s)) {
|
||
s++;
|
||
}
|
||
snprintf(buf, len, "%s", s);
|
||
for (int i = strlen(buf) - 1; i >= 0 && isspace((unsigned char)buf[i]); i--) {
|
||
buf[i] = 0;
|
||
}
|
||
return buf[0] != 0;
|
||
}
|
||
|
||
static bool is_espnow(const cJSON *dev)
|
||
{
|
||
const cJSON *tr = cJSON_GetObjectItem(dev, "transport");
|
||
return !cJSON_IsString(tr) || !strcmp(tr->valuestring, "espnow");
|
||
}
|
||
|
||
// Check and tidy name, type, transport, address and zones in place; returns an error or NULL
|
||
static const char *normalize_device(cJSON *dev, const char *mac)
|
||
{
|
||
char buf[64];
|
||
if (!trimmed(cJSON_GetObjectItem(dev, "name"), buf, sizeof(buf))) {
|
||
return "name is required";
|
||
}
|
||
api_set(dev, "name", cJSON_CreateString(buf));
|
||
const cJSON *type = cJSON_GetObjectItem(dev, "type");
|
||
if (type && !cJSON_IsNull(type) && !(cJSON_IsString(type) && !strcmp(type->valuestring, "led"))) {
|
||
return "type must be led";
|
||
}
|
||
api_set(dev, "type", cJSON_CreateString("led"));
|
||
const cJSON *tr = cJSON_GetObjectItem(dev, "transport");
|
||
const char *transport = cJSON_IsString(tr) ? tr->valuestring : "espnow";
|
||
if (strcmp(transport, "espnow") && strcmp(transport, "wifi")) {
|
||
return "transport must be wifi or espnow";
|
||
}
|
||
api_set(dev, "transport", cJSON_CreateString(transport));
|
||
if (!strcmp(transport, "espnow")) {
|
||
api_set(dev, "address", cJSON_CreateString(mac));
|
||
} else {
|
||
trimmed(cJSON_GetObjectItem(dev, "address"), buf, sizeof(buf));
|
||
api_set(dev, "address", cJSON_CreateString(buf));
|
||
}
|
||
const cJSON *zones = cJSON_GetObjectItem(dev, "zones"), *z;
|
||
cJSON *out = cJSON_CreateArray();
|
||
if (!cJSON_IsArray(zones)) {
|
||
zones = out; // empty
|
||
}
|
||
cJSON_ArrayForEach(z, zones)
|
||
{
|
||
if (api_id(z, buf, sizeof(buf))) {
|
||
cJSON_AddItemToArray(out, cJSON_CreateString(buf));
|
||
}
|
||
}
|
||
api_set(dev, "zones", out);
|
||
const cJSON *ob = cJSON_GetObjectItem(dev, "output_brightness");
|
||
if (ob && !cJSON_IsNull(ob) &&
|
||
!(cJSON_IsNumber(ob) && ob->valuedouble == (int)ob->valuedouble && ob->valuedouble >= 0 && ob->valuedouble <= 255)) {
|
||
return "output_brightness must be between 0 and 255";
|
||
}
|
||
if (!cJSON_GetObjectItem(dev, "default_pattern")) {
|
||
cJSON_AddNullToObject(dev, "default_pattern");
|
||
}
|
||
api_set(dev, "id", cJSON_CreateString(mac));
|
||
cJSON_DeleteItemFromObject(dev, "mac");
|
||
return NULL;
|
||
}
|
||
|
||
// Copy of a device with "connected": null for ESP-NOW (no link state), false for Wi-Fi (the
|
||
// controller keeps no Wi-Fi driver connections)
|
||
static cJSON *with_connected(const cJSON *dev)
|
||
{
|
||
cJSON *o = cJSON_Duplicate(dev, true);
|
||
api_set(o, "connected", is_espnow(dev) ? cJSON_CreateNull() : cJSON_CreateFalse());
|
||
return o;
|
||
}
|
||
|
||
static cJSON *find(const char *id, char mac[13])
|
||
{
|
||
cJSON *v = cJSON_CreateString(id);
|
||
bool ok = api_mac(v, mac);
|
||
cJSON_Delete(v);
|
||
if (!ok) {
|
||
snprintf(mac, 13, "%.12s", id);
|
||
}
|
||
return cJSON_GetObjectItem(store_coll("device"), mac);
|
||
}
|
||
|
||
static esp_err_t create_device(httpd_req_t *req)
|
||
{
|
||
cJSON *body = api_body_opt(req);
|
||
if (!body) {
|
||
return ESP_OK;
|
||
}
|
||
char name[64], mac[13];
|
||
const char *err = NULL;
|
||
const cJSON *tr = cJSON_GetObjectItem(body, "transport");
|
||
bool wifi = cJSON_IsString(tr) && !strcmp(tr->valuestring, "wifi");
|
||
if (!trimmed(cJSON_GetObjectItem(body, "name"), name, sizeof(name))) {
|
||
err = "name is required";
|
||
} else if (!api_mac(cJSON_GetObjectItem(body, "mac"), mac) &&
|
||
(wifi || !api_mac(cJSON_GetObjectItem(body, "address"), mac))) {
|
||
err = "mac is required (12 hex digits); for Wi-Fi include mac plus IP in address";
|
||
}
|
||
cJSON_DeleteItemFromObject(body, "id");
|
||
cJSON_DeleteItemFromObject(body, "connected");
|
||
cJSON_DeleteItemFromObject(body, "addresses");
|
||
if (!err) {
|
||
err = normalize_device(body, mac);
|
||
}
|
||
if (err) {
|
||
cJSON_Delete(body);
|
||
return api_error(req, "400 Bad Request", err);
|
||
}
|
||
cJSON *all = store_coll("device");
|
||
if (cJSON_GetObjectItem(all, mac)) {
|
||
cJSON_Delete(body);
|
||
return api_error(req, "409 Conflict", "device with this mac already exists");
|
||
}
|
||
cJSON_AddItemToObject(all, mac, body);
|
||
store_save("device");
|
||
engine_groups_changed();
|
||
cJSON *o = cJSON_CreateObject();
|
||
cJSON_AddItemReferenceToObject(o, mac, body);
|
||
return api_json(req, "201 Created", o, true);
|
||
}
|
||
|
||
// Settings a driver keeps in its own settings.json and takes from a device_config message
|
||
static const char *const DEVICE_CONFIG_KEYS[] = { "max_brightness", "num_leds", "color_order", "startup_mode", "reversed" };
|
||
|
||
// The driver settings present in a device update, or NULL when it has none. Caller deletes the result.
|
||
static cJSON *device_config_from(const cJSON *body)
|
||
{
|
||
cJSON *dc = NULL;
|
||
for (size_t i = 0; i < sizeof(DEVICE_CONFIG_KEYS) / sizeof(DEVICE_CONFIG_KEYS[0]); i++) {
|
||
const cJSON *v = cJSON_GetObjectItem(body, DEVICE_CONFIG_KEYS[i]);
|
||
if (!v || cJSON_IsNull(v)) {
|
||
continue;
|
||
}
|
||
if (!dc) {
|
||
dc = cJSON_CreateObject();
|
||
}
|
||
cJSON_AddItemToObject(dc, DEVICE_CONFIG_KEYS[i], cJSON_Duplicate(v, true));
|
||
}
|
||
return dc;
|
||
}
|
||
|
||
// v1 messages to one driver by its MAC
|
||
static esp_err_t push_to(const char *mac, cJSON *msg)
|
||
{
|
||
cJSON *messages = cJSON_CreateArray(), *targets = cJSON_CreateArray();
|
||
cJSON_AddItemToArray(messages, msg);
|
||
cJSON_AddItemToArray(targets, cJSON_CreateString(mac));
|
||
esp_err_t err = engine_push(messages, targets);
|
||
cJSON_Delete(messages);
|
||
cJSON_Delete(targets);
|
||
return err;
|
||
}
|
||
|
||
// Send changed settings to an ESP-NOW driver; takes ownership of dc
|
||
static esp_err_t push_device_config(const cJSON *dev, cJSON *dc)
|
||
{
|
||
const cJSON *addr = cJSON_GetObjectItem(dev, "address");
|
||
if (!is_espnow(dev) || !cJSON_IsString(addr)) {
|
||
cJSON_Delete(dc);
|
||
return ESP_ERR_INVALID_ARG;
|
||
}
|
||
cJSON *msg = cJSON_CreateObject();
|
||
cJSON_AddStringToObject(msg, "v", "1");
|
||
cJSON_AddItemToObject(msg, "device_config", dc);
|
||
cJSON_AddTrueToObject(msg, "save");
|
||
return push_to(addr->valuestring, msg);
|
||
}
|
||
|
||
static esp_err_t update_device(httpd_req_t *req, cJSON *dev, const char *mac)
|
||
{
|
||
cJSON *body = api_body(req);
|
||
if (!body) {
|
||
return ESP_OK;
|
||
}
|
||
char other[13];
|
||
const cJSON *bm = cJSON_GetObjectItem(body, "mac");
|
||
if (bm && !cJSON_IsNull(bm) && !(api_mac(bm, other) && !strcmp(other, mac))) {
|
||
cJSON_Delete(body);
|
||
return api_error(req, "400 Bad Request", "cannot change device mac; delete and re-add");
|
||
}
|
||
cJSON_DeleteItemFromObject(body, "connected");
|
||
cJSON_DeleteItemFromObject(body, "addresses");
|
||
cJSON *merged = cJSON_Duplicate(dev, true);
|
||
api_merge(merged, body);
|
||
const char *err = normalize_device(merged, mac);
|
||
if (err) {
|
||
cJSON_Delete(merged);
|
||
cJSON_Delete(body);
|
||
return api_error(req, "400 Bad Request", err);
|
||
}
|
||
cJSON *dev_cfg = device_config_from(body);
|
||
cJSON_Delete(body);
|
||
cJSON_ReplaceItemInObject(store_coll("device"), mac, merged);
|
||
store_save("device");
|
||
if (dev_cfg) {
|
||
push_device_config(merged, dev_cfg); // before the group resend: a second message right behind another may not be delivered
|
||
}
|
||
engine_groups_changed();
|
||
return api_json(req, "200 OK", merged, false);
|
||
}
|
||
|
||
// Identify: a red 10 Hz blink, then "off" two seconds later. A device is addressed by its MAC; a
|
||
// group by one broadcast its members filter on (they blink together).
|
||
static const char IDENTIFY_PRESET[] = "{\"__identify\":{\"p\":\"blink\",\"c\":[\"#ff0000\"],\"d\":50,\"b\":128,"
|
||
"\"a\":true,\"n1\":0,\"n2\":0,\"n3\":0,\"n4\":0,\"n5\":0,\"n6\":0}}";
|
||
|
||
typedef struct {
|
||
char mac[13]; // "" when addressing a group
|
||
char group[24];
|
||
} identify_t;
|
||
|
||
static esp_err_t identify_send(const identify_t *id, bool on)
|
||
{
|
||
cJSON *msg = cJSON_CreateObject();
|
||
cJSON_AddStringToObject(msg, "v", "1");
|
||
if (on) {
|
||
cJSON_AddItemToObject(msg, "presets", cJSON_Parse(IDENTIFY_PRESET));
|
||
}
|
||
cJSON *sel = cJSON_AddArrayToObject(msg, "select");
|
||
cJSON_AddItemToArray(sel, cJSON_CreateString(on ? "__identify" : "off"));
|
||
if (id->mac[0]) {
|
||
return push_to(id->mac, msg);
|
||
}
|
||
cJSON *groups = cJSON_AddArrayToObject(msg, "groups");
|
||
cJSON_AddItemToArray(groups, cJSON_CreateString(id->group));
|
||
cJSON *messages = cJSON_CreateArray();
|
||
cJSON_AddItemToArray(messages, msg);
|
||
esp_err_t err = engine_push(messages, NULL);
|
||
cJSON_Delete(messages);
|
||
return err;
|
||
}
|
||
|
||
static void identify_off_task(void *arg)
|
||
{
|
||
identify_t *id = arg;
|
||
vTaskDelay(pdMS_TO_TICKS(IDENTIFY_OFF_MS));
|
||
identify_send(id, false);
|
||
free(id);
|
||
vTaskDelete(NULL);
|
||
}
|
||
|
||
static esp_err_t identify_start(const char *mac, const char *group)
|
||
{
|
||
identify_t *id = calloc(1, sizeof(*id));
|
||
if (!id) {
|
||
return ESP_ERR_NO_MEM;
|
||
}
|
||
snprintf(id->mac, sizeof(id->mac), "%s", mac ? mac : "");
|
||
snprintf(id->group, sizeof(id->group), "%s", group ? group : "");
|
||
esp_err_t err = identify_send(id, true);
|
||
if (err != ESP_OK || xTaskCreate(identify_off_task, "identify", 6144, id, 3, NULL) != pdPASS) {
|
||
free(id);
|
||
}
|
||
return err;
|
||
}
|
||
|
||
esp_err_t api_identify_group(const char *group_id)
|
||
{
|
||
return identify_start(NULL, group_id);
|
||
}
|
||
|
||
static esp_err_t identify(httpd_req_t *req, const cJSON *dev, const char *mac)
|
||
{
|
||
if (!is_espnow(dev)) {
|
||
return api_error(req, "503 Service Unavailable", "Wi-Fi driver not connected");
|
||
}
|
||
if (identify_start(mac, NULL) != ESP_OK) {
|
||
return api_error(req, "503 Service Unavailable", "Identify send failed");
|
||
}
|
||
return api_message(req, "200 OK", "Identify sent");
|
||
}
|
||
|
||
/* ------------------------------------------------------------- brightness */
|
||
|
||
static int clamp255(const cJSON *v, int dflt)
|
||
{
|
||
if (!cJSON_IsNumber(v)) {
|
||
return dflt;
|
||
}
|
||
int b = (int)v->valuedouble;
|
||
return b < 0 ? 0 : (b > 255 ? 255 : b);
|
||
}
|
||
|
||
// global x each group listing the MAC (none: no factor) x device output_brightness [x zone], each a
|
||
// 0..255 factor: round(f1/255 * f2/255 * ... * 255). zone_b < 0 leaves the zone out.
|
||
int api_effective_brightness(const char *mac, int zone_b)
|
||
{
|
||
double v = clamp255(cJSON_GetObjectItem(store_settings(), "global_brightness"), 255) / 255.0;
|
||
const cJSON *g;
|
||
cJSON_ArrayForEach(g, store_coll("group"))
|
||
{
|
||
const cJSON *it;
|
||
cJSON_ArrayForEach(it, cJSON_GetObjectItem(g, "devices"))
|
||
{
|
||
char m[13];
|
||
if (api_mac(it, m) && !strcmp(m, mac)) {
|
||
v *= clamp255(cJSON_GetObjectItem(g, "output_brightness"), 255) / 255.0;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
const cJSON *dev = cJSON_GetObjectItem(store_coll("device"), mac);
|
||
v *= clamp255(cJSON_GetObjectItem(dev, "output_brightness"), 255) / 255.0;
|
||
if (zone_b >= 0) {
|
||
v *= (zone_b > 255 ? 255 : zone_b) / 255.0;
|
||
}
|
||
int b = (int)(v * 255 + 0.5);
|
||
return b < 0 ? 0 : (b > 255 ? 255 : b);
|
||
}
|
||
|
||
// zone_brightness from a body: -1 when absent, -2 (error sent) when invalid
|
||
static int zone_brightness(httpd_req_t *req, const cJSON *body)
|
||
{
|
||
const cJSON *z = cJSON_GetObjectItem(body, "zone_brightness");
|
||
if (!z || cJSON_IsNull(z)) {
|
||
return -1;
|
||
}
|
||
if (!cJSON_IsNumber(z) || z->valuedouble != (int)z->valuedouble || z->valuedouble < 0 || z->valuedouble > 255) {
|
||
api_error(req, "400 Bad Request", "output_brightness must be an integer 0–255");
|
||
return -2;
|
||
}
|
||
return (int)z->valuedouble;
|
||
}
|
||
|
||
// POST /devices/resolve-brightness {macs, zone_brightness?} -> {values: {mac: brightness}}
|
||
static esp_err_t resolve_brightness(httpd_req_t *req)
|
||
{
|
||
cJSON *body = api_body_opt(req);
|
||
if (!body) {
|
||
return ESP_OK;
|
||
}
|
||
const cJSON *macs = cJSON_GetObjectItem(body, "macs");
|
||
if (!cJSON_IsArray(macs)) {
|
||
cJSON_Delete(body);
|
||
return api_error(req, "400 Bad Request", "macs must be an array");
|
||
}
|
||
int zb = zone_brightness(req, body);
|
||
if (zb == -2) {
|
||
cJSON_Delete(body);
|
||
return ESP_OK;
|
||
}
|
||
cJSON *o = cJSON_CreateObject(), *values = cJSON_AddObjectToObject(o, "values");
|
||
const cJSON *it;
|
||
cJSON_ArrayForEach(it, macs)
|
||
{
|
||
char mac[13];
|
||
if (api_mac(it, mac) && !cJSON_GetObjectItem(values, mac)) {
|
||
cJSON_AddNumberToObject(values, mac, api_effective_brightness(mac, zb));
|
||
}
|
||
}
|
||
cJSON_Delete(body);
|
||
return api_json(req, "200 OK", o, true);
|
||
}
|
||
|
||
// POST /devices/<id>/brightness {zone_brightness?}: the combined brightness, saved on the driver
|
||
static esp_err_t device_brightness(httpd_req_t *req, const char *mac)
|
||
{
|
||
cJSON *body = api_body_opt(req);
|
||
if (!body) {
|
||
return ESP_OK;
|
||
}
|
||
int zb = zone_brightness(req, body);
|
||
cJSON_Delete(body);
|
||
if (zb == -2) {
|
||
return ESP_OK;
|
||
}
|
||
int b = api_effective_brightness(mac, zb);
|
||
cJSON *msg = cJSON_CreateObject();
|
||
cJSON_AddStringToObject(msg, "v", "1");
|
||
cJSON_AddNumberToObject(msg, "b", b);
|
||
cJSON_AddTrueToObject(msg, "save");
|
||
if (push_to(mac, msg) != ESP_OK) {
|
||
return api_error(req, "503 Service Unavailable", "Send failed");
|
||
}
|
||
cJSON *o = cJSON_CreateObject();
|
||
cJSON_AddStringToObject(o, "message", "brightness sent");
|
||
cJSON_AddNumberToObject(o, "brightness", b);
|
||
return api_json(req, "200 OK", o, true);
|
||
}
|
||
|
||
// POST /devices/<id>/driver-config {name, num_leds, color_order, startup_mode}
|
||
static esp_err_t device_driver_config(httpd_req_t *req, const char *mac)
|
||
{
|
||
cJSON *body = api_body_opt(req);
|
||
if (!body) {
|
||
return ESP_OK;
|
||
}
|
||
cJSON *dc = api_driver_config(cJSON_GetObjectItem(body, "name"), cJSON_GetObjectItem(body, "num_leds"),
|
||
cJSON_GetObjectItem(body, "color_order"), cJSON_GetObjectItem(body, "startup_mode"));
|
||
cJSON_Delete(body);
|
||
if (!dc) {
|
||
return api_error(req, "400 Bad Request", "Provide at least one of name, num_leds, color_order, startup_mode");
|
||
}
|
||
cJSON *msg = cJSON_CreateObject();
|
||
cJSON_AddStringToObject(msg, "v", "1");
|
||
cJSON_AddItemToObject(msg, "device_config", dc);
|
||
cJSON_AddTrueToObject(msg, "save");
|
||
if (push_to(mac, msg) != ESP_OK) {
|
||
return api_error(req, "503 Service Unavailable", "Send failed");
|
||
}
|
||
return api_message(req, "200 OK", "driver-config sent");
|
||
}
|
||
|
||
/* ------------------------------------------------------------------- ping */
|
||
|
||
#define PING_MAX 32
|
||
|
||
typedef struct {
|
||
uint8_t mac[6];
|
||
char name[33];
|
||
int rtt_ms;
|
||
} ping_rsp_t;
|
||
|
||
static struct {
|
||
uint32_t id; // 0 = no ping running
|
||
int64_t sent_us;
|
||
int count;
|
||
ping_rsp_t rsp[PING_MAX];
|
||
} s_ping;
|
||
static portMUX_TYPE s_ping_mux = portMUX_INITIALIZER_UNLOCKED;
|
||
|
||
// Rel task: [4C][06][ping_id u32 LE][len][name]
|
||
static void on_ping_rsp(const uint8_t mac[6], const uint8_t *pkt, int len)
|
||
{
|
||
if (len < 7) {
|
||
return;
|
||
}
|
||
uint32_t id = pkt[2] | (pkt[3] << 8) | (pkt[4] << 16) | ((uint32_t)pkt[5] << 24);
|
||
int nl = pkt[6] < len - 7 ? pkt[6] : len - 7;
|
||
int64_t now = esp_timer_get_time();
|
||
portENTER_CRITICAL(&s_ping_mux);
|
||
if (id && id == s_ping.id && s_ping.count < PING_MAX) {
|
||
bool seen = false;
|
||
for (int i = 0; i < s_ping.count && !seen; i++) {
|
||
seen = !memcmp(s_ping.rsp[i].mac, mac, 6);
|
||
}
|
||
if (!seen) {
|
||
ping_rsp_t *r = &s_ping.rsp[s_ping.count++];
|
||
memcpy(r->mac, mac, 6);
|
||
nl = nl < (int)sizeof(r->name) - 1 ? nl : (int)sizeof(r->name) - 1;
|
||
memcpy(r->name, pkt + 7, nl);
|
||
r->name[nl] = 0;
|
||
r->rtt_ms = (int)((now - s_ping.sent_us) / 1000);
|
||
}
|
||
}
|
||
portEXIT_CRITICAL(&s_ping_mux);
|
||
}
|
||
|
||
// Add a driver that answered but is not registered yet, or take its new name. True when stored.
|
||
static bool register_from_ping(const char *hex, const char *name)
|
||
{
|
||
char label[48];
|
||
snprintf(label, sizeof(label), "%s", name);
|
||
if (!label[0]) {
|
||
snprintf(label, sizeof(label), "led-%s", hex);
|
||
}
|
||
cJSON *devs = store_coll("device");
|
||
cJSON *rec = cJSON_GetObjectItem(devs, hex);
|
||
if (!rec) {
|
||
rec = cJSON_AddObjectToObject(devs, hex);
|
||
cJSON_AddStringToObject(rec, "id", hex);
|
||
cJSON_AddStringToObject(rec, "name", label);
|
||
cJSON_AddStringToObject(rec, "type", "led");
|
||
cJSON_AddStringToObject(rec, "transport", "espnow");
|
||
cJSON_AddStringToObject(rec, "address", hex);
|
||
return true;
|
||
}
|
||
const cJSON *old = cJSON_GetObjectItem(rec, "name");
|
||
if (is_espnow(rec) && (!cJSON_IsString(old) || strcmp(old->valuestring, label))) {
|
||
api_set(rec, "name", cJSON_CreateString(label));
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
// POST /devices/ping {timeout_s}: broadcast PING_REQ and collect replies for timeout_s (0.5-30, default 3)
|
||
static esp_err_t ping_devices(httpd_req_t *req)
|
||
{
|
||
static bool hooked; // replies only matter while a ping runs, so the callback is set on first use
|
||
if (!hooked) {
|
||
rel_set_ping_cb(on_ping_rsp);
|
||
hooked = true;
|
||
}
|
||
cJSON *body = api_body_opt(req);
|
||
if (!body) {
|
||
return ESP_OK;
|
||
}
|
||
const cJSON *t = cJSON_GetObjectItem(body, "timeout_s");
|
||
if (t && !cJSON_IsNull(t) && !cJSON_IsNumber(t)) {
|
||
cJSON_Delete(body);
|
||
return api_error(req, "400 Bad Request", "Invalid timeout_s");
|
||
}
|
||
double timeout_s = cJSON_IsNumber(t) ? t->valuedouble : 3.0;
|
||
timeout_s = timeout_s < 0.5 ? 0.5 : (timeout_s > 30 ? 30 : timeout_s);
|
||
cJSON_Delete(body);
|
||
|
||
portENTER_CRITICAL(&s_ping_mux);
|
||
bool busy = s_ping.id != 0;
|
||
uint32_t id = (esp_random() | 1);
|
||
if (!busy) {
|
||
s_ping.id = id;
|
||
s_ping.count = 0;
|
||
s_ping.sent_us = esp_timer_get_time();
|
||
}
|
||
portEXIT_CRITICAL(&s_ping_mux);
|
||
if (busy) {
|
||
return api_error(req, "409 Conflict", "a ping is already running");
|
||
}
|
||
uint8_t pkt[6] = { 0x4C, 0x05, id & 255, (id >> 8) & 255, (id >> 16) & 255, id >> 24 };
|
||
esp_err_t err = espnow_tx_send(NULL, pkt, sizeof(pkt));
|
||
vTaskDelay(pdMS_TO_TICKS(20));
|
||
espnow_tx_send(NULL, pkt, sizeof(pkt)); // a second copy against a lost broadcast; replies are deduplicated
|
||
if (err == ESP_OK) {
|
||
store_unlock(); // replies take up to timeout_s; HTTP and the sequencer keep going
|
||
vTaskDelay(pdMS_TO_TICKS((int)(timeout_s * 1000)));
|
||
store_lock();
|
||
}
|
||
static ping_rsp_t got[PING_MAX];
|
||
portENTER_CRITICAL(&s_ping_mux);
|
||
int n = s_ping.count;
|
||
memcpy(got, s_ping.rsp, n * sizeof(got[0]));
|
||
s_ping.id = 0;
|
||
portEXIT_CRITICAL(&s_ping_mux);
|
||
if (err != ESP_OK) {
|
||
return api_error(req, "503 Service Unavailable", "Send failed");
|
||
}
|
||
|
||
cJSON *o = cJSON_CreateObject(), *responses;
|
||
cJSON_AddTrueToObject(o, "ok");
|
||
cJSON_AddNumberToObject(o, "ping_id", id);
|
||
cJSON_AddNumberToObject(o, "timeout_s", timeout_s);
|
||
responses = cJSON_AddObjectToObject(o, "responses");
|
||
int registered = 0;
|
||
for (int i = 0; i < n; i++) {
|
||
char hex[13];
|
||
const uint8_t *m = got[i].mac;
|
||
snprintf(hex, sizeof(hex), "%02x%02x%02x%02x%02x%02x", m[0], m[1], m[2], m[3], m[4], m[5]);
|
||
cJSON *r = cJSON_AddObjectToObject(responses, hex);
|
||
cJSON_AddStringToObject(r, "mac", hex);
|
||
cJSON_AddStringToObject(r, "name", got[i].name);
|
||
cJSON_AddNumberToObject(r, "rtt_ms", got[i].rtt_ms);
|
||
registered += register_from_ping(hex, got[i].name);
|
||
}
|
||
cJSON_AddNumberToObject(o, "registered", registered);
|
||
if (registered) {
|
||
store_save("device");
|
||
engine_groups_changed();
|
||
}
|
||
return api_json(req, "200 OK", o, true);
|
||
}
|
||
|
||
// POST /devices/groups: push group membership to every ESP-NOW driver and report the acks
|
||
static esp_err_t push_groups(httpd_req_t *req)
|
||
{
|
||
int total, sent, failed;
|
||
store_unlock(); // waits up to a few seconds for acks
|
||
engine_groups_push_all(&total, &sent, &failed);
|
||
store_lock();
|
||
if (!total) {
|
||
cJSON *o = cJSON_CreateObject();
|
||
cJSON_AddFalseToObject(o, "ok");
|
||
cJSON_AddStringToObject(o, "error", "No ESP-NOW devices in registry");
|
||
return api_json(req, "400 Bad Request", o, true);
|
||
}
|
||
cJSON *o = cJSON_CreateObject();
|
||
cJSON_AddBoolToObject(o, "ok", failed == 0);
|
||
cJSON_AddNumberToObject(o, "total", total);
|
||
cJSON_AddNumberToObject(o, "sent", sent);
|
||
cJSON_AddNumberToObject(o, "failed", failed);
|
||
return api_json(req, failed ? "503 Service Unavailable" : "200 OK", o, true);
|
||
}
|
||
|
||
// Per-driver delivery health from the acked link
|
||
static esp_err_t device_status(httpd_req_t *req)
|
||
{
|
||
cJSON *o = cJSON_CreateObject(), *d;
|
||
cJSON_ArrayForEach(d, store_coll("device"))
|
||
{
|
||
const cJSON *addr = cJSON_GetObjectItem(d, "address");
|
||
const char *hex = (cJSON_IsString(addr) && strlen(addr->valuestring) == 12) ? addr->valuestring
|
||
: (strlen(d->string) == 12 ? d->string : NULL);
|
||
uint8_t mac[6];
|
||
unsigned v[6];
|
||
if (hex && sscanf(hex, "%2x%2x%2x%2x%2x%2x", &v[0], &v[1], &v[2], &v[3], &v[4], &v[5]) == 6) {
|
||
for (int i = 0; i < 6; i++) {
|
||
mac[i] = v[i];
|
||
}
|
||
int fails;
|
||
int age = rel_peer_status(mac, &fails);
|
||
cJSON *e = cJSON_AddObjectToObject(o, d->string);
|
||
cJSON_AddNumberToObject(e, "last_ack_ms_ago", age);
|
||
cJSON_AddNumberToObject(e, "failed_messages", fails);
|
||
}
|
||
}
|
||
return api_json(req, "200 OK", o, true);
|
||
}
|
||
|
||
bool devices_route(httpd_req_t *req, int n, api_seg_t seg, esp_err_t *ret)
|
||
{
|
||
const int method = req->method;
|
||
if (n == 2 && method == HTTP_GET && !strcmp(seg[1], "status")) {
|
||
*ret = device_status(req);
|
||
return true;
|
||
}
|
||
if (n == 2 && method == HTTP_POST && !strcmp(seg[1], "ping")) {
|
||
*ret = ping_devices(req);
|
||
return true;
|
||
}
|
||
if (n == 2 && method == HTTP_POST && !strcmp(seg[1], "groups")) {
|
||
*ret = push_groups(req);
|
||
return true;
|
||
}
|
||
if (n == 2 && method == HTTP_POST && !strcmp(seg[1], "resolve-brightness")) {
|
||
*ret = resolve_brightness(req);
|
||
return true;
|
||
}
|
||
if (n == 1) {
|
||
if (method == HTTP_GET) {
|
||
cJSON *o = cJSON_CreateObject(), *d;
|
||
cJSON_ArrayForEach(d, store_coll("device"))
|
||
{
|
||
cJSON_AddItemToObject(o, d->string, with_connected(d));
|
||
}
|
||
*ret = api_json(req, "200 OK", o, true);
|
||
return true;
|
||
}
|
||
if (method == HTTP_POST) {
|
||
*ret = create_device(req);
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
char mac[13];
|
||
cJSON *dev = find(seg[1], mac);
|
||
if (!dev) {
|
||
*ret = api_error(req, "404 Not Found", "Device not found");
|
||
return true;
|
||
}
|
||
if (n == 3) {
|
||
if (method == HTTP_POST && !strcmp(seg[2], "identify")) {
|
||
*ret = identify(req, dev, mac);
|
||
} else if (method == HTTP_POST && !strcmp(seg[2], "brightness")) {
|
||
*ret = device_brightness(req, mac);
|
||
} else if (method == HTTP_POST && !strcmp(seg[2], "driver-config")) {
|
||
*ret = device_driver_config(req, mac);
|
||
} else if (method == HTTP_POST && !strcmp(seg[2], "patterns")) {
|
||
*ret = api_error(req, "400 Bad Request", "Pattern OTA push is not supported for ESP-NOW devices; use POST /patterns/<name>/send");
|
||
} else {
|
||
*ret = api_error(req, "404 Not Found", "unknown action");
|
||
}
|
||
return true;
|
||
}
|
||
switch (method) {
|
||
case HTTP_GET:
|
||
*ret = api_json(req, "200 OK", with_connected(dev), true);
|
||
return true;
|
||
case HTTP_PUT:
|
||
*ret = update_device(req, dev, mac);
|
||
return true;
|
||
case HTTP_DELETE:
|
||
cJSON_DeleteItemFromObject(store_coll("device"), mac);
|
||
store_save("device");
|
||
engine_groups_changed();
|
||
*ret = api_message(req, "200 OK", "Device deleted successfully");
|
||
return true;
|
||
default:
|
||
return false;
|
||
}
|
||
}
|