Add LED web UI with AP, Wi-Fi client, mDNS and patterns

Brings the led_strip example into the cpp app, targeting the ESP32-C3:
- Access point led-XXXXXX (open) plus a Wi-Fi client configured from the
  web Settings tab, with credentials stored in NVS and reconnect backoff
- mDNS as led.local with an HTTP service on port 80
- HTTP server with an embedded web UI and a JSON API for patterns and Wi-Fi
- Pattern runner for solid, rainbow, chase, breathe, blink, pulse,
  transition and circle on a 119-LED WS2812 strip (GPIO 10)

Co-Authored-By: Claude Haiku 5.5 <noreply@anthropic.com>
This commit is contained in:
jimmyandClaude Haiku 5.5 committed 2026-11-11 00:02:49 +13:00
1 parent df43820acd
commit 89f996096c
20 files changed
+1539 -18

No files matched your search

+5 -2
View File
@@ -1,2 +1,5 @@
idf_component_register(SRCS "main.cpp"
INCLUDE_DIRS ".")
idf_component_register(SRCS "main.cpp" "ws2812.cpp" "net.cpp" "settings.cpp" "web.cpp" "patterns.cpp"
PRIV_REQUIRES esp_driver_rmt esp_driver_gpio esp_wifi esp_netif esp_event
esp_timer nvs_flash esp_http_server cjson mdns esp_hw_support
INCLUDE_DIRS "."
EMBED_TXTFILES "../web/index.html" "../web/app.js" "../web/style.css")
+5
View File
@@ -0,0 +1,5 @@
dependencies:
espressif/mdns:
version: "^1.4.0"
espressif/cjson:
version: "^1.7.19"
+23 -11
View File
@@ -1,18 +1,30 @@
#include <cstdio>
/*
* SPDX-License-Identifier: Apache-2.0
*/
#include "esp_log.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "nvs_flash.h"
static const char *TAG = "led_driver";
#include "net.h"
#include "patterns.h"
#include "web.h"
static const char *TAG = "example";
extern "C" void app_main(void)
{
ESP_LOGI(TAG, "LED driver (C++) starting");
int tick = 0;
while (true) {
ESP_LOGI(TAG, "alive: %d", tick++);
vTaskDelay(pdMS_TO_TICKS(1000));
// NVS holds the saved Wi-Fi client credentials
esp_err_t err = nvs_flash_init();
if (err == ESP_ERR_NVS_NO_FREE_PAGES || err == ESP_ERR_NVS_NEW_VERSION_FOUND) {
ESP_ERROR_CHECK(nvs_flash_erase());
err = nvs_flash_init();
}
ESP_ERROR_CHECK(err);
patterns_start();
ESP_ERROR_CHECK(net_start());
ESP_ERROR_CHECK(web_start());
char ssid[16];
net_ap_ssid(ssid, sizeof(ssid));
ESP_LOGI(TAG, "Ready: join Wi-Fi %s and open http://192.168.4.1/, or http://led.local/ on your network", ssid);
}
+180
View File
@@ -0,0 +1,180 @@
/*
* SPDX-License-Identifier: Apache-2.0
*/
#include <cstdio>
#include <cstring>
#include "esp_event.h"
#include "esp_log.h"
#include "esp_mac.h"
#include "esp_netif.h"
#include "esp_timer.h"
#include "esp_wifi.h"
#include "mdns.h"
#include "net.h"
static const char *TAG = "net";
#define AP_CHANNEL 1
#define AP_MAX_CLIENTS 4
#define MDNS_HOSTNAME "led"
#define RETRY_MAX_MS 30000
static esp_netif_t *s_ap_netif;
static esp_netif_t *s_sta_netif;
static esp_timer_handle_t s_retry_timer;
static volatile bool s_sta_up;
static esp_ip4_addr_t s_sta_ip;
static int s_retries;
// Set the STA config from credentials. Empty password means an open network.
static void apply_sta_config(const wifi_creds_t *c)
{
wifi_config_t cfg = {};
strncpy((char *)cfg.sta.ssid, c->ssid, sizeof(cfg.sta.ssid) - 1);
strncpy((char *)cfg.sta.password, c->pass, sizeof(cfg.sta.password) - 1);
cfg.sta.threshold.authmode = c->pass[0] ? WIFI_AUTH_WPA2_PSK : WIFI_AUTH_OPEN;
esp_wifi_set_config(WIFI_IF_STA, &cfg);
}
static void retry_cb(void *arg)
{
(void)arg;
esp_wifi_connect();
}
static void on_wifi_event(void *arg, esp_event_base_t base, int32_t id, void *data)
{
(void)arg;
(void)base;
(void)data;
switch (id) {
case WIFI_EVENT_STA_START: {
wifi_creds_t c;
if (settings_load_wifi(&c) == ESP_OK && c.ssid[0]) {
esp_wifi_connect();
}
break;
}
case WIFI_EVENT_STA_DISCONNECTED: {
// Back off 1 s, 2 s, 4 s ... up to RETRY_MAX_MS
s_sta_up = false;
uint32_t delay_ms = 1000u << (s_retries < 5 ? s_retries : 5);
if (delay_ms > RETRY_MAX_MS) delay_ms = RETRY_MAX_MS;
s_retries++;
esp_timer_stop(s_retry_timer);
esp_timer_start_once(s_retry_timer, (uint64_t)delay_ms * 1000);
break;
}
default:
break;
}
}
static void on_ip_event(void *arg, esp_event_base_t base, int32_t id, void *data)
{
(void)arg;
(void)base;
(void)id;
ip_event_got_ip_t *e = (ip_event_got_ip_t *)data;
s_sta_ip = e->ip_info.ip;
s_sta_up = true;
s_retries = 0;
ESP_LOGI(TAG, "Client IP " IPSTR, IP2STR(&e->ip_info.ip));
}
void net_ap_ssid(char *buf, size_t len)
{
uint8_t mac[6];
esp_read_mac(mac, ESP_MAC_WIFI_SOFTAP);
snprintf(buf, len, "led-%02X%02X%02X", mac[3], mac[4], mac[5]);
}
esp_err_t net_start(void)
{
ESP_ERROR_CHECK(esp_netif_init());
ESP_ERROR_CHECK(esp_event_loop_create_default());
s_ap_netif = esp_netif_create_default_wifi_ap();
s_sta_netif = esp_netif_create_default_wifi_sta();
wifi_init_config_t init_cfg = WIFI_INIT_CONFIG_DEFAULT();
ESP_ERROR_CHECK(esp_wifi_init(&init_cfg));
ESP_ERROR_CHECK(esp_event_handler_instance_register(WIFI_EVENT, ESP_EVENT_ANY_ID, on_wifi_event, NULL, NULL));
ESP_ERROR_CHECK(esp_event_handler_instance_register(IP_EVENT, IP_EVENT_STA_GOT_IP, on_ip_event, NULL, NULL));
const esp_timer_create_args_t timer_args = {
.callback = retry_cb,
.arg = NULL,
.dispatch_method = ESP_TIMER_TASK,
.name = "wifi_retry",
.skip_unhandled_events = false,
};
ESP_ERROR_CHECK(esp_timer_create(&timer_args, &s_retry_timer));
ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_APSTA));
// Open access point named led-XXXXXX
char ssid[16];
net_ap_ssid(ssid, sizeof(ssid));
wifi_config_t ap = {};
strncpy((char *)ap.ap.ssid, ssid, sizeof(ap.ap.ssid) - 1);
ap.ap.ssid_len = strlen(ssid);
ap.ap.channel = AP_CHANNEL;
ap.ap.max_connection = AP_MAX_CLIENTS;
ap.ap.authmode = WIFI_AUTH_OPEN;
ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_AP, &ap));
// Client credentials, if any were saved
wifi_creds_t c;
if (settings_load_wifi(&c) == ESP_OK && c.ssid[0]) {
apply_sta_config(&c);
}
ESP_ERROR_CHECK(esp_wifi_start());
ESP_LOGI(TAG, "AP %s started", ssid);
// mDNS: led.local, with an HTTP service on port 80
ESP_ERROR_CHECK(mdns_init());
ESP_ERROR_CHECK(mdns_hostname_set(MDNS_HOSTNAME));
ESP_ERROR_CHECK(mdns_instance_name_set("LED controller"));
ESP_ERROR_CHECK(mdns_service_add(NULL, "_http", "_tcp", 80, NULL, 0));
ESP_LOGI(TAG, "mDNS: %s.local", MDNS_HOSTNAME);
return ESP_OK;
}
bool net_sta_status(char *ip, size_t ip_len)
{
if (ip_len) {
ip[0] = '\0';
}
if (!s_sta_up) {
return false;
}
snprintf(ip, ip_len, IPSTR, IP2STR(&s_sta_ip));
return true;
}
esp_err_t net_sta_connect(const wifi_creds_t *c)
{
esp_err_t err = settings_save_wifi(c);
if (err != ESP_OK) {
return err;
}
esp_timer_stop(s_retry_timer);
esp_wifi_disconnect();
s_retries = 0;
apply_sta_config(c);
return esp_wifi_connect();
}
esp_err_t net_scan(wifi_ap_record_t *recs, uint16_t *count)
{
esp_err_t err = esp_wifi_scan_start(NULL, true);
if (err != ESP_OK) {
return err;
}
uint16_t max = *count;
err = esp_wifi_scan_get_ap_records(&max, recs);
*count = max;
return err;
}
+26
View File
@@ -0,0 +1,26 @@
/*
* SPDX-License-Identifier: Apache-2.0
*/
#pragma once
#include <cstddef>
#include <cstdint>
#include "esp_err.h"
#include "esp_wifi_types.h"
#include "settings.h"
/** @brief Start Wi-Fi (AP `led-XXXXXX` plus an optional client), and mDNS as led.local. Needs NVS. */
esp_err_t net_start(void);
/** @brief Fill buf with the AP SSID, e.g. "led-A1B2C3". */
void net_ap_ssid(char *buf, size_t len);
/** @brief Client link state and its IPv4 address ("" if not connected). */
bool net_sta_status(char *ip, size_t ip_len);
/** @brief Save credentials, then connect the client with them. */
esp_err_t net_sta_connect(const wifi_creds_t *c);
/** @brief Scan for networks. On entry *count is the array size; on exit, the number found. */
esp_err_t net_scan(wifi_ap_record_t *recs, uint16_t *count);
+188
View File
@@ -0,0 +1,188 @@
/*
* SPDX-License-Identifier: Apache-2.0
*/
#include <cstring>
#include "esp_log.h"
#include "esp_timer.h"
#include "driver/gpio.h"
#include "freertos/FreeRTOS.h"
#include "freertos/semphr.h"
#include "freertos/task.h"
#include "patterns.h"
#include "ws2812.h"
#define RMT_LED_STRIP_GPIO_NUM GPIO_NUM_10
#define EXAMPLE_LED_NUMBERS 119
#define FRAME_MS 20
static const char *TAG = "patterns";
static const char *const s_names[PM_COUNT] = {
"solid", "rainbow", "chase", "breathe", "blink", "pulse", "transition", "circle",
};
static WS2812 *s_strip;
static SemaphoreHandle_t s_lock;
static pattern_params_t s_p = { PM_CHASE, { 255, 0, 0 }, { 0, 0, 0 }, 1000, 16 };
const char *patterns_mode_name(pattern_mode_t m)
{
return (m >= 0 && m < PM_COUNT) ? s_names[m] : "";
}
pattern_mode_t patterns_mode_from_name(const char *name)
{
for (int i = 0; i < PM_COUNT; i++) {
if (strcmp(name, s_names[i]) == 0) {
return (pattern_mode_t)i;
}
}
return PM_COUNT;
}
void patterns_set(const pattern_params_t &p)
{
pattern_params_t q = p;
if (q.speed_ms < 10) q.speed_ms = 10;
if (q.speed_ms > 10000) q.speed_ms = 10000;
if (q.mode >= PM_COUNT) q.mode = PM_SOLID;
xSemaphoreTake(s_lock, portMAX_DELAY);
s_p = q;
xSemaphoreGive(s_lock);
}
pattern_params_t patterns_get(void)
{
xSemaphoreTake(s_lock, portMAX_DELAY);
pattern_params_t p = s_p;
xSemaphoreGive(s_lock);
return p;
}
// Linear blend from a (k=0) to b (k=255)
static void lerp(const uint8_t *a, const uint8_t *b, uint32_t k, uint8_t *out)
{
for (int i = 0; i < 3; i++) {
out[i] = (uint8_t)(a[i] + ((int)b[i] - a[i]) * (int)k / 255);
}
}
// Draw one frame of the pattern at time t (ms since the start of the pattern)
static void render(const pattern_params_t &p, uint32_t t, WS2812 &s)
{
const size_t n = s.size();
const uint32_t sp = p.speed_ms;
uint8_t col[3];
switch (p.mode) {
case PM_SOLID:
s.fill(p.c1[0], p.c1[1], p.c1[2]);
break;
case PM_RAINBOW: {
uint32_t off = (t / sp) % 360;
for (size_t i = 0; i < n; i++) {
uint32_t r, g, b;
WS2812::hsv2rgb((i * 360 / n + off) % 360, 100, 100, &r, &g, &b);
s.set(i, r, g, b);
}
break;
}
case PM_CHASE: {
// Every third LED lit, moving one step per speed_ms; hue shifts each full cycle
uint32_t step = t / sp;
uint32_t phase = step % 3;
uint32_t off = ((step / 3) * 60) % 360;
s.fill(0, 0, 0);
for (size_t j = phase; j < n; j += 3) {
uint32_t r, g, b;
WS2812::hsv2rgb((j * 360 / n + off) % 360, 100, 100, &r, &g, &b);
s.set(j, r, g, b);
}
break;
}
case PM_BREATHE: {
uint32_t period = sp * 2 < 500 ? 500 : sp * 2;
uint32_t ph = t % period;
uint32_t k = ph * 2 < period ? (ph * 2 * 255) / period : ((period - ph) * 2 * 255) / period;
lerp(p.c2, p.c1, k, col);
s.fill(col[0], col[1], col[2]);
break;
}
case PM_BLINK:
if ((t / sp) % 2 == 0) {
s.fill(p.c1[0], p.c1[1], p.c1[2]);
} else {
s.fill(p.c2[0], p.c2[1], p.c2[2]);
}
break;
case PM_PULSE: {
// Attack over the first 10% of the period, then a linear decay back to c2
uint32_t period = sp * 2 < 200 ? 200 : sp * 2;
uint32_t frac = ((t % period) * 1000) / period;
uint32_t k = frac < 100 ? frac * 255 / 100 : (1000 - frac) * 255 / 900;
lerp(p.c2, p.c1, k, col);
s.fill(col[0], col[1], col[2]);
break;
}
case PM_TRANSITION: {
// c1 -> c2 over speed_ms, then back again
uint32_t period = 2 * sp;
uint32_t ph = t % period;
uint32_t k = ph < sp ? ph * 255 / sp : (period - ph) * 255 / sp;
lerp(p.c1, p.c2, k, col);
s.fill(col[0], col[1], col[2]);
break;
}
case PM_CIRCLE: {
// A segment a third of the strip long, moving around the ring
size_t head = (t / sp) % n;
size_t len = n / 3 < 1 ? 1 : n / 3;
for (size_t i = 0; i < n; i++) {
size_t dist = (head + n - i) % n;
if (dist < len) {
s.set(i, p.c1[0], p.c1[1], p.c1[2]);
} else {
s.set(i, p.c2[0], p.c2[1], p.c2[2]);
}
}
break;
}
default:
break;
}
}
static void patterns_task(void *arg)
{
(void)arg;
const uint32_t t0 = (uint32_t)(esp_timer_get_time() / 1000);
while (true) {
pattern_params_t p = patterns_get();
uint32_t now = (uint32_t)(esp_timer_get_time() / 1000);
s_strip->setBrightness(p.brightness);
render(p, now - t0, *s_strip);
esp_err_t err = s_strip->write();
if (err != ESP_OK) {
ESP_LOGW(TAG, "LED write failed: %s", esp_err_to_name(err));
}
vTaskDelay(pdMS_TO_TICKS(FRAME_MS));
}
}
void patterns_start(void)
{
s_lock = xSemaphoreCreateMutex();
s_strip = new WS2812(RMT_LED_STRIP_GPIO_NUM, EXAMPLE_LED_NUMBERS);
xTaskCreate(patterns_task, "patterns", 4096, NULL, 5, NULL);
ESP_LOGI(TAG, "Started %d LEDs on GPIO %d", EXAMPLE_LED_NUMBERS, (int)RMT_LED_STRIP_GPIO_NUM);
}
+42
View File
@@ -0,0 +1,42 @@
/*
* SPDX-License-Identifier: Apache-2.0
*/
#pragma once
#include <cstdint>
// Pattern names (also the strings the web UI uses). Order matters: the index is the mode id.
enum pattern_mode_t {
PM_SOLID,
PM_RAINBOW,
PM_CHASE,
PM_BREATHE,
PM_BLINK,
PM_PULSE,
PM_TRANSITION,
PM_CIRCLE,
PM_COUNT,
};
struct pattern_params_t {
pattern_mode_t mode;
uint8_t c1[3]; // main colour (ignored by rainbow and chase)
uint8_t c2[3]; // background / second colour
uint32_t speed_ms; // one step of the pattern, 10-10000 ms
uint8_t brightness; // 0-255
};
/** @brief Start the LED strip and the pattern task. */
void patterns_start(void);
/** @brief Replace the running pattern. Values are clamped to valid ranges. */
void patterns_set(const pattern_params_t &p);
/** @brief Copy of the running pattern. */
pattern_params_t patterns_get(void);
/** @brief Name of a mode, e.g. "rainbow". */
const char *patterns_mode_name(pattern_mode_t m);
/** @brief Mode for a name, or PM_COUNT if unknown. */
pattern_mode_t patterns_mode_from_name(const char *name);
+42
View File
@@ -0,0 +1,42 @@
/*
* SPDX-License-Identifier: Apache-2.0
*/
#include "nvs.h"
#include "settings.h"
static const char *NS = "led";
esp_err_t settings_load_wifi(wifi_creds_t *c)
{
nvs_handle_t h;
esp_err_t err = nvs_open(NS, NVS_READONLY, &h);
if (err != ESP_OK) {
return err;
}
size_t len = sizeof(c->ssid);
err = nvs_get_str(h, "sta_ssid", c->ssid, &len);
if (err == ESP_OK) {
len = sizeof(c->pass);
err = nvs_get_str(h, "sta_pass", c->pass, &len);
if (err == ESP_ERR_NVS_NOT_FOUND) {
c->pass[0] = '\0';
err = ESP_OK;
}
}
nvs_close(h);
return err;
}
esp_err_t settings_save_wifi(const wifi_creds_t *c)
{
nvs_handle_t h;
esp_err_t err = nvs_open(NS, NVS_READWRITE, &h);
if (err != ESP_OK) {
return err;
}
err = nvs_set_str(h, "sta_ssid", c->ssid);
if (err == ESP_OK) err = nvs_set_str(h, "sta_pass", c->pass);
if (err == ESP_OK) err = nvs_commit(h);
nvs_close(h);
return err;
}
+17
View File
@@ -0,0 +1,17 @@
/*
* SPDX-License-Identifier: Apache-2.0
*/
#pragma once
#include "esp_err.h"
struct wifi_creds_t {
char ssid[33];
char pass[65];
};
/** @brief Read saved Wi-Fi client credentials. ESP_ERR_NVS_NOT_FOUND if none are saved. */
esp_err_t settings_load_wifi(wifi_creds_t *c);
/** @brief Save Wi-Fi client credentials to NVS. */
esp_err_t settings_save_wifi(const wifi_creds_t *c);
+276
View File
@@ -0,0 +1,276 @@
/*
* SPDX-License-Identifier: Apache-2.0
*/
#include <cstring>
#include "cJSON.h"
#include "esp_http_server.h"
#include "esp_log.h"
#include "esp_wifi.h"
#include "net.h"
#include "patterns.h"
#include "settings.h"
#include "web.h"
static const char *TAG = "web";
// Files embedded from web/ (see main/CMakeLists.txt EMBED_TXTFILES)
extern const char index_html_start[] asm("_binary_index_html_start");
extern const char index_html_end[] asm("_binary_index_html_end");
extern const char app_js_start[] asm("_binary_app_js_start");
extern const char app_js_end[] asm("_binary_app_js_end");
extern const char style_css_start[] asm("_binary_style_css_start");
extern const char style_css_end[] asm("_binary_style_css_end");
static httpd_handle_t s_server;
#define MAX_BODY 512
#define MAX_SCAN 20
static esp_err_t send_embedded(httpd_req_t *req, const char *type, const char *start, const char *end)
{
httpd_resp_set_type(req, type);
httpd_resp_set_hdr(req, "Cache-Control", "no-cache");
return httpd_resp_send(req, start, end - start);
}
static esp_err_t send_json(httpd_req_t *req, cJSON *obj)
{
char *s = cJSON_PrintUnformatted(obj);
cJSON_Delete(obj);
if (!s) {
return httpd_resp_send_500(req);
}
httpd_resp_set_type(req, "application/json");
esp_err_t err = httpd_resp_sendstr(req, s);
cJSON_free(s);
return err;
}
static esp_err_t send_error(httpd_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);
}
// 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)
{
int len = req->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);
if (r <= 0) {
return false;
}
got += r;
}
buf[got] = '\0';
return true;
}
static void read_rgb(const cJSON *arr, uint8_t *out)
{
if (!cJSON_IsArray(arr) || cJSON_GetArraySize(arr) != 3) {
return;
}
for (int i = 0; i < 3; i++) {
cJSON *v = cJSON_GetArrayItem(arr, i);
if (cJSON_IsNumber(v)) {
int x = v->valueint;
out[i] = (uint8_t)(x < 0 ? 0 : x > 255 ? 255 : x);
}
}
}
static void put_rgb(cJSON *obj, const char *key, const uint8_t *c)
{
cJSON *a = cJSON_AddArrayToObject(obj, key);
for (int i = 0; i < 3; i++) {
cJSON_AddItemToArray(a, cJSON_CreateNumber(c[i]));
}
}
// GET / , /app.js , /style.css
static esp_err_t index_get(httpd_req_t *req)
{
return send_embedded(req, "text/html", index_html_start, index_html_end);
}
static esp_err_t app_js_get(httpd_req_t *req)
{
return send_embedded(req, "application/javascript", app_js_start, app_js_end);
}
static esp_err_t style_css_get(httpd_req_t *req)
{
return send_embedded(req, "text/css", style_css_start, style_css_end);
}
// GET /api/status
static esp_err_t status_get(httpd_req_t *req)
{
pattern_params_t p = patterns_get();
char ap[16], ip[16];
net_ap_ssid(ap, sizeof(ap));
bool up = net_sta_status(ip, sizeof(ip));
cJSON *o = cJSON_CreateObject();
cJSON_AddStringToObject(o, "ap_ssid", ap);
cJSON_AddBoolToObject(o, "sta_connected", up);
cJSON_AddStringToObject(o, "sta_ip", ip);
cJSON_AddStringToObject(o, "mode", patterns_mode_name(p.mode));
cJSON *modes = cJSON_AddArrayToObject(o, "modes");
for (int i = 0; i < PM_COUNT; i++) {
cJSON_AddItemToArray(modes, cJSON_CreateString(patterns_mode_name((pattern_mode_t)i)));
}
put_rgb(o, "c1", p.c1);
put_rgb(o, "c2", p.c2);
cJSON_AddNumberToObject(o, "speed_ms", p.speed_ms);
cJSON_AddNumberToObject(o, "brightness", p.brightness);
return send_json(req, o);
}
// POST /api/pattern {"mode","c1":[r,g,b],"c2":[r,g,b],"speed_ms","brightness"}
static esp_err_t pattern_post(httpd_req_t *req)
{
char body[MAX_BODY];
if (!read_body(req, body, sizeof(body))) {
return send_error(req, "400 Bad Request", "empty or too large body");
}
cJSON *in = cJSON_Parse(body);
if (!in) {
return send_error(req, "400 Bad Request", "invalid JSON");
}
pattern_params_t p = patterns_get();
cJSON *mode = cJSON_GetObjectItem(in, "mode");
if (cJSON_IsString(mode)) {
pattern_mode_t m = patterns_mode_from_name(mode->valuestring);
if (m == PM_COUNT) {
cJSON_Delete(in);
return send_error(req, "400 Bad Request", "unknown mode");
}
p.mode = m;
}
read_rgb(cJSON_GetObjectItem(in, "c1"), p.c1);
read_rgb(cJSON_GetObjectItem(in, "c2"), p.c2);
cJSON *speed = cJSON_GetObjectItem(in, "speed_ms");
if (cJSON_IsNumber(speed)) p.speed_ms = (uint32_t)speed->valueint;
cJSON *bright = cJSON_GetObjectItem(in, "brightness");
if (cJSON_IsNumber(bright)) {
int b = bright->valueint;
p.brightness = (uint8_t)(b < 0 ? 0 : b > 255 ? 255 : b);
}
cJSON_Delete(in);
patterns_set(p);
return send_json(req, cJSON_CreateObject());
}
// GET /api/wifi : saved client SSID and connection state
static esp_err_t wifi_get(httpd_req_t *req)
{
wifi_creds_t c = {};
settings_load_wifi(&c);
char ip[16];
bool up = net_sta_status(ip, sizeof(ip));
cJSON *o = cJSON_CreateObject();
cJSON_AddStringToObject(o, "ssid", c.ssid);
cJSON_AddBoolToObject(o, "connected", up);
cJSON_AddStringToObject(o, "ip", ip);
return send_json(req, o);
}
// POST /api/wifi {"ssid","password"} : save and connect
static esp_err_t wifi_post(httpd_req_t *req)
{
char body[MAX_BODY];
if (!read_body(req, body, sizeof(body))) {
return send_error(req, "400 Bad Request", "empty or too large body");
}
cJSON *in = cJSON_Parse(body);
if (!in) {
return send_error(req, "400 Bad Request", "invalid JSON");
}
cJSON *ssid = cJSON_GetObjectItem(in, "ssid");
cJSON *pass = cJSON_GetObjectItem(in, "password");
const char *pw = cJSON_IsString(pass) ? pass->valuestring : "";
if (!cJSON_IsString(ssid) || !ssid->valuestring[0] || strlen(ssid->valuestring) > 32) {
cJSON_Delete(in);
return send_error(req, "400 Bad Request", "SSID must be 1-32 characters");
}
size_t plen = strlen(pw);
if (plen > 0 && (plen < 8 || plen > 64)) {
cJSON_Delete(in);
return send_error(req, "400 Bad Request", "password must be empty or 8-64 characters");
}
wifi_creds_t c = {};
strncpy(c.ssid, ssid->valuestring, sizeof(c.ssid) - 1);
strncpy(c.pass, pw, sizeof(c.pass) - 1);
cJSON_Delete(in);
esp_err_t err = net_sta_connect(&c);
if (err != ESP_OK) {
ESP_LOGW(TAG, "Connect to %s failed: %s", c.ssid, esp_err_to_name(err));
return send_error(req, "500 Internal Server Error", esp_err_to_name(err));
}
cJSON *o = cJSON_CreateObject();
cJSON_AddStringToObject(o, "message", "saved; connecting");
return send_json(req, o);
}
// GET /api/wifi/scan : visible networks
static esp_err_t wifi_scan_get(httpd_req_t *req)
{
static wifi_ap_record_t recs[MAX_SCAN];
uint16_t count = MAX_SCAN;
esp_err_t err = net_scan(recs, &count);
if (err != ESP_OK) {
return send_error(req, "500 Internal Server Error", esp_err_to_name(err));
}
cJSON *arr = cJSON_CreateArray();
for (int i = 0; i < count; i++) {
cJSON *o = cJSON_CreateObject();
cJSON_AddStringToObject(o, "ssid", (const char *)recs[i].ssid);
cJSON_AddNumberToObject(o, "rssi", recs[i].rssi);
cJSON_AddBoolToObject(o, "open", recs[i].authmode == WIFI_AUTH_OPEN);
cJSON_AddItemToArray(arr, o);
}
cJSON *root = cJSON_CreateObject();
cJSON_AddItemToObject(root, "networks", arr);
return send_json(req, root);
}
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_register_uri_handler(srv, &u);
}
esp_err_t web_start(void)
{
httpd_config_t cfg = HTTPD_DEFAULT_CONFIG();
cfg.max_uri_handlers = 12;
cfg.lru_purge_enable = true;
cfg.max_open_sockets = 7;
cfg.backlog_conn = 10;
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));
return err;
}
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);
ESP_LOGI(TAG, "Web UI on port 80");
return ESP_OK;
}
+9
View File
@@ -0,0 +1,9 @@
/*
* SPDX-License-Identifier: Apache-2.0
*/
#pragma once
#include "esp_err.h"
/** @brief Start the HTTP server on port 80 (UI and JSON API). */
esp_err_t web_start(void);
+237
View File
@@ -0,0 +1,237 @@
/*
* SPDX-License-Identifier: Apache-2.0
*/
#include "ws2812.h"
#include <stdlib.h>
#include "freertos/FreeRTOS.h"
#include "esp_check.h"
#include "esp_log.h"
static const char *TAG = "ws2812";
/* ---- RMT encoder: turns RGB bytes into WS2812 waveform symbols ---- */
typedef struct {
rmt_encoder_t base;
rmt_encoder_t *bytes_encoder;
rmt_encoder_t *copy_encoder;
int state;
rmt_symbol_word_t reset_code;
} rmt_ws2812_encoder_t;
RMT_ENCODER_FUNC_ATTR
static size_t rmt_encode_ws2812(rmt_encoder_t *encoder, rmt_channel_handle_t channel, const void *primary_data, size_t data_size, rmt_encode_state_t *ret_state)
{
rmt_ws2812_encoder_t *led_encoder = __containerof(encoder, rmt_ws2812_encoder_t, base);
rmt_encoder_handle_t bytes_encoder = led_encoder->bytes_encoder;
rmt_encoder_handle_t copy_encoder = led_encoder->copy_encoder;
rmt_encode_state_t session_state = RMT_ENCODING_RESET;
rmt_encode_state_t state = RMT_ENCODING_RESET;
size_t encoded_symbols = 0;
switch (led_encoder->state) {
case 0: // send RGB data
encoded_symbols += bytes_encoder->encode(bytes_encoder, channel, primary_data, data_size, &session_state);
if (session_state & RMT_ENCODING_COMPLETE) {
led_encoder->state = 1; // switch to next state when current encoding session finished
}
if (session_state & RMT_ENCODING_MEM_FULL) {
state = static_cast<rmt_encode_state_t>(state | RMT_ENCODING_MEM_FULL);
goto out; // yield if there's no free space for encoding artifacts
}
// fall-through
case 1: // send reset code
encoded_symbols += copy_encoder->encode(copy_encoder, channel, &led_encoder->reset_code,
sizeof(led_encoder->reset_code), &session_state);
if (session_state & RMT_ENCODING_COMPLETE) {
led_encoder->state = RMT_ENCODING_RESET; // back to the initial encoding session
state = static_cast<rmt_encode_state_t>(state | RMT_ENCODING_COMPLETE);
}
if (session_state & RMT_ENCODING_MEM_FULL) {
state = static_cast<rmt_encode_state_t>(state | RMT_ENCODING_MEM_FULL);
goto out; // yield if there's no free space for encoding artifacts
}
}
out:
*ret_state = state;
return encoded_symbols;
}
static esp_err_t rmt_del_ws2812_encoder(rmt_encoder_t *encoder)
{
rmt_ws2812_encoder_t *led_encoder = __containerof(encoder, rmt_ws2812_encoder_t, base);
rmt_del_encoder(led_encoder->bytes_encoder);
rmt_del_encoder(led_encoder->copy_encoder);
free(led_encoder);
return ESP_OK;
}
RMT_ENCODER_FUNC_ATTR
static esp_err_t rmt_ws2812_encoder_reset(rmt_encoder_t *encoder)
{
rmt_ws2812_encoder_t *led_encoder = __containerof(encoder, rmt_ws2812_encoder_t, base);
rmt_encoder_reset(led_encoder->bytes_encoder);
rmt_encoder_reset(led_encoder->copy_encoder);
led_encoder->state = RMT_ENCODING_RESET;
return ESP_OK;
}
static esp_err_t new_ws2812_encoder(uint32_t resolution, rmt_encoder_handle_t *ret_encoder)
{
// Declared up front: the error path jumps forward to `err`, which C++ forbids
// across initialised declarations.
esp_err_t ret = ESP_OK;
rmt_ws2812_encoder_t *led_encoder = NULL;
rmt_bytes_encoder_config_t bytes_encoder_config = {};
rmt_copy_encoder_config_t copy_encoder_config = {};
uint32_t reset_ticks = 0;
ESP_GOTO_ON_FALSE(ret_encoder, ESP_ERR_INVALID_ARG, err, TAG, "invalid argument");
led_encoder = static_cast<rmt_ws2812_encoder_t *>(rmt_alloc_encoder_mem(sizeof(rmt_ws2812_encoder_t)));
ESP_GOTO_ON_FALSE(led_encoder, ESP_ERR_NO_MEM, err, TAG, "no mem for ws2812 encoder");
led_encoder->base.encode = rmt_encode_ws2812;
led_encoder->base.del = rmt_del_ws2812_encoder;
led_encoder->base.reset = rmt_ws2812_encoder_reset;
// WS2812 timing
bytes_encoder_config.bit0.level0 = 1;
bytes_encoder_config.bit0.duration0 = 0.3 * resolution / 1000000; // T0H=0.3us
bytes_encoder_config.bit0.level1 = 0;
bytes_encoder_config.bit0.duration1 = 0.9 * resolution / 1000000; // T0L=0.9us
bytes_encoder_config.bit1.level0 = 1;
bytes_encoder_config.bit1.duration0 = 0.9 * resolution / 1000000; // T1H=0.9us
bytes_encoder_config.bit1.level1 = 0;
bytes_encoder_config.bit1.duration1 = 0.3 * resolution / 1000000; // T1L=0.3us
bytes_encoder_config.flags.msb_first = 1; // WS2812 transfer bit order: G7...G0R7...R0B7...B0
ESP_GOTO_ON_ERROR(rmt_new_bytes_encoder(&bytes_encoder_config, &led_encoder->bytes_encoder), err, TAG, "create bytes encoder failed");
ESP_GOTO_ON_ERROR(rmt_new_copy_encoder(&copy_encoder_config, &led_encoder->copy_encoder), err, TAG, "create copy encoder failed");
reset_ticks = resolution / 1000000 * 50 / 2; // reset code duration defaults to 50us
led_encoder->reset_code.level0 = 0;
led_encoder->reset_code.duration0 = reset_ticks;
led_encoder->reset_code.level1 = 0;
led_encoder->reset_code.duration1 = reset_ticks;
*ret_encoder = &led_encoder->base;
return ESP_OK;
err:
if (led_encoder) {
if (led_encoder->bytes_encoder) {
rmt_del_encoder(led_encoder->bytes_encoder);
}
if (led_encoder->copy_encoder) {
rmt_del_encoder(led_encoder->copy_encoder);
}
free(led_encoder);
}
return ret;
}
/* ---- WS2812 strip ---- */
WS2812::WS2812(gpio_num_t gpio, size_t num_leds, uint32_t resolution_hz)
: num_leds_(num_leds), pixels_(num_leds * 3, 0), tx_pixels_(num_leds * 3, 0)
{
rmt_tx_channel_config_t tx_chan_config = {};
tx_chan_config.clk_src = RMT_CLK_SRC_DEFAULT;
tx_chan_config.gpio_num = gpio;
tx_chan_config.mem_block_symbols = 64; // larger blocks reduce flicker
tx_chan_config.resolution_hz = resolution_hz;
tx_chan_config.trans_queue_depth = 4;
ESP_ERROR_CHECK(rmt_new_tx_channel(&tx_chan_config, &channel_));
ESP_ERROR_CHECK(new_ws2812_encoder(resolution_hz, &encoder_));
ESP_ERROR_CHECK(rmt_enable(channel_));
tx_config_.loop_count = 0; // send once per write()
ESP_LOGI(TAG, "Strip ready: %zu LEDs on GPIO %d", num_leds_, (int)gpio);
}
WS2812::~WS2812()
{
if (channel_) {
rmt_tx_wait_all_done(channel_, portMAX_DELAY);
rmt_disable(channel_);
rmt_del_channel(channel_);
}
if (encoder_) {
encoder_->del(encoder_);
}
}
void WS2812::set(size_t index, uint8_t r, uint8_t g, uint8_t b)
{
if (index >= num_leds_) {
return;
}
uint8_t *p = &pixels_[index * 3];
p[0] = g;
p[1] = r;
p[2] = b;
}
void WS2812::fill(uint8_t r, uint8_t g, uint8_t b)
{
for (size_t i = 0; i < num_leds_; i++) {
set(i, r, g, b);
}
}
esp_err_t WS2812::write()
{
for (size_t i = 0; i < pixels_.size(); i++) {
tx_pixels_[i] = static_cast<uint8_t>(pixels_[i] * brightness_ / 255);
}
esp_err_t ret = rmt_transmit(channel_, encoder_, tx_pixels_.data(), tx_pixels_.size(), &tx_config_);
if (ret != ESP_OK) {
return ret;
}
return rmt_tx_wait_all_done(channel_, portMAX_DELAY);
}
void WS2812::hsv2rgb(uint32_t h, uint32_t s, uint32_t v, uint32_t *r, uint32_t *g, uint32_t *b)
{
h %= 360; // h -> [0,360]
uint32_t rgb_max = v * 2.55f;
uint32_t rgb_min = rgb_max * (100 - s) / 100.0f;
uint32_t i = h / 60;
uint32_t diff = h % 60;
// RGB adjustment amount by hue
uint32_t rgb_adj = (rgb_max - rgb_min) * diff / 60;
switch (i) {
case 0:
*r = rgb_max;
*g = rgb_min + rgb_adj;
*b = rgb_min;
break;
case 1:
*r = rgb_max - rgb_adj;
*g = rgb_max;
*b = rgb_min;
break;
case 2:
*r = rgb_min;
*g = rgb_max;
*b = rgb_min + rgb_adj;
break;
case 3:
*r = rgb_min;
*g = rgb_max - rgb_adj;
*b = rgb_max;
break;
case 4:
*r = rgb_min + rgb_adj;
*g = rgb_min;
*b = rgb_max;
break;
default:
*r = rgb_max;
*g = rgb_min;
*b = rgb_max - rgb_adj;
break;
}
}
+74
View File
@@ -0,0 +1,74 @@
/*
* SPDX-License-Identifier: Apache-2.0
*/
#pragma once
#include <cstddef>
#include <cstdint>
#include <vector>
#include "driver/gpio.h"
#include "driver/rmt_encoder.h"
#include "driver/rmt_tx.h"
#include "esp_err.h"
/**
* @brief WS2812-style addressable LED strip driven through the RMT peripheral.
*
* Pixel data is kept in a local buffer. set() and fill() only update that buffer;
* call write() to push the buffer out to the strip.
*/
class WS2812 {
public:
/**
* @param gpio GPIO connected to the strip's data input (DI)
* @param num_leds Number of LEDs in the strip
* @param resolution_hz RMT tick resolution; 10 MHz gives 0.1 us ticks, which WS2812 needs
*/
WS2812(gpio_num_t gpio, size_t num_leds, uint32_t resolution_hz = 10000000);
~WS2812();
WS2812(const WS2812 &) = delete;
WS2812 &operator=(const WS2812 &) = delete;
/** @brief Set one pixel in the buffer. Out-of-range indices are ignored. */
void set(size_t index, uint8_t r, uint8_t g, uint8_t b);
/** @brief Set every pixel in the buffer to the same colour. */
void fill(uint8_t r, uint8_t g, uint8_t b);
/**
* @brief Transmit the buffer to the strip and wait until the transfer finishes.
* @return ESP_OK on success, or an error from the RMT driver.
*/
esp_err_t write();
/** @brief Number of LEDs in the strip. */
size_t size() const { return num_leds_; }
/**
* @brief Set the output brightness, 0 (off) to 255 (full). Applied in write();
* the pixel buffer keeps its full-colour values. Defaults to 255.
*/
void setBrightness(uint8_t level) { brightness_ = level; }
/** @brief Current output brightness, 0-255. */
uint8_t brightness() const { return brightness_; }
/**
* @brief Convert HSV to RGB.
*
* h is the hue in degrees (wrapped to [0, 360)); s and v are 0-100 percent.
* Wiki: https://en.wikipedia.org/wiki/HSL_and_HSV
*/
static void hsv2rgb(uint32_t h, uint32_t s, uint32_t v, uint32_t *r, uint32_t *g, uint32_t *b);
private:
size_t num_leds_;
std::vector<uint8_t> pixels_; // GRB byte order, 3 bytes per LED, as WS2812 expects
std::vector<uint8_t> tx_pixels_; // pixels_ scaled by brightness_, sent by write()
uint8_t brightness_ = 255;
rmt_channel_handle_t channel_ = nullptr;
rmt_encoder_handle_t encoder_ = nullptr;
rmt_transmit_config_t tx_config_ = {};
};