feat: DDP frame sync over UDP broadcast, DDP acks, DDP enable setting
- Driver acks each completed DDP frame; the test waits for the acks before broadcasting the sync. - Sync listener on UDP 4049: a frame is held until the next sync, then shown. - DDP pixels are shown at full brightness, ignoring the device brightness settings. - "DDP and sync receive on" setting (NVS, network API, web UI); off ignores DDP and sync packets. - ddp_test.py: finds devices on the subnet, drives them in lockstep at a fixed rate, runs animations. - /api/ddp reports sync counters for diagnosis. - Includes in-progress WebSocket, multi-driver web UI and Wi-Fi work from the same tree. Co-Authored-By: Claude Haiku 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
47f4eba0d6
commit
4cd3bc7973
294 files changed
+48954
-301
No files matched your search
+539
-129
@@ -11,6 +11,9 @@
|
||||
#include "esp_http_server.h"
|
||||
#include "esp_log.h"
|
||||
#include "esp_netif.h"
|
||||
#include "esp_timer.h"
|
||||
#include <netinet/tcp.h>
|
||||
#include <sys/socket.h>
|
||||
#include "esp_wifi.h"
|
||||
#include "net.h"
|
||||
#include "ota.h"
|
||||
@@ -20,6 +23,7 @@
|
||||
#include "presets.h"
|
||||
#include "settings.h"
|
||||
#include "web.h"
|
||||
#include "ws_client.h"
|
||||
|
||||
static const char *TAG = "web";
|
||||
|
||||
@@ -122,38 +126,74 @@ void web_allow_lan_origin(httpd_req_t *req)
|
||||
httpd_resp_set_hdr(req, "Vary", "Origin");
|
||||
}
|
||||
|
||||
static esp_err_t send_json(httpd_req_t *req, cJSON *obj)
|
||||
// One API call, from an HTTP request or from a WebSocket message. Handlers use only the helpers
|
||||
// below, so the same handler serves both.
|
||||
typedef struct {
|
||||
httpd_req_t *http; // the HTTP request, or NULL for a WebSocket call
|
||||
const char *body; // WebSocket call: the request body text
|
||||
const char *query; // WebSocket call: the query string after '?', or ""
|
||||
char *out; // WebSocket call: the reply text is written here
|
||||
size_t out_cap;
|
||||
int status; // WebSocket call: the reply's status code
|
||||
} api_req_t;
|
||||
|
||||
typedef esp_err_t (*api_fn_t)(api_req_t *req);
|
||||
|
||||
// Send a JSON reply. status is a status line such as "200 OK".
|
||||
static esp_err_t send_text(api_req_t *req, const char *status, const char *text)
|
||||
{
|
||||
if (req->http) {
|
||||
web_allow_lan_origin(req->http);
|
||||
httpd_resp_set_status(req->http, status);
|
||||
httpd_resp_set_type(req->http, "application/json");
|
||||
return httpd_resp_sendstr(req->http, text);
|
||||
}
|
||||
req->status = atoi(status);
|
||||
snprintf(req->out, req->out_cap, "%s", text);
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
static esp_err_t send_json(api_req_t *req, cJSON *obj)
|
||||
{
|
||||
char *s = cJSON_PrintUnformatted(obj);
|
||||
cJSON_Delete(obj);
|
||||
web_allow_lan_origin(req);
|
||||
if (!s) {
|
||||
return httpd_resp_send_500(req);
|
||||
return send_text(req, "500 Internal Server Error", "{\"error\":\"out of memory\"}");
|
||||
}
|
||||
httpd_resp_set_type(req, "application/json");
|
||||
esp_err_t err = httpd_resp_sendstr(req, s);
|
||||
esp_err_t err = send_text(req, "200 OK", s);
|
||||
cJSON_free(s);
|
||||
return err;
|
||||
}
|
||||
|
||||
static esp_err_t send_error(httpd_req_t *req, const char *status, const char *msg)
|
||||
static esp_err_t send_error(api_req_t *req, const char *status, const char *msg)
|
||||
{
|
||||
httpd_resp_set_status(req, status);
|
||||
cJSON *o = cJSON_CreateObject();
|
||||
cJSON_AddStringToObject(o, "error", msg);
|
||||
return send_json(req, o);
|
||||
char *s = cJSON_PrintUnformatted(o);
|
||||
cJSON_Delete(o);
|
||||
esp_err_t err = send_text(req, status, s ? s : "{}");
|
||||
cJSON_free(s);
|
||||
return err;
|
||||
}
|
||||
|
||||
// Read the request body into buf (NUL-terminated). False if missing, too big or unreadable.
|
||||
static bool read_body(httpd_req_t *req, char *buf, size_t cap)
|
||||
static bool read_body(api_req_t *req, char *buf, size_t cap)
|
||||
{
|
||||
int len = req->content_len;
|
||||
if (!req->http) {
|
||||
size_t n = req->body ? strlen(req->body) : 0;
|
||||
if (n == 0 || n >= cap) {
|
||||
return false;
|
||||
}
|
||||
memcpy(buf, req->body, n + 1);
|
||||
return true;
|
||||
}
|
||||
int len = req->http->content_len;
|
||||
if (len <= 0 || (size_t)len >= cap) {
|
||||
return false;
|
||||
}
|
||||
int got = 0;
|
||||
while (got < len) {
|
||||
int r = httpd_req_recv(req, buf + got, len - got);
|
||||
int r = httpd_req_recv(req->http, buf + got, len - got);
|
||||
if (r <= 0) {
|
||||
return false;
|
||||
}
|
||||
@@ -164,7 +204,7 @@ static bool read_body(httpd_req_t *req, char *buf, size_t cap)
|
||||
}
|
||||
|
||||
// Read a JSON body; NULL (no reply sent) if missing, too big or not JSON. Caller frees with cJSON_Delete.
|
||||
static cJSON *read_json(httpd_req_t *req)
|
||||
static cJSON *read_json(api_req_t *req)
|
||||
{
|
||||
char body[MAX_BODY];
|
||||
if (!read_body(req, body, sizeof(body))) {
|
||||
@@ -190,7 +230,7 @@ static esp_err_t style_css_get(httpd_req_t *req)
|
||||
}
|
||||
|
||||
// GET /api/status : the running preset (same fields as a preset), plus device and network state
|
||||
static esp_err_t status_get(httpd_req_t *req)
|
||||
static esp_err_t status_get(api_req_t *req)
|
||||
{
|
||||
preset_t p;
|
||||
patterns_get(&p);
|
||||
@@ -207,6 +247,7 @@ static esp_err_t status_get(httpd_req_t *req)
|
||||
cJSON_AddStringToObject(o, "sta_ip", ip);
|
||||
cJSON_AddStringToObject(o, "selected", presets_selected());
|
||||
cJSON_AddNumberToObject(o, "global_brightness", patterns_get_global());
|
||||
cJSON_AddNumberToObject(o, "master_brightness", patterns_get_master());
|
||||
cJSON *modes = cJSON_AddArrayToObject(o, "patterns");
|
||||
for (int i = 0; i < patterns_count(); i++) {
|
||||
cJSON_AddItemToArray(modes, cJSON_CreateString(patterns_name(i)));
|
||||
@@ -215,7 +256,7 @@ static esp_err_t status_get(httpd_req_t *req)
|
||||
}
|
||||
|
||||
// POST /api/pattern : change the running settings. Fields missing from the body keep their value.
|
||||
static esp_err_t pattern_post(httpd_req_t *req)
|
||||
static esp_err_t pattern_post(api_req_t *req)
|
||||
{
|
||||
cJSON *in = read_json(req);
|
||||
if (!in) {
|
||||
@@ -233,7 +274,7 @@ static esp_err_t pattern_post(httpd_req_t *req)
|
||||
}
|
||||
|
||||
// GET /api/wifi : saved client SSID and connection state
|
||||
static esp_err_t wifi_get(httpd_req_t *req)
|
||||
static esp_err_t wifi_get(api_req_t *req)
|
||||
{
|
||||
wifi_creds_t c = {};
|
||||
settings_load_wifi(&c);
|
||||
@@ -247,7 +288,7 @@ static esp_err_t wifi_get(httpd_req_t *req)
|
||||
}
|
||||
|
||||
// POST /api/wifi {"ssid","password"} : save and connect
|
||||
static esp_err_t wifi_post(httpd_req_t *req)
|
||||
static esp_err_t wifi_post(api_req_t *req)
|
||||
{
|
||||
char body[MAX_BODY];
|
||||
if (!read_body(req, body, sizeof(body))) {
|
||||
@@ -285,7 +326,7 @@ static esp_err_t wifi_post(httpd_req_t *req)
|
||||
}
|
||||
|
||||
// GET /api/wifi/scan : visible networks
|
||||
static esp_err_t wifi_scan_get(httpd_req_t *req)
|
||||
static esp_err_t wifi_scan_get(api_req_t *req)
|
||||
{
|
||||
static wifi_ap_record_t recs[MAX_SCAN];
|
||||
uint16_t count = MAX_SCAN;
|
||||
@@ -330,7 +371,7 @@ static bool valid_ipv4(const char *s)
|
||||
}
|
||||
|
||||
// GET /api/network : mDNS name and client address settings, with the current address
|
||||
static esp_err_t network_get(httpd_req_t *req)
|
||||
static esp_err_t network_get(api_req_t *req)
|
||||
{
|
||||
net_cfg_t n;
|
||||
settings_load_net(&n);
|
||||
@@ -345,12 +386,14 @@ static esp_err_t network_get(httpd_req_t *req)
|
||||
cJSON_AddStringToObject(o, "dns", n.dns);
|
||||
cJSON_AddBoolToObject(o, "connected", up);
|
||||
cJSON_AddStringToObject(o, "current_ip", ip);
|
||||
cJSON_AddBoolToObject(o, "ap_enabled", n.ap_enabled);
|
||||
cJSON_AddBoolToObject(o, "ddp_enabled", n.ddp_enabled);
|
||||
return send_json(req, o);
|
||||
}
|
||||
|
||||
// POST /api/network {"hostname","mode":"dhcp"|"static","ip","netmask","gateway","dns"}
|
||||
// Missing fields keep their current value. Saves, applies and reconnects the client.
|
||||
static esp_err_t network_post(httpd_req_t *req)
|
||||
static esp_err_t network_post(api_req_t *req)
|
||||
{
|
||||
cJSON *in = read_json(req);
|
||||
if (!in) {
|
||||
@@ -399,6 +442,15 @@ static esp_err_t network_post(httpd_req_t *req)
|
||||
f.dst[f.len - 1] = '\0';
|
||||
}
|
||||
}
|
||||
cJSON *ap = cJSON_GetObjectItem(in, "ap_enabled");
|
||||
if (cJSON_IsBool(ap)) {
|
||||
n.ap_enabled = cJSON_IsTrue(ap);
|
||||
}
|
||||
cJSON *ddp = cJSON_GetObjectItem(in, "ddp_enabled");
|
||||
if (cJSON_IsBool(ddp)) {
|
||||
n.ddp_enabled = cJSON_IsTrue(ddp);
|
||||
ddp_set_enabled(n.ddp_enabled);
|
||||
}
|
||||
cJSON_Delete(in);
|
||||
|
||||
if (n.use_static) {
|
||||
@@ -411,6 +463,9 @@ static esp_err_t network_post(httpd_req_t *req)
|
||||
}
|
||||
|
||||
esp_err_t err = net_save_network(&n);
|
||||
if (err == ESP_ERR_INVALID_STATE) {
|
||||
return send_error(req, "400 Bad Request", "connect to a Wi-Fi network before turning the access point off");
|
||||
}
|
||||
if (err != ESP_OK) {
|
||||
ESP_LOGW(TAG, "Network apply failed: %s", esp_err_to_name(err));
|
||||
return send_error(req, "500 Internal Server Error", esp_err_to_name(err));
|
||||
@@ -451,7 +506,7 @@ static bool valid_pin(int pin)
|
||||
}
|
||||
|
||||
// GET /api/hardware : LED strip settings
|
||||
static esp_err_t hardware_get(httpd_req_t *req)
|
||||
static esp_err_t hardware_get(api_req_t *req)
|
||||
{
|
||||
hw_cfg_t hw;
|
||||
settings_load_hw(&hw);
|
||||
@@ -464,7 +519,7 @@ static esp_err_t hardware_get(httpd_req_t *req)
|
||||
}
|
||||
|
||||
// POST /api/hardware {"rgb_order","max_brightness":0-255,"num_leds":1-512}. Missing fields keep their value.
|
||||
static esp_err_t hardware_post(httpd_req_t *req)
|
||||
static esp_err_t hardware_post(api_req_t *req)
|
||||
{
|
||||
cJSON *in = read_json(req);
|
||||
if (!in) {
|
||||
@@ -523,18 +578,21 @@ static esp_err_t hardware_post(httpd_req_t *req)
|
||||
}
|
||||
|
||||
// GET /api/ddp[?led=N] : DDP receiver state, and the colour shown on LED N (for checks)
|
||||
static esp_err_t ddp_get(httpd_req_t *req)
|
||||
static esp_err_t ddp_get(api_req_t *req)
|
||||
{
|
||||
bool active;
|
||||
uint32_t packets;
|
||||
patterns_ddp_status(&active, &packets);
|
||||
int led = 0;
|
||||
char q[32];
|
||||
if (httpd_req_get_url_query_str(req, q, sizeof(q)) == ESP_OK) {
|
||||
char v[8];
|
||||
if (httpd_query_key_value(q, "led", v, sizeof(v)) == ESP_OK) {
|
||||
led = atoi(v);
|
||||
}
|
||||
char q[32] = "";
|
||||
if (req->http) {
|
||||
httpd_req_get_url_query_str(req->http, q, sizeof(q));
|
||||
} else {
|
||||
snprintf(q, sizeof(q), "%s", req->query);
|
||||
}
|
||||
char v[8];
|
||||
if (httpd_query_key_value(q, "led", v, sizeof(v)) == ESP_OK) {
|
||||
led = atoi(v);
|
||||
}
|
||||
uint8_t px[3];
|
||||
patterns_shown_pixel(led, px);
|
||||
@@ -542,6 +600,16 @@ static esp_err_t ddp_get(httpd_req_t *req)
|
||||
cJSON_AddBoolToObject(o, "active", active);
|
||||
cJSON_AddNumberToObject(o, "packets", packets);
|
||||
cJSON_AddNumberToObject(o, "port", DDP_PORT);
|
||||
patterns_ddp_debug_t dbg;
|
||||
patterns_ddp_debug(&dbg);
|
||||
cJSON *sy = cJSON_AddObjectToObject(o, "sync");
|
||||
cJSON_AddNumberToObject(sy, "port", DDP_SYNC_PORT);
|
||||
cJSON_AddNumberToObject(sy, "syncs", dbg.syncs);
|
||||
cJSON_AddNumberToObject(sy, "seq", dbg.sync_seq);
|
||||
cJSON_AddNumberToObject(sy, "age_ms", dbg.sync_age_ms == UINT32_MAX ? -1 : (double)dbg.sync_age_ms);
|
||||
cJSON_AddNumberToObject(sy, "frames", dbg.frames);
|
||||
cJSON_AddNumberToObject(sy, "shown", dbg.shown);
|
||||
cJSON_AddBoolToObject(sy, "held", dbg.held);
|
||||
cJSON_AddNumberToObject(o, "led", led);
|
||||
cJSON *px_arr = cJSON_AddArrayToObject(o, "rgb");
|
||||
for (int i = 0; i < 3; i++) {
|
||||
@@ -551,7 +619,7 @@ static esp_err_t ddp_get(httpd_req_t *req)
|
||||
}
|
||||
|
||||
// POST /api/presets/order {"names":[...]} : the presets' order on the front page
|
||||
static esp_err_t presets_order_post(httpd_req_t *req)
|
||||
static esp_err_t presets_order_post(api_req_t *req)
|
||||
{
|
||||
cJSON *in = read_json(req);
|
||||
if (!in) {
|
||||
@@ -578,7 +646,7 @@ static esp_err_t presets_order_post(httpd_req_t *req)
|
||||
}
|
||||
|
||||
// POST /api/presets/defaults : add the default presets that are missing
|
||||
static esp_err_t presets_defaults_post(httpd_req_t *req)
|
||||
static esp_err_t presets_defaults_post(api_req_t *req)
|
||||
{
|
||||
cJSON *o = cJSON_CreateObject();
|
||||
cJSON_AddNumberToObject(o, "added", presets_add_defaults());
|
||||
@@ -586,7 +654,7 @@ static esp_err_t presets_defaults_post(httpd_req_t *req)
|
||||
}
|
||||
|
||||
// GET /api/presets
|
||||
static esp_err_t presets_get(httpd_req_t *req)
|
||||
static esp_err_t presets_get(api_req_t *req)
|
||||
{
|
||||
cJSON *o = cJSON_CreateObject();
|
||||
cJSON *arr = cJSON_AddArrayToObject(o, "presets");
|
||||
@@ -599,32 +667,52 @@ static esp_err_t presets_get(httpd_req_t *req)
|
||||
return send_json(req, o);
|
||||
}
|
||||
|
||||
// POST /api/brightness {"brightness":0-255} : live brightness for every pattern, saved
|
||||
static esp_err_t brightness_post(httpd_req_t *req)
|
||||
// POST /api/brightness {"brightness":0-255} sets this device's level; {"master":0-255} sets its
|
||||
// master scale (sent to every device by "All devices"). Either or both, saved.
|
||||
// Returns NULL when applied, or the error message.
|
||||
static const char *brightness_apply(const cJSON *in)
|
||||
{
|
||||
const cJSON *v = cJSON_GetObjectItem(in, "brightness");
|
||||
const cJSON *m = cJSON_GetObjectItem(in, "master");
|
||||
if (!v && !m) {
|
||||
return "send brightness and/or master";
|
||||
}
|
||||
if ((v && (!cJSON_IsNumber(v) || v->valueint < 0 || v->valueint > 255)) ||
|
||||
(m && (!cJSON_IsNumber(m) || m->valueint < 0 || m->valueint > 255))) {
|
||||
return "brightness and master must be 0-255";
|
||||
}
|
||||
hw_cfg_t hw;
|
||||
settings_load_hw(&hw);
|
||||
if (v) {
|
||||
hw.global_brightness = (uint8_t)v->valueint;
|
||||
patterns_set_global(hw.global_brightness);
|
||||
}
|
||||
if (m) {
|
||||
hw.master_brightness = (uint8_t)m->valueint;
|
||||
patterns_set_master(hw.master_brightness);
|
||||
}
|
||||
settings_save_hw(&hw);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static esp_err_t brightness_post(api_req_t *req)
|
||||
{
|
||||
cJSON *in = read_json(req);
|
||||
if (!in) {
|
||||
return send_error(req, "400 Bad Request", "empty, too large or invalid JSON");
|
||||
}
|
||||
cJSON *v = cJSON_GetObjectItem(in, "brightness");
|
||||
if (!cJSON_IsNumber(v) || v->valueint < 0 || v->valueint > 255) {
|
||||
cJSON_Delete(in);
|
||||
return send_error(req, "400 Bad Request", "brightness must be 0-255");
|
||||
}
|
||||
uint8_t level = (uint8_t)v->valueint;
|
||||
const char *err = brightness_apply(in);
|
||||
cJSON_Delete(in);
|
||||
patterns_set_global(level);
|
||||
hw_cfg_t hw;
|
||||
settings_load_hw(&hw);
|
||||
hw.global_brightness = level;
|
||||
settings_save_hw(&hw);
|
||||
if (err) {
|
||||
return send_error(req, "400 Bad Request", err);
|
||||
}
|
||||
cJSON *o = cJSON_CreateObject();
|
||||
cJSON_AddStringToObject(o, "message", "saved");
|
||||
return send_json(req, o);
|
||||
}
|
||||
|
||||
// POST /api/presets : create or update by name. Missing fields take the running settings.
|
||||
static esp_err_t presets_post(httpd_req_t *req)
|
||||
static esp_err_t presets_post(api_req_t *req)
|
||||
{
|
||||
cJSON *in = read_json(req);
|
||||
if (!in) {
|
||||
@@ -656,7 +744,7 @@ static esp_err_t presets_post(httpd_req_t *req)
|
||||
}
|
||||
|
||||
// Shared body for select, delete and startup: {"name"}
|
||||
static esp_err_t preset_name_action(httpd_req_t *req, esp_err_t (*action)(const char *), const char *ok_msg)
|
||||
static esp_err_t preset_name_action(api_req_t *req, esp_err_t (*action)(const char *), const char *ok_msg)
|
||||
{
|
||||
cJSON *in = read_json(req);
|
||||
if (!in) {
|
||||
@@ -684,24 +772,25 @@ static esp_err_t preset_name_action(httpd_req_t *req, esp_err_t (*action)(const
|
||||
return send_json(req, o);
|
||||
}
|
||||
|
||||
static esp_err_t select_post(httpd_req_t *req)
|
||||
static esp_err_t select_post(api_req_t *req)
|
||||
{
|
||||
return preset_name_action(req, presets_select, "selected");
|
||||
}
|
||||
|
||||
static esp_err_t delete_post(httpd_req_t *req)
|
||||
static esp_err_t delete_post(api_req_t *req)
|
||||
{
|
||||
return preset_name_action(req, presets_delete, "deleted");
|
||||
}
|
||||
|
||||
static esp_err_t startup_post(httpd_req_t *req)
|
||||
static esp_err_t startup_post(api_req_t *req)
|
||||
{
|
||||
return preset_name_action(req, presets_set_startup, "startup set");
|
||||
}
|
||||
|
||||
static void add_uri(httpd_handle_t srv, const char *uri, httpd_method_t method, esp_err_t (*handler)(httpd_req_t *))
|
||||
{
|
||||
httpd_uri_t u = { .uri = uri, .method = method, .handler = handler, .user_ctx = NULL };
|
||||
httpd_uri_t u = { .uri = uri, .method = method, .handler = handler, .user_ctx = NULL,
|
||||
.is_websocket = false, .handle_ws_control_frames = false, .supported_subprotocol = NULL };
|
||||
httpd_register_uri_handler(srv, &u);
|
||||
}
|
||||
|
||||
@@ -734,90 +823,240 @@ static bool relay_path_ok(const char *p)
|
||||
return strstr(p, "..") == NULL && strchr(p, ' ') == NULL && strchr(p, '\r') == NULL && strchr(p, '\n') == NULL;
|
||||
}
|
||||
|
||||
// Relay connections are kept open per peer, so a relayed request does not pay for a new TCP connection.
|
||||
// The HTTP server runs one task, so relay calls never overlap and the slots need no lock.
|
||||
#define RELAY_SLOTS 4
|
||||
#define RELAY_TIMEOUT_MS 4000
|
||||
struct relay_slot_t {
|
||||
char host[80];
|
||||
esp_http_client_handle_t cl;
|
||||
};
|
||||
static relay_slot_t s_relay[RELAY_SLOTS];
|
||||
|
||||
// The kept-open client for this host, pointed at url. A new slot evicts the oldest one.
|
||||
static esp_http_client_handle_t relay_client(const char *host, const char *url)
|
||||
{
|
||||
int slot = -1;
|
||||
for (int i = 0; i < RELAY_SLOTS; i++) {
|
||||
if (s_relay[i].cl && strcmp(s_relay[i].host, host) == 0) {
|
||||
slot = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (slot < 0) {
|
||||
slot = 0;
|
||||
for (int i = 0; i < RELAY_SLOTS; i++) {
|
||||
if (!s_relay[i].cl) {
|
||||
slot = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (s_relay[slot].cl) {
|
||||
esp_http_client_cleanup(s_relay[slot].cl);
|
||||
}
|
||||
esp_http_client_config_t cfg = {};
|
||||
cfg.url = url;
|
||||
cfg.timeout_ms = RELAY_TIMEOUT_MS;
|
||||
cfg.keep_alive_enable = true;
|
||||
s_relay[slot].cl = esp_http_client_init(&cfg);
|
||||
snprintf(s_relay[slot].host, sizeof(s_relay[slot].host), "%s", host);
|
||||
return s_relay[slot].cl;
|
||||
}
|
||||
esp_http_client_set_url(s_relay[slot].cl, url);
|
||||
return s_relay[slot].cl;
|
||||
}
|
||||
|
||||
// One request to a peer over its kept-open connection. A dead connection is dropped and retried once.
|
||||
static esp_err_t relay_do(const char *host, const char *url, bool is_post, const char *body, int body_len,
|
||||
int *status, char *out, int cap, int *got)
|
||||
{
|
||||
for (int attempt = 0; attempt < 2; attempt++) {
|
||||
const int64_t t0 = esp_timer_get_time();
|
||||
esp_http_client_handle_t cl = relay_client(host, url);
|
||||
const int64_t t_client = esp_timer_get_time();
|
||||
if (!cl) {
|
||||
return ESP_ERR_NO_MEM;
|
||||
}
|
||||
esp_http_client_set_method(cl, is_post ? HTTP_METHOD_POST : HTTP_METHOD_GET);
|
||||
esp_http_client_set_header(cl, "Content-Type", "text/plain");
|
||||
esp_err_t err = esp_http_client_open(cl, is_post ? body_len : 0);
|
||||
const int64_t t_open = esp_timer_get_time();
|
||||
if (err == ESP_OK && is_post && body_len > 0 && esp_http_client_write(cl, body, body_len) != body_len) {
|
||||
err = ESP_FAIL;
|
||||
}
|
||||
const int64_t t_write = esp_timer_get_time();
|
||||
*got = 0;
|
||||
bool full = false;
|
||||
int fetch_rc = -1;
|
||||
if (err == ESP_OK) {
|
||||
fetch_rc = esp_http_client_fetch_headers(cl);
|
||||
}
|
||||
const int64_t t_headers = esp_timer_get_time();
|
||||
ESP_LOGI(TAG, "relay %s attempt %d: client %lld us, open %lld us, write %lld us, headers %lld us (rc %d, err %d)",
|
||||
host, attempt, (long long)(t_client - t0), (long long)(t_open - t_client),
|
||||
(long long)(t_write - t_open), (long long)(t_headers - t_write), fetch_rc, (int)err);
|
||||
if (err == ESP_OK && fetch_rc >= 0) {
|
||||
*status = esp_http_client_get_status_code(cl);
|
||||
int r;
|
||||
while (*got < cap && (r = esp_http_client_read(cl, out + *got, cap - *got)) > 0) {
|
||||
*got += r;
|
||||
}
|
||||
ESP_LOGI(TAG, "relay %s body %d bytes read in %lld us", host, *got,
|
||||
(long long)(esp_timer_get_time() - t_headers));
|
||||
full = *got >= cap; // more body than fits: keep what fits, and drop the connection
|
||||
if (!full) {
|
||||
return ESP_OK;
|
||||
}
|
||||
esp_http_client_close(cl);
|
||||
return ESP_OK;
|
||||
}
|
||||
// Failed before the answer: drop this connection and try once more
|
||||
esp_http_client_close(cl);
|
||||
}
|
||||
return ESP_FAIL;
|
||||
}
|
||||
|
||||
// Calls to a peer go over a kept-open WebSocket (its /ws), not a new HTTP request each time.
|
||||
#define WS_SLOTS 4
|
||||
struct ws_slot_t {
|
||||
char host[80]; // empty when the slot is free
|
||||
int fd;
|
||||
};
|
||||
static ws_slot_t s_ws[WS_SLOTS];
|
||||
|
||||
static void ws_slot_drop(ws_slot_t *slot)
|
||||
{
|
||||
ws_client_close(slot->fd);
|
||||
slot->fd = -1;
|
||||
slot->host[0] = '\0';
|
||||
}
|
||||
|
||||
// Send msg to host's /ws and read the reply into reply. Reconnects once if the connection is dead.
|
||||
static bool ws_fast_call(const char *host, const char *msg, char *reply, size_t cap)
|
||||
{
|
||||
for (int attempt = 0; attempt < 2; attempt++) {
|
||||
ws_slot_t *slot = NULL;
|
||||
for (int i = 0; i < WS_SLOTS; i++) {
|
||||
if (s_ws[i].host[0] && strcmp(s_ws[i].host, host) == 0) {
|
||||
slot = &s_ws[i];
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!slot) {
|
||||
for (int i = 0; i < WS_SLOTS && !slot; i++) {
|
||||
if (!s_ws[i].host[0]) {
|
||||
slot = &s_ws[i];
|
||||
}
|
||||
}
|
||||
if (!slot) {
|
||||
slot = &s_ws[0];
|
||||
ws_slot_drop(slot);
|
||||
}
|
||||
slot->fd = ws_client_connect(host, "/ws");
|
||||
if (slot->fd < 0) {
|
||||
slot->host[0] = '\0';
|
||||
return false;
|
||||
}
|
||||
snprintf(slot->host, sizeof(slot->host), "%s", host);
|
||||
}
|
||||
if (ws_client_send_text(slot->fd, msg, strlen(msg)) == ESP_OK && ws_client_recv_text(slot->fd, reply, cap) >= 0) {
|
||||
return true;
|
||||
}
|
||||
ws_slot_drop(slot);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
// The reply to a relayed or WebSocket call: {"status": n, "body": "..."}
|
||||
static void envelope(char *out, size_t cap, int status, const char *body_text)
|
||||
{
|
||||
cJSON *env = cJSON_CreateObject();
|
||||
cJSON_AddNumberToObject(env, "status", status);
|
||||
cJSON_AddStringToObject(env, "body", body_text);
|
||||
char *s = cJSON_PrintUnformatted(env);
|
||||
snprintf(out, cap, "%s", s ? s : "{}");
|
||||
cJSON_free(s);
|
||||
cJSON_Delete(env);
|
||||
}
|
||||
|
||||
// Call another driver's API. The peer's WebSocket is tried first (kept open, so it is fast); the HTTP
|
||||
// call is the fallback. out gets the envelope {"status": n, "body": "..."}.
|
||||
static void relay_forward(const char *host, const char *method, const char *path, const char *body,
|
||||
char *out, size_t cap)
|
||||
{
|
||||
if (!relay_host_ok(host) || !relay_path_ok(path) || (strcmp(method, "GET") != 0 && strcmp(method, "POST") != 0)) {
|
||||
envelope(out, cap, 400, "{\"error\":\"need host, method GET or POST, and a path under /api/\"}");
|
||||
return;
|
||||
}
|
||||
const bool is_post = strcmp(method, "POST") == 0;
|
||||
const char *b = is_post ? body : "";
|
||||
|
||||
cJSON *m = cJSON_CreateObject();
|
||||
cJSON_AddStringToObject(m, "method", method);
|
||||
cJSON_AddStringToObject(m, "path", path);
|
||||
cJSON_AddStringToObject(m, "body", b);
|
||||
char *msg = cJSON_PrintUnformatted(m);
|
||||
cJSON_Delete(m);
|
||||
bool ok = msg && ws_fast_call(host, msg, out, cap); // the peer's reply is already an envelope
|
||||
cJSON_free(msg);
|
||||
if (ok) {
|
||||
return;
|
||||
}
|
||||
|
||||
char *buf = (char *)malloc(4096);
|
||||
if (!buf) {
|
||||
envelope(out, cap, 503, "{\"error\":\"out of memory\"}");
|
||||
return;
|
||||
}
|
||||
char url[200];
|
||||
snprintf(url, sizeof(url), "http://%s%s", host, path);
|
||||
int got = 0;
|
||||
int status = 0;
|
||||
if (relay_do(host, url, is_post, b, (int)strlen(b), &status, buf, 4095, &got) != ESP_OK) {
|
||||
envelope(out, cap, 502, "{\"error\":\"could not reach that device\"}");
|
||||
} else {
|
||||
buf[got] = '\0';
|
||||
envelope(out, cap, status, buf);
|
||||
}
|
||||
free(buf);
|
||||
}
|
||||
|
||||
// POST /api/relay {"host": "10.1.1.50", "method": "GET" or "POST", "path": "/api/status", "body": "..."}
|
||||
// Calls another driver from here and answers {"status": n, "body": "..."}. A page on this driver only
|
||||
// talks to this driver, so the browser never has to reach the other device itself.
|
||||
static esp_err_t relay_post(httpd_req_t *req)
|
||||
// Kept for HTTP callers; the page itself sends relayed calls over the WebSocket.
|
||||
static esp_err_t relay_post(api_req_t *req)
|
||||
{
|
||||
// Heap buffers: the HTTP server task has an 8 KB stack
|
||||
char *in = (char *)malloc(2048);
|
||||
char *out = (char *)malloc(4096);
|
||||
char *out = (char *)malloc(8192);
|
||||
if (!in || !out) {
|
||||
free(in);
|
||||
free(out);
|
||||
return send_error(req, "503 Service Unavailable", "out of memory");
|
||||
}
|
||||
esp_err_t result = ESP_FAIL;
|
||||
esp_err_t result;
|
||||
if (!read_body(req, in, 2048)) {
|
||||
result = send_error(req, "400 Bad Request", "empty, too large or invalid JSON");
|
||||
goto done;
|
||||
} else {
|
||||
cJSON *top = cJSON_Parse(in);
|
||||
const cJSON *jh = top ? cJSON_GetObjectItem(top, "host") : NULL;
|
||||
const cJSON *jm = top ? cJSON_GetObjectItem(top, "method") : NULL;
|
||||
const cJSON *jp = top ? cJSON_GetObjectItem(top, "path") : NULL;
|
||||
const cJSON *jb = top ? cJSON_GetObjectItem(top, "body") : NULL;
|
||||
if (!cJSON_IsString(jh) || !cJSON_IsString(jm) || !cJSON_IsString(jp) || !relay_host_ok(jh->valuestring)
|
||||
|| !relay_path_ok(jp->valuestring) || (strcmp(jm->valuestring, "GET") != 0 && strcmp(jm->valuestring, "POST") != 0)) {
|
||||
if (!cJSON_IsString(jh) || !cJSON_IsString(jm) || !cJSON_IsString(jp)) {
|
||||
cJSON_Delete(top);
|
||||
result = send_error(req, "400 Bad Request", "need host, method GET or POST, and a path under /api/");
|
||||
goto done;
|
||||
}
|
||||
const bool is_post = strcmp(jm->valuestring, "POST") == 0;
|
||||
const char *body = (is_post && cJSON_IsString(jb)) ? jb->valuestring : "";
|
||||
const int body_len = (int)strlen(body);
|
||||
char url[200];
|
||||
snprintf(url, sizeof(url), "http://%s%s", jh->valuestring, jp->valuestring);
|
||||
esp_http_client_config_t ccfg = {};
|
||||
ccfg.url = url;
|
||||
ccfg.method = is_post ? HTTP_METHOD_POST : HTTP_METHOD_GET;
|
||||
ccfg.timeout_ms = 4000;
|
||||
esp_http_client_handle_t cl = esp_http_client_init(&ccfg);
|
||||
if (!cl) {
|
||||
cJSON_Delete(top);
|
||||
result = send_error(req, "502 Bad Gateway", "could not start the request");
|
||||
goto done;
|
||||
}
|
||||
esp_http_client_set_header(cl, "Content-Type", "text/plain");
|
||||
esp_err_t err = esp_http_client_open(cl, is_post ? body_len : 0);
|
||||
if (err == ESP_OK && is_post && body_len > 0) {
|
||||
if (esp_http_client_write(cl, body, body_len) != body_len) {
|
||||
err = ESP_FAIL;
|
||||
}
|
||||
}
|
||||
int got = 0;
|
||||
int status = 0;
|
||||
if (err == ESP_OK && esp_http_client_fetch_headers(cl) >= 0) {
|
||||
status = esp_http_client_get_status_code(cl);
|
||||
int r;
|
||||
while (got < 4095 && (r = esp_http_client_read(cl, out + got, 4095 - got)) > 0) {
|
||||
got += r;
|
||||
}
|
||||
result = send_error(req, "400 Bad Request", "need host, method and path");
|
||||
} else {
|
||||
err = ESP_FAIL;
|
||||
relay_forward(jh->valuestring, jm->valuestring, jp->valuestring,
|
||||
cJSON_IsString(jb) ? jb->valuestring : "", out, 8192);
|
||||
cJSON_Delete(top);
|
||||
result = send_text(req, "200 OK", out);
|
||||
}
|
||||
esp_http_client_close(cl);
|
||||
esp_http_client_cleanup(cl);
|
||||
cJSON_Delete(top);
|
||||
if (err != ESP_OK) {
|
||||
result = send_error(req, "502 Bad Gateway", "could not reach that device");
|
||||
goto done;
|
||||
}
|
||||
out[got] = '\0';
|
||||
cJSON *o = cJSON_CreateObject();
|
||||
cJSON_AddNumberToObject(o, "status", status);
|
||||
cJSON_AddStringToObject(o, "body", out);
|
||||
result = send_json(req, o);
|
||||
}
|
||||
done:
|
||||
free(in);
|
||||
free(out);
|
||||
return result;
|
||||
}
|
||||
|
||||
// GET /api/devices: the LED drivers on this network, found by mDNS (they advertise app=led-strip).
|
||||
// Includes this driver; the page leaves it out, since "This device" is already in the list.
|
||||
static esp_err_t devices_get(httpd_req_t *req)
|
||||
static esp_err_t devices_get(api_req_t *req)
|
||||
{
|
||||
cJSON *arr = cJSON_CreateArray();
|
||||
mdns_result_t *res = NULL;
|
||||
@@ -873,6 +1112,184 @@ static esp_err_t devices_get(httpd_req_t *req)
|
||||
return send_json(req, top);
|
||||
}
|
||||
|
||||
// The server sends each response header as its own small write. With Nagle on, every write after the
|
||||
// first waits for the client's delayed ACK (hundreds of ms), so turn Nagle off on each new connection.
|
||||
static esp_err_t open_nodelay(httpd_handle_t hd, int sockfd)
|
||||
{
|
||||
(void)hd;
|
||||
int one = 1;
|
||||
setsockopt(sockfd, IPPROTO_TCP, TCP_NODELAY, &one, sizeof(one));
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
// The JSON API. Each route answers an HTTP request and a WebSocket message alike.
|
||||
typedef struct {
|
||||
const char *path;
|
||||
httpd_method_t method;
|
||||
api_fn_t fn;
|
||||
} api_route_t;
|
||||
|
||||
static const api_route_t s_api[] = {
|
||||
{"/api/status", HTTP_GET, status_get},
|
||||
{"/api/pattern", HTTP_POST, pattern_post},
|
||||
{"/api/wifi", HTTP_GET, wifi_get},
|
||||
{"/api/wifi", HTTP_POST, wifi_post},
|
||||
{"/api/wifi/scan", HTTP_GET, wifi_scan_get},
|
||||
{"/api/network", HTTP_GET, network_get},
|
||||
{"/api/network", HTTP_POST, network_post},
|
||||
{"/api/ddp", HTTP_GET, ddp_get},
|
||||
{"/api/hardware", HTTP_GET, hardware_get},
|
||||
{"/api/hardware", HTTP_POST, hardware_post},
|
||||
{"/api/presets", HTTP_GET, presets_get},
|
||||
{"/api/presets", HTTP_POST, presets_post},
|
||||
{"/api/presets/select", HTTP_POST, select_post},
|
||||
{"/api/presets/delete", HTTP_POST, delete_post},
|
||||
{"/api/presets/startup", HTTP_POST, startup_post},
|
||||
{"/api/presets/defaults", HTTP_POST, presets_defaults_post},
|
||||
{"/api/presets/order", HTTP_POST, presets_order_post},
|
||||
{"/api/brightness", HTTP_POST, brightness_post},
|
||||
{"/api/devices", HTTP_GET, devices_get},
|
||||
{"/api/relay", HTTP_POST, relay_post},
|
||||
};
|
||||
|
||||
// An HTTP request for a route: the route's function is kept in the URI's user_ctx.
|
||||
static esp_err_t api_http_entry(httpd_req_t *req)
|
||||
{
|
||||
api_req_t a = {};
|
||||
a.http = req;
|
||||
return reinterpret_cast<api_fn_t>(req->user_ctx)(&a);
|
||||
}
|
||||
|
||||
#define WS_MSG_MAX 2048 // a request message
|
||||
#define WS_REPLY_MAX 8192 // a reply envelope
|
||||
|
||||
// Run an API route on this driver: target is the path, optionally with a query string.
|
||||
static void ws_local(const char *method, const char *target, const char *body, char *out, size_t cap)
|
||||
{
|
||||
char path[64];
|
||||
const char *q = strchr(target, '?');
|
||||
size_t n = q ? (size_t)(q - target) : strlen(target);
|
||||
if (n >= sizeof(path)) {
|
||||
envelope(out, cap, 404, "{\"error\":\"no such API path\"}");
|
||||
return;
|
||||
}
|
||||
memcpy(path, target, n);
|
||||
path[n] = '\0';
|
||||
for (size_t i = 0; i < sizeof(s_api) / sizeof(s_api[0]); i++) {
|
||||
const bool is_get = s_api[i].method == HTTP_GET;
|
||||
if (strcmp(s_api[i].path, path) == 0 && strcmp(method, is_get ? "GET" : "POST") == 0) {
|
||||
char *reply = (char *)malloc(WS_REPLY_MAX);
|
||||
if (!reply) {
|
||||
envelope(out, cap, 503, "{\"error\":\"out of memory\"}");
|
||||
return;
|
||||
}
|
||||
reply[0] = '\0';
|
||||
api_req_t a = {};
|
||||
a.body = body;
|
||||
a.query = q ? q + 1 : "";
|
||||
a.out = reply;
|
||||
a.out_cap = WS_REPLY_MAX;
|
||||
a.status = 200;
|
||||
s_api[i].fn(&a);
|
||||
if (reply[0] == '\0') {
|
||||
snprintf(reply, WS_REPLY_MAX, "{}");
|
||||
}
|
||||
envelope(out, cap, a.status, reply);
|
||||
free(reply);
|
||||
return;
|
||||
}
|
||||
}
|
||||
envelope(out, cap, 404, "{\"error\":\"no such API path\"}");
|
||||
}
|
||||
|
||||
// A WebSocket request: {"method": "GET" or "POST", "path": "/api/...", "body": "<JSON text>"}, plus
|
||||
// "host" to have this driver relay it to that driver. The reply is the envelope {"status": n, "body": "..."}.
|
||||
static void ws_dispatch(const char *msg, char *out, size_t cap)
|
||||
{
|
||||
cJSON *top = cJSON_Parse(msg);
|
||||
const cJSON *jm = top ? cJSON_GetObjectItem(top, "method") : NULL;
|
||||
const cJSON *jp = top ? cJSON_GetObjectItem(top, "path") : NULL;
|
||||
const cJSON *jb = top ? cJSON_GetObjectItem(top, "body") : NULL;
|
||||
const cJSON *jh = top ? cJSON_GetObjectItem(top, "host") : NULL;
|
||||
if (!cJSON_IsString(jp)) {
|
||||
envelope(out, cap, 400, "{\"error\":\"need a path\"}");
|
||||
cJSON_Delete(top);
|
||||
return;
|
||||
}
|
||||
const char *method = cJSON_IsString(jm) ? jm->valuestring : "GET";
|
||||
char *owned = NULL; // body printed from a JSON object (a string is used as it is)
|
||||
const char *body = "";
|
||||
if (cJSON_IsString(jb)) {
|
||||
body = jb->valuestring;
|
||||
} else if (jb) {
|
||||
owned = cJSON_PrintUnformatted(jb);
|
||||
body = owned ? owned : "";
|
||||
}
|
||||
if (cJSON_IsString(jh) && jh->valuestring[0] != '\0') {
|
||||
relay_forward(jh->valuestring, method, jp->valuestring, body, out, cap);
|
||||
} else {
|
||||
ws_local(method, jp->valuestring, body, out, cap);
|
||||
}
|
||||
cJSON_free(owned);
|
||||
cJSON_Delete(top);
|
||||
}
|
||||
|
||||
// WebSocket handler: one text frame in, one text frame out
|
||||
// Another site's page must not drive this driver. A browser sends its Origin with the WebSocket
|
||||
// handshake, and only a page from the LAN (or this device) may open the socket. ESP-IDF has no hook
|
||||
// before the handshake reply, so the check runs right after it: a refused socket is closed before any
|
||||
// frame is read, so its messages are never dispatched.
|
||||
static esp_err_t ws_origin_check(httpd_req_t *req)
|
||||
{
|
||||
size_t origin_len = httpd_req_get_hdr_value_len(req, "Origin");
|
||||
if (origin_len == 0) {
|
||||
return ESP_OK; // not a browser (no Origin): the device's own client, or a tool
|
||||
}
|
||||
char origin[128];
|
||||
if (origin_len >= sizeof(origin) || httpd_req_get_hdr_value_str(req, "Origin", origin, sizeof(origin)) != ESP_OK
|
||||
|| !origin_is_lan(origin)) {
|
||||
return ESP_FAIL;
|
||||
}
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
static esp_err_t ws_handler(httpd_req_t *req)
|
||||
{
|
||||
if (req->method == HTTP_GET) {
|
||||
return ws_origin_check(req); // the handshake is done
|
||||
}
|
||||
httpd_ws_frame_t frame = {};
|
||||
frame.type = HTTPD_WS_TYPE_TEXT;
|
||||
esp_err_t err = httpd_ws_recv_frame(req, &frame, 0);
|
||||
if (err != ESP_OK) {
|
||||
return err;
|
||||
}
|
||||
if (frame.len == 0 || frame.len > WS_MSG_MAX) {
|
||||
return ESP_FAIL;
|
||||
}
|
||||
uint8_t *buf = (uint8_t *)malloc(frame.len + 1);
|
||||
char *reply = (char *)malloc(WS_REPLY_MAX);
|
||||
if (!buf || !reply) {
|
||||
free(buf);
|
||||
free(reply);
|
||||
return ESP_ERR_NO_MEM;
|
||||
}
|
||||
frame.payload = buf;
|
||||
err = httpd_ws_recv_frame(req, &frame, frame.len);
|
||||
if (err == ESP_OK) {
|
||||
buf[frame.len] = '\0';
|
||||
ws_dispatch((const char *)buf, reply, WS_REPLY_MAX);
|
||||
httpd_ws_frame_t out = {};
|
||||
out.type = HTTPD_WS_TYPE_TEXT;
|
||||
out.payload = (uint8_t *)reply;
|
||||
out.len = strlen(reply);
|
||||
err = httpd_ws_send_frame(req, &out);
|
||||
}
|
||||
free(buf);
|
||||
free(reply);
|
||||
return err;
|
||||
}
|
||||
|
||||
esp_err_t web_start(void)
|
||||
{
|
||||
httpd_config_t cfg = HTTPD_DEFAULT_CONFIG();
|
||||
@@ -881,6 +1298,7 @@ esp_err_t web_start(void)
|
||||
cfg.lru_purge_enable = true;
|
||||
cfg.max_open_sockets = 7;
|
||||
cfg.backlog_conn = 10;
|
||||
cfg.open_fn = open_nodelay;
|
||||
esp_err_t err = httpd_start(&s_server, &cfg);
|
||||
if (err != ESP_OK) {
|
||||
ESP_LOGE(TAG, "HTTP server start failed: %s", esp_err_to_name(err));
|
||||
@@ -889,26 +1307,18 @@ esp_err_t web_start(void)
|
||||
add_uri(s_server, "/", HTTP_GET, index_get);
|
||||
add_uri(s_server, "/app.js", HTTP_GET, app_js_get);
|
||||
add_uri(s_server, "/style.css", HTTP_GET, style_css_get);
|
||||
add_uri(s_server, "/api/status", HTTP_GET, status_get);
|
||||
add_uri(s_server, "/api/pattern", HTTP_POST, pattern_post);
|
||||
add_uri(s_server, "/api/wifi", HTTP_GET, wifi_get);
|
||||
add_uri(s_server, "/api/wifi", HTTP_POST, wifi_post);
|
||||
add_uri(s_server, "/api/wifi/scan", HTTP_GET, wifi_scan_get);
|
||||
add_uri(s_server, "/api/network", HTTP_GET, network_get);
|
||||
add_uri(s_server, "/api/network", HTTP_POST, network_post);
|
||||
add_uri(s_server, "/api/ddp", HTTP_GET, ddp_get);
|
||||
add_uri(s_server, "/api/hardware", HTTP_GET, hardware_get);
|
||||
add_uri(s_server, "/api/hardware", HTTP_POST, hardware_post);
|
||||
add_uri(s_server, "/api/presets", HTTP_GET, presets_get);
|
||||
add_uri(s_server, "/api/presets", HTTP_POST, presets_post);
|
||||
add_uri(s_server, "/api/presets/select", HTTP_POST, select_post);
|
||||
add_uri(s_server, "/api/presets/delete", HTTP_POST, delete_post);
|
||||
add_uri(s_server, "/api/presets/startup", HTTP_POST, startup_post);
|
||||
add_uri(s_server, "/api/presets/defaults", HTTP_POST, presets_defaults_post);
|
||||
add_uri(s_server, "/api/presets/order", HTTP_POST, presets_order_post);
|
||||
add_uri(s_server, "/api/brightness", HTTP_POST, brightness_post);
|
||||
add_uri(s_server, "/api/relay", HTTP_POST, relay_post);
|
||||
add_uri(s_server, "/api/devices", HTTP_GET, devices_get);
|
||||
for (size_t i = 0; i < sizeof(s_api) / sizeof(s_api[0]); i++) {
|
||||
httpd_uri_t u = {};
|
||||
u.uri = s_api[i].path;
|
||||
u.method = s_api[i].method;
|
||||
u.handler = api_http_entry;
|
||||
u.user_ctx = reinterpret_cast<void *>(s_api[i].fn);
|
||||
httpd_register_uri_handler(s_server, &u);
|
||||
}
|
||||
static const httpd_uri_t ws_uri = { .uri = "/ws", .method = HTTP_GET, .handler = ws_handler,
|
||||
.user_ctx = NULL, .is_websocket = true, .handle_ws_control_frames = false,
|
||||
.supported_subprotocol = NULL };
|
||||
httpd_register_uri_handler(s_server, &ws_uri);
|
||||
ota_register(s_server);
|
||||
ESP_LOGI(TAG, "Web UI on port 80");
|
||||
return ESP_OK;
|
||||
|
||||
Reference in new issue
Block a user