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

+6 -1
View File
@@ -1,3 +1,8 @@
cmake_minimum_required(VERSION 3.16)
# The following lines of boilerplate have to be in your project's CMakeLists
# in this exact order for cmake to work correctly
cmake_minimum_required(VERSION 3.22)
include($ENV{IDF_PATH}/tools/cmake/project.cmake)
# "Trim" the build. Include the minimal set of components, main, and anything it depends on.
idf_build_set_property(MINIMAL_BUILD ON)
project(led_driver)
+75
View File
@@ -0,0 +1,75 @@
# Top-level Makefile for the led_strip ESP-IDF project.
# Thin wrapper around idf.py. Runs on Linux, macOS (bash) and Windows (GNU make with cmd.exe or sh).
#
# Override any variable on the command line, for example:
# make flash PORT=/dev/ttyUSB0 # Linux
# make flash PORT=/dev/cu.usbmodem101 # macOS
# make flash PORT=COM4 # Windows
ifeq ($(OS),Windows_NT)
HOST_OS := windows
HOME_DIR := $(USERPROFILE)
DEFAULT_PORT := COM3
else
HOST_OS := $(shell uname -s)
HOME_DIR := $(HOME)
ifeq ($(HOST_OS),Darwin)
DEFAULT_PORT := /dev/cu.usbmodem101
else
DEFAULT_PORT := /dev/ttyACM0
endif
endif
IDF_PATH ?= $(HOME_DIR)/.espressif/v6.1/esp-idf
IDF_PYTHON_ENV_PATH ?= $(HOME_DIR)/.espressif/python_env/idf6.1_py3.12_env
PORT ?= $(DEFAULT_PORT)
export IDF_PATH
export IDF_PYTHON_ENV_PATH
# Run idf.py in a shell that has sourced ESP-IDF's environment script (sets PATH and toolchains).
ifeq ($(HOST_OS),windows)
define idf
cmd /c "$(subst /,\,$(IDF_PATH))\export.bat && idf.py $(1)"
endef
else
define idf
bash -c '. "$(IDF_PATH)/export.sh" >/dev/null 2>&1 && idf.py $(1)'
endef
endif
.PHONY: all build flash monitor flash-monitor menuconfig clean fullclean help
all: build
build:
$(call idf,build)
flash: build
$(call idf,-p $(PORT) flash)
monitor:
$(call idf,-p $(PORT) monitor)
flash-monitor: build
$(call idf,-p $(PORT) flash monitor)
menuconfig:
$(call idf,menuconfig)
clean:
$(call idf,clean)
fullclean:
$(call idf,fullclean)
help:
@echo Targets:
@echo build Build the firmware
@echo flash Build, then flash to the board on PORT
@echo monitor Open the serial monitor on PORT
@echo flash-monitor Build, flash, then open the serial monitor
@echo menuconfig Open the project configuration menu
@echo clean Remove build outputs
@echo fullclean Delete the build directory entirely
@echo help Show this help
+25 -3
View File
@@ -53,10 +53,32 @@ led-driver/
## C++ app (ESP-IDF)
The `cpp` branch adds a basic ESP-IDF project for ESP32-S3 at the repo root (`CMakeLists.txt`, `main/`).
The `cpp` branch is an ESP-IDF app for the ESP32-C3 at the repo root (`CMakeLists.txt`, `main/`, `web/`). It drives a 119-LED WS2812 strip on GPIO 10 (set in `main/patterns.cpp`).
### Web UI, access point and Wi-Fi client
The firmware runs three things at once:
- **Access point** `led-XXXXXX` (the last three bytes of the MAC), open, no password. Join it and browse to `http://192.168.4.1/`.
- **Wi-Fi client**: set a network from the Settings tab (scan, pick, enter password). Credentials are saved to NVS, and the client reconnects with backoff after a drop.
- **mDNS**: once on a network, the device answers as `http://led.local/`.
Patterns: solid, rainbow, chase, breathe, blink, pulse, transition and circle. The web UI is embedded in the firmware from `web/`.
JSON API (port 80):
| Method | Path | Purpose |
|--------|------|---------|
| GET | `/api/status` | Current pattern and parameters, AP name, client state and IP |
| POST | `/api/pattern` | `{"mode","c1":[r,g,b],"c2":[r,g,b],"speed_ms","brightness"}` |
| GET | `/api/wifi` | Saved client SSID and connection state |
| POST | `/api/wifi` | `{"ssid","password"}`: save and connect |
| GET | `/api/wifi/scan` | Visible networks |
Build and flash for the ESP32-C3:
```bash
. ~/.espressif/v6.1/esp-idf/export.sh # or your ESP-IDF install's export.sh
idf.py set-target esp32s3
. ~/.espressif/v6.1/esp-idf/export.sh
idf.py set-target esp32c3
idf.py build flash monitor
```
+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_ = {};
};
+3 -1
View File
@@ -1 +1,3 @@
CONFIG_IDF_TARGET="esp32s3"
CONFIG_IDF_TARGET="esp32c3"
# The mDNS console CLI needs the console component; the app does not use it.
CONFIG_MDNS_ENABLE_CONSOLE_CLI=n
+121
View File
@@ -0,0 +1,121 @@
// LED strip web UI. Talks to the JSON API in main/web.cpp.
(() => {
const $ = (id) => document.getElementById(id);
async function api(path, opts) {
const r = await fetch(path, opts);
const j = await r.json().catch(() => ({}));
if (!r.ok) throw new Error(j.error || r.statusText);
return j;
}
const post = (path, body) => api(path, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(body),
});
const toHex = (rgb) => '#' + rgb.map((v) => v.toString(16).padStart(2, '0')).join('');
const fromHex = (h) => [1, 3, 5].map((i) => parseInt(h.slice(i, i + 2), 16));
function updateOutputs() {
$('speedOut').textContent = $('speed').value + ' ms';
$('brightOut').textContent = $('bright').value;
}
// Coalesce slider drags into one request
let sendTimer;
function sendPattern() {
updateOutputs();
clearTimeout(sendTimer);
sendTimer = setTimeout(async () => {
try {
await post('/api/pattern', {
mode: $('mode').value,
c1: fromHex($('c1').value),
c2: fromHex($('c2').value),
speed_ms: Number($('speed').value),
brightness: Number($('bright').value),
});
$('status').textContent = 'Applied';
} catch (e) {
$('status').textContent = e.message;
}
}, 150);
}
async function loadStatus() {
const s = await api('/api/status');
$('apName').textContent = s.ap_ssid;
$('staState').textContent = s.sta_connected ? 'connected (' + s.sta_ip + ')' : 'not connected';
if (!$('mode').options.length) {
s.modes.forEach((m) => $('mode').add(new Option(m, m)));
}
$('mode').value = s.mode;
$('c1').value = toHex(s.c1);
$('c2').value = toHex(s.c2);
$('speed').value = s.speed_ms;
$('bright').value = s.brightness;
updateOutputs();
}
async function loadWifi() {
const w = await api('/api/wifi');
if (w.ssid && !$('ssid').value) $('ssid').value = w.ssid;
}
async function scan() {
const list = $('networks');
list.textContent = 'Scanning…';
try {
const { networks } = await api('/api/wifi/scan');
list.textContent = '';
networks.sort((a, b) => b.rssi - a.rssi).forEach((n) => {
const li = document.createElement('li');
const btn = document.createElement('button');
btn.type = 'button';
btn.className = 'net';
btn.textContent = `${n.ssid || '(hidden)'} ${n.rssi} dBm${n.open ? '' : ' 🔒'}`;
btn.addEventListener('click', () => { $('ssid').value = n.ssid; $('pass').focus(); });
li.appendChild(btn);
list.appendChild(li);
});
if (!networks.length) list.textContent = 'No networks found.';
} catch (e) {
list.textContent = e.message;
}
}
// Tabs
document.querySelectorAll('.tab').forEach((btn) => {
btn.addEventListener('click', () => {
document.querySelectorAll('.tab').forEach((b) => b.classList.toggle('active', b === btn));
$('patterns').hidden = btn.dataset.tab !== 'patterns';
$('settings').hidden = btn.dataset.tab !== 'settings';
});
});
['mode', 'c1', 'c2', 'speed', 'bright'].forEach((id) => {
$(id).addEventListener('input', sendPattern);
$(id).addEventListener('change', sendPattern);
});
$('scan').addEventListener('click', scan);
$('wifiForm').addEventListener('submit', async (ev) => {
ev.preventDefault();
$('wifiMsg').textContent = 'Saving…';
try {
const j = await post('/api/wifi', { ssid: $('ssid').value, password: $('pass').value });
$('wifiMsg').textContent = j.message || 'Saved';
$('pass').value = '';
setTimeout(() => loadStatus().catch(() => {}), 4000);
} catch (e) {
$('wifiMsg').textContent = e.message;
}
});
loadStatus().catch((e) => { $('status').textContent = e.message; });
loadWifi().catch(() => {});
setInterval(() => loadStatus().catch(() => {}), 5000);
})();
+64
View File
@@ -0,0 +1,64 @@
<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>LED strip</title>
<link rel="stylesheet" href="/style.css">
</head>
<body>
<header>
<h1>LED strip</h1>
<nav>
<button class="tab active" data-tab="patterns">Patterns</button>
<button class="tab" data-tab="settings">Settings</button>
</nav>
</header>
<main>
<section id="patterns">
<label>Pattern
<select id="mode"></select>
</label>
<div class="row">
<label>Colour
<input type="color" id="c1" value="#ff0000">
</label>
<label>Colour 2
<input type="color" id="c2" value="#000000">
</label>
</div>
<label>Speed <output id="speedOut"></output>
<input type="range" id="speed" min="10" max="3000" step="10">
</label>
<label>Brightness <output id="brightOut"></output>
<input type="range" id="bright" min="0" max="255" step="1">
</label>
<p id="status" class="muted" role="status"></p>
</section>
<section id="settings" hidden>
<h2>Access point</h2>
<p>Network <strong id="apName">…</strong> (open). Address <strong>192.168.4.1</strong>.</p>
<h2>Wi-Fi client</h2>
<p>Status: <span id="staState">…</span></p>
<button id="scan" type="button">Scan for networks</button>
<ul id="networks" class="list"></ul>
<form id="wifiForm">
<label>Network name (SSID)
<input id="ssid" required maxlength="32" autocomplete="off">
</label>
<label>Password <span class="muted">(blank for open networks)</span>
<input id="pass" type="password" maxlength="64" autocomplete="off">
</label>
<button type="submit">Save and connect</button>
</form>
<p id="wifiMsg" class="muted" role="status"></p>
</section>
</main>
<script src="/app.js"></script>
</body>
</html>
+121
View File
@@ -0,0 +1,121 @@
:root {
--bg: #f6f6f7;
--fg: #1d1d1f;
--muted: #6e6e73;
--card: #ffffff;
--accent: #2563eb;
--border: #d2d2d7;
}
@media (prefers-color-scheme: dark) {
:root:not([data-theme="light"]) {
--bg: #111114;
--fg: #f2f2f5;
--muted: #9a9aa3;
--card: #1c1c21;
--accent: #5b8cff;
--border: #34343c;
}
}
:root[data-theme="dark"] {
--bg: #111114;
--fg: #f2f2f5;
--muted: #9a9aa3;
--card: #1c1c21;
--accent: #5b8cff;
--border: #34343c;
}
* { box-sizing: border-box; }
body {
margin: 0;
padding: 0 16px 32px;
background: var(--bg);
color: var(--fg);
font: 16px/1.4 system-ui, -apple-system, "Segoe UI", Roboto, sans-serif;
}
header {
max-width: 560px;
margin: 0 auto;
padding: 16px 0 8px;
}
h1 { margin: 0 0 12px; font-size: 1.5rem; }
h2 { font-size: 1.1rem; margin: 20px 0 8px; }
nav { display: flex; gap: 8px; }
main {
max-width: 560px;
margin: 0 auto;
background: var(--card);
border: 1px solid var(--border);
border-radius: 12px;
padding: 16px;
}
section > * + * { margin-top: 12px; }
label {
display: flex;
flex-direction: column;
gap: 6px;
font-weight: 500;
}
output { font-weight: 400; color: var(--muted); }
.row { display: flex; gap: 16px; flex-wrap: wrap; }
.row > label { flex: 1 1 140px; }
select, input[type="text"], input:not([type]), input[type="password"] {
font: inherit;
padding: 8px 10px;
border: 1px solid var(--border);
border-radius: 8px;
background: var(--bg);
color: var(--fg);
width: 100%;
}
input[type="color"] {
width: 100%;
height: 44px;
padding: 2px;
border: 1px solid var(--border);
border-radius: 8px;
background: var(--bg);
}
input[type="range"] { width: 100%; accent-color: var(--accent); }
button {
font: inherit;
padding: 8px 14px;
border: 1px solid var(--border);
border-radius: 8px;
background: var(--bg);
color: var(--fg);
cursor: pointer;
}
button.tab.active,
button[type="submit"] {
background: var(--accent);
border-color: var(--accent);
color: #fff;
}
.list { list-style: none; padding: 0; margin: 0; }
.list li + li { margin-top: 6px; }
button.net { width: 100%; text-align: left; }
.muted { color: var(--muted); font-size: 0.9rem; }
[hidden] { display: none !important; }
form { display: flex; flex-direction: column; gap: 12px; }
form button { align-self: flex-start; }