en/ESP-Scope
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add poweroff function & status LED. Include 3D files for Seeed XIAO

Browse Source
This commit is contained in:
Matt
2025-12-13 17:38:18 +00:00
parent c762e0d632
commit 00c3c85c67
6 changed files with 4258 additions and 118 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
main/Kconfig
View File

@@ -1,15 +1,20 @@
menu "espScope Configuration"
config LED_BUILTIN
int "LED IO Pin"
default 15
help
LED IO pin
config ESP_WIFI_SSID
string "WiFi SSID"
default "myssid"
help
SSID (network name) to connect to.
Default SSID (network name) to connect to. You can change this onece connected via the web interface.
config ESP_WIFI_PASSWORD
string "WiFi Password"
default "mypassword"
help
WiFi password.
Default SSID password. You can change this onece connected via the web interface.
endmenu

8
main/index.html
View File

@@ -111,13 +111,14 @@
direction: rtl;
}
#resetBtn {
#resetBtn, #powerOff {
background: #222;
color: #e66;
border: 1px solid;
font-size: 0.8rem;
height: 4em;
width: 6em;
vertical-align: middle;
}
</style>
</head>
@@ -168,7 +169,10 @@
<input type="number" id="testHz" value="100" min="1" max="10000">
</div>
</div>
<button id="resetBtn">Reset</button>
<div>
<button id="resetBtn">Reset</button>
<button id="powerOff">Power off</button>
</div>
</form>
</div>

3
main/index.js
View File

@@ -452,6 +452,9 @@ document.getElementById('resetBtn').addEventListener('click', () => {
localStorage.clear();
window.location.reload();
});
document.getElementById('powerOff').addEventListener('click', () => {
navigator.sendBeacon("/poweroff");
});
setParams();
connect();

245
main/main.c
View File

@@ -1,3 +1,9 @@
#include <inttypes.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include "cJSON.h"
#include "driver/gpio.h"
#include "driver/ledc.h"
@@ -5,20 +11,16 @@
#include "esp_event.h"
#include "esp_http_server.h"
#include "esp_log.h"
#include "esp_sleep.h"
#include "esp_system.h"
#include "esp_wifi.h"
#include "freertos/FreeRTOS.h"
#include "freertos/event_groups.h"
#include "freertos/task.h"
#include "nvs_flash.h"
#include <inttypes.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
// Tag for logging
static const char *TAG = "ESP-SCOPE";
static const char* TAG = "ESP-SCOPE";
// WiFi configuration from Kconfig
/* See untracked wifi-credentials.h */
@@ -65,7 +67,6 @@ static httpd_handle_t s_server = NULL;
static adc_continuous_handle_t adc_handle = NULL;
// Single client support for simplicity, or use a list for multiple
static int s_ws_client_fd = -1;
@@ -78,40 +79,38 @@ static uint16_t s_test_hz = 100;
// Forward declarations
static void wifi_init_sta(void);
static void continuous_adc_init(adc_channel_t *channel, uint8_t channel_num,
adc_continuous_handle_t *out_handle);
static esp_err_t ws_handler(httpd_req_t *req);
static void continuous_adc_init(adc_channel_t* channel, uint8_t channel_num,
adc_continuous_handle_t* out_handle);
static esp_err_t ws_handler(httpd_req_t* req);
// Forward declarations
static void wifi_init_sta(void);
static void continuous_adc_init(adc_channel_t *channel, uint8_t channel_num,
adc_continuous_handle_t *out_handle);
static esp_err_t ws_handler(httpd_req_t *req);
static void continuous_adc_init(adc_channel_t* channel, uint8_t channel_num,
adc_continuous_handle_t* out_handle);
static esp_err_t ws_handler(httpd_req_t* req);
// Helper to calculate optimal buffer size (approx 50ms latency, max 4096, aligned to 4)
static uint32_t get_optimal_buffer_size(uint32_t sample_rate) {
uint32_t bytes_per_sec = sample_rate * sizeof(adc_digi_output_data_t);
uint32_t target_size = bytes_per_sec / 50; // 20ms (50Hz)
uint32_t bytes_per_sec = sample_rate * sizeof(adc_digi_output_data_t);
uint32_t target_size = bytes_per_sec / 50; // 20ms (50Hz)
// Clamp to min/max
if (target_size < 128) target_size = 128;
if (target_size > ADC_READ_LEN) target_size = ADC_READ_LEN;
// Clamp to min/max
if (target_size < 128) target_size = 128;
if (target_size > ADC_READ_LEN) target_size = ADC_READ_LEN;
// Align to 4 bytes
return (target_size + 3) & ~3;
// Align to 4 bytes
return (target_size + 3) & ~3;
}
/*
* Task to read from ADC Continuous driver
*/
static void adc_read_task(void *arg) {
static void adc_read_task(void* arg) {
esp_err_t ret;
uint32_t ret_num = 0;
uint8_t result[ADC_READ_LEN] = {0};
memset(result, 0xcc, ADC_READ_LEN);
// ADC Init (Moved from app_main)
// TODO: Make this configurable or find a good default pin.
// For ESP32C6 ADC1 Channel 0 is usually GPIO 0. Let's use Channel 0 for now.
@@ -157,7 +156,6 @@ static void adc_read_task(void *arg) {
if (ret == ESP_OK) {
// ESP_LOGI(TAG, "ret is %x, ret_num is %"PRIu32" bytes", ret, ret_num);
// OPTIMIZED BATCH SENDING
// We have `ret_num` bytes of data in `result`.
// It contains `adc_digi_output_data_t` structs (4 bytes each).
@@ -166,39 +164,37 @@ static void adc_read_task(void *arg) {
// So we have 1/2 the size.
if (s_ws_client_fd != -1) {
// Allocate a small temp buffer on stack or static to avoid malloc in loop
// ret_num is up to ADC_READ_LEN (1024). 1024 / 4 = 256 samples.
// 256 * 2 bytes = 512 bytes output. Stack safe.
uint16_t out_buf[ADC_READ_LEN / sizeof(adc_digi_output_data_t)];
int out_idx = 0;
// Allocate a small temp buffer on stack or static to avoid malloc in loop
// ret_num is up to ADC_READ_LEN (1024). 1024 / 4 = 256 samples.
// 256 * 2 bytes = 512 bytes output. Stack safe.
uint16_t out_buf[ADC_READ_LEN / sizeof(adc_digi_output_data_t)];
int out_idx = 0;
for (int i = 0; i < ret_num; i += sizeof(adc_digi_output_data_t)) {
adc_digi_output_data_t* p = (adc_digi_output_data_t*)&result[i];
uint32_t val = ADC_GET_DATA(p);
out_buf[out_idx++] = (uint16_t)val;
}
for (int i = 0; i < ret_num; i += sizeof(adc_digi_output_data_t)) {
adc_digi_output_data_t *p = (adc_digi_output_data_t *)&result[i];
uint32_t val = ADC_GET_DATA(p);
out_buf[out_idx++] = (uint16_t)val;
}
if (out_idx > 0) {
httpd_ws_frame_t ws_frame = {
.final = true,
.fragmented = false,
.type = HTTPD_WS_TYPE_BINARY,
.payload = (uint8_t *)out_buf,
.len = out_idx * sizeof(uint16_t)
};
// Non-blocking send (best effort)
esp_err_t ret_ws = httpd_ws_send_frame_async(s_server, s_ws_client_fd, &ws_frame);
if (ret_ws != ESP_OK) {
ESP_LOGW(TAG, "dropped: %s", esp_err_to_name(ret_ws));
// Invalidate FD if it's no longer valid (client disconnected)
if (ret_ws == ESP_ERR_INVALID_ARG || ret_ws == ESP_FAIL) {
s_ws_client_fd = -1;
}
}
if (out_idx > 0) {
httpd_ws_frame_t ws_frame = {
.final = true,
.fragmented = false,
.type = HTTPD_WS_TYPE_BINARY,
.payload = (uint8_t*)out_buf,
.len = out_idx * sizeof(uint16_t)};
// Non-blocking send (best effort)
esp_err_t ret_ws = httpd_ws_send_frame_async(s_server, s_ws_client_fd, &ws_frame);
if (ret_ws != ESP_OK) {
ESP_LOGW(TAG, "dropped: %s", esp_err_to_name(ret_ws));
// Invalidate FD if it's no longer valid (client disconnected)
if (ret_ws == ESP_ERR_INVALID_ARG || ret_ws == ESP_FAIL) {
s_ws_client_fd = -1;
}
}
}
}
/**
@@ -213,11 +209,8 @@ static void adc_read_task(void *arg) {
}
}
static void continuous_adc_init(adc_channel_t *channel, uint8_t channel_num,
adc_continuous_handle_t *out_handle) {
static void continuous_adc_init(adc_channel_t* channel, uint8_t channel_num,
adc_continuous_handle_t* out_handle) {
uint32_t frame_size = get_optimal_buffer_size(s_sample_rate);
ESP_LOGI(TAG, "Dynamic Buffer Size: %lu bytes", frame_size);
@@ -271,30 +264,39 @@ static void start_test_signal(uint32_t hz) {
}
ESP_LOGI(TAG, "Starting test signal at %u Hz", hz);
ledc_timer_config_t ledc_timer = {
.speed_mode = LEDC_LOW_SPEED_MODE,
.duty_resolution = LEDC_TIMER_14_BIT,
.timer_num = LEDC_TIMER_0,
.freq_hz = hz,
.clk_cfg = LEDC_AUTO_CLK
};
.speed_mode = LEDC_LOW_SPEED_MODE,
.duty_resolution = LEDC_TIMER_14_BIT,
.timer_num = LEDC_TIMER_0,
.freq_hz = hz,
.clk_cfg = LEDC_AUTO_CLK};
ledc_channel_config_t ledc_channel = {
.gpio_num = 1, // GPIO data pin 1
.speed_mode = LEDC_LOW_SPEED_MODE,
.channel = LEDC_CHANNEL_0,
.timer_sel = LEDC_TIMER_0,
.duty = 1 << (ledc_timer.duty_resolution - 1), // 512, // 50% duty cycle (1024 / 2 for 10-bit resolution)
.hpoint = 0
};
.gpio_num = 1, // GPIO data pin 1
.speed_mode = LEDC_LOW_SPEED_MODE,
.channel = LEDC_CHANNEL_0,
.timer_sel = LEDC_TIMER_0,
.duty = 1 << (ledc_timer.duty_resolution - 1), // 512, // 50% duty cycle (1024 / 2 for 10-bit resolution)
.hpoint = 0};
// Initialize the PWM
ledc_timer_config(&ledc_timer);
ledc_channel_config(&ledc_channel);
// Start the PWM signal
ledc_set_duty(ledc_channel.speed_mode, ledc_channel.channel, ledc_channel.duty); // 50% duty cycle
ledc_set_duty(ledc_channel.speed_mode, ledc_channel.channel, ledc_channel.duty); // 50% duty cycle
ledc_update_duty(ledc_channel.speed_mode, ledc_channel.channel);
ledc_inited = true;
}
static void show_status_led() {
#ifdef CONFIG_LED_BUILTIN
while (true) {
vTaskDelay(pdMS_TO_TICKS(100));
gpio_set_level(CONFIG_LED_BUILTIN, 1);
vTaskDelay(pdMS_TO_TICKS(s_ws_client_fd == -1 ? 900 : 200));
gpio_set_level(CONFIG_LED_BUILTIN, 0);
}
#endif
}
void app_main(void) {
// Initialize NVS
esp_err_t ret = nvs_flash_init();
@@ -305,28 +307,35 @@ void app_main(void) {
}
ESP_ERROR_CHECK(ret);
#ifdef CONFIG_LED_BUILTIN
gpio_config_t led_io_conf = {
.pin_bit_mask = (1ULL << CONFIG_LED_BUILTIN),
.mode = GPIO_MODE_OUTPUT,
.pull_up_en = GPIO_PULLUP_DISABLE,
.pull_down_en = GPIO_PULLDOWN_DISABLE,
.intr_type = GPIO_INTR_DISABLE};
gpio_config(&led_io_conf);
gpio_set_level(CONFIG_LED_BUILTIN, 0);
#endif
ESP_LOGI(TAG, "ESP_WIFI_MODE_STA");
/* Board-specific WiFi init (if any) */
// Seeed XIAO ESP32C6: Configure GPIO 3 and GPIO 14 as outputs
gpio_config_t io_conf = {
.pin_bit_mask = (1ULL << 3) | (1ULL << 14),
.mode = GPIO_MODE_OUTPUT,
.pull_up_en = GPIO_PULLUP_DISABLE,
.pull_down_en = GPIO_PULLDOWN_DISABLE,
.intr_type = GPIO_INTR_DISABLE
};
gpio_config(&io_conf);
// Seeed XIAO ESP32C6: Configure GPIO 3 and GPIO 14 as outputs
gpio_config_t board_io_conf = {
.pin_bit_mask = (1ULL << 3) | (1ULL << 14),
.mode = GPIO_MODE_OUTPUT,
.pull_up_en = GPIO_PULLUP_DISABLE,
.pull_down_en = GPIO_PULLDOWN_DISABLE,
.intr_type = GPIO_INTR_DISABLE};
gpio_config(&board_io_conf);
// Set GPIO 3 and GPIO 14 to low
gpio_set_level(3, 0);
gpio_set_level(14, 0);
// Set GPIO 3 and GPIO 14 to low
gpio_set_level(3, 0);
gpio_set_level(14, 0);
/* end board-specific WiFi init (if any) */
wifi_init_sta();
start_test_signal(100);
xTaskCreate(adc_read_task, "adc_read_task", 8192 + ADC_READ_LEN, NULL, 5, NULL);
// Wait for WiFi connection
@@ -337,6 +346,7 @@ void app_main(void) {
if (bits & WIFI_CONNECTED_BIT) {
ESP_LOGI(TAG, "connected to ap SSID:%s", ESP_WIFI_SSID);
start_webserver();
show_status_led();
} else if (bits & WIFI_FAIL_BIT) {
ESP_LOGI(TAG, "Failed to connect to SSID:%s", ESP_WIFI_SSID);
} else {
@@ -344,8 +354,8 @@ void app_main(void) {
}
}
static void event_handler(void *arg, esp_event_base_t event_base,
int32_t event_id, void *event_data) {
static void event_handler(void* arg, esp_event_base_t event_base,
int32_t event_id, void* event_data) {
if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_START) {
esp_wifi_connect();
} else if (event_base == WIFI_EVENT &&
@@ -359,7 +369,7 @@ static void event_handler(void *arg, esp_event_base_t event_base,
}
ESP_LOGI(TAG, "connect to the AP fail");
} else if (event_base == IP_EVENT && event_id == IP_EVENT_STA_GOT_IP) {
ip_event_got_ip_t *event = (ip_event_got_ip_t *)event_data;
ip_event_got_ip_t* event = (ip_event_got_ip_t*)event_data;
ESP_LOGI(TAG, "got ip:" IPSTR, IP2STR(&event->ip_info.ip));
s_retry_num = 0;
xEventGroupSetBits(s_wifi_event_group, WIFI_CONNECTED_BIT);
@@ -401,19 +411,17 @@ static void wifi_init_sta(void) {
ESP_LOGI(TAG, "wifi_init_sta finished.");
}
/*
* WebSocket Handler
*/
static esp_err_t ws_handler(httpd_req_t *req) {
static esp_err_t ws_handler(httpd_req_t* req) {
if (req->method == HTTP_GET) {
// Handshake
return ESP_OK;
}
httpd_ws_frame_t ws_pkt;
uint8_t *buf = NULL;
uint8_t* buf = NULL;
memset(&ws_pkt, 0, sizeof(httpd_ws_frame_t));
ws_pkt.type = HTTPD_WS_TYPE_TEXT;
@@ -435,7 +443,7 @@ static esp_err_t ws_handler(httpd_req_t *req) {
// Check for "hello"
if (ws_pkt.type == HTTPD_WS_TYPE_TEXT &&
strcmp((char *)ws_pkt.payload, "hello") == 0) {
strcmp((char*)ws_pkt.payload, "hello") == 0) {
ESP_LOGI(TAG, "New WS client connected, fd=%d", httpd_req_to_sockfd(req));
s_ws_client_fd = httpd_req_to_sockfd(req);
}
@@ -447,7 +455,7 @@ static esp_err_t ws_handler(httpd_req_t *req) {
/*
* Control Params Handler (POST /params)
*/
static esp_err_t params_handler(httpd_req_t *req) {
static esp_err_t params_handler(httpd_req_t* req) {
char buf[256];
int ret, remaining = req->content_len;
if (remaining >= sizeof(buf)) {
@@ -460,24 +468,24 @@ static esp_err_t params_handler(httpd_req_t *req) {
return ESP_FAIL;
buf[ret] = '\0';
cJSON *root = cJSON_Parse(buf);
cJSON* root = cJSON_Parse(buf);
if (root) {
cJSON *sample_rate = cJSON_GetObjectItem(root, "sample_rate");
cJSON* sample_rate = cJSON_GetObjectItem(root, "sample_rate");
if (sample_rate && s_sample_rate != sample_rate->valueint) {
s_reconfig_needed = true;
s_sample_rate = sample_rate->valueint;
}
cJSON *atten = cJSON_GetObjectItem(root, "atten");
cJSON* atten = cJSON_GetObjectItem(root, "atten");
if (atten && s_atten != (adc_atten_t)atten->valueint) {
s_reconfig_needed = true;
s_atten = (adc_atten_t)atten->valueint;
}
cJSON *bit_width = cJSON_GetObjectItem(root, "bit_width");
cJSON* bit_width = cJSON_GetObjectItem(root, "bit_width");
if (bit_width && s_bit_width != (adc_bitwidth_t)bit_width->valueint) {
s_reconfig_needed = true;
s_bit_width = (adc_bitwidth_t)bit_width->valueint;
}
cJSON *test_hz = cJSON_GetObjectItem(root, "test_hz");
cJSON* test_hz = cJSON_GetObjectItem(root, "test_hz");
if (test_hz) {
if (s_test_hz != (adc_bitwidth_t)test_hz->valueint) {
s_test_hz = (adc_bitwidth_t)test_hz->valueint;
@@ -487,7 +495,7 @@ static esp_err_t params_handler(httpd_req_t *req) {
ESP_LOGI(TAG, "Config Request: Rate=%lu, Atten=%d, Width=%d, TestHz=%u, s_reconfig_needed=%d", s_sample_rate,
s_atten, s_bit_width, s_test_hz,
s_reconfig_needed);
s_reconfig_needed);
cJSON_Delete(root);
}
@@ -507,16 +515,14 @@ static const httpd_uri_t uri_params = {.uri = "/params",
.handler = params_handler,
.user_ctx = NULL};
/* Handler for serving index.html */
static esp_err_t index_handler(httpd_req_t *req) {
static esp_err_t index_handler(httpd_req_t* req) {
httpd_resp_set_type(req, "text/html");
httpd_resp_set_hdr(req, "Content-Type", "text/html; charset=utf-8");
uint32_t len = index_html_end - index_html_start;
// Workaround for some build systems adding null byte
while (len && index_js_start[len-1] == 0) len--;
httpd_resp_send(req, (const char *)index_html_start, len);
while (len && index_js_start[len - 1] == 0) len--;
httpd_resp_send(req, (const char*)index_html_start, len);
return ESP_OK;
}
@@ -524,19 +530,32 @@ static const httpd_uri_t uri_index = {
.uri = "/", .method = HTTP_GET, .handler = index_handler, .user_ctx = NULL};
/* Handler for serving index.js */
static esp_err_t index_js_handler(httpd_req_t *req) {
static esp_err_t index_js_handler(httpd_req_t* req) {
httpd_resp_set_type(req, "text/javascript");
httpd_resp_set_hdr(req, "Content-Type", "text/javascript; charset=utf-8");
uint32_t len = index_js_end - index_js_start;
// Workaround for some build systems adding null byte
while (len && index_js_start[len-1] == 0) len--;
httpd_resp_send(req, (const char *)index_js_start, len);
while (len && index_js_start[len - 1] == 0) len--;
httpd_resp_send(req, (const char*)index_js_start, len);
return ESP_OK;
}
static const httpd_uri_t uri_index_js = {
.uri = "/index.js", .method = HTTP_GET, .handler = index_js_handler, .user_ctx = NULL};
static esp_err_t power_handler(httpd_req_t* req) {
#ifdef CONFIG_LED_BUILTIN
gpio_set_level(CONFIG_LED_BUILTIN, 0);
#endif
esp_sleep_enable_timer_wakeup(30L * 24L * 60L * 60L * 1000000ULL); // One month
esp_deep_sleep_start();
return ESP_OK;
}
static const httpd_uri_t uri_power = {
.uri = "/poweroff", .method = HTTP_POST, .handler = power_handler, .user_ctx = NULL};
static void start_webserver(void) {
httpd_config_t config = HTTPD_DEFAULT_CONFIG();
config.lru_purge_enable = true;
@@ -548,9 +567,7 @@ static void start_webserver(void) {
httpd_register_uri_handler(s_server, &uri_index_js);
httpd_register_uri_handler(s_server, &uri_ws);
httpd_register_uri_handler(s_server, &uri_params);
httpd_register_uri_handler(s_server, &uri_power);
} else {
ESP_LOGI(TAG, "Error starting server!");
}