feat: browser simulator served by the controller, desktop build, browser bridge

- led-simulator: the rig runs the C++ led-driver as WebAssembly (sim-driver/),
  one single-threaded worker per bar, no cross-origin isolation needed. Rooms
  (one JSON per room) with an on-page editor, and a pattern gallery. The
  Python server, Pyodide boot and ring buffer are removed.
- sim-controller sim_rig.c: serves /sim/ from an embedded pack, the page's
  WebSocket and the rooms/flash API. The desktop build embeds it too.
- bridge.c: a "browser" bridge kind that carries ESP-NOW frames to the page;
  devices announced through it are marked sim.
- UI: Simulator in the Menu, split view with resize and pop-out, swipe
  between controller and rig on phones; SIM/REAL badges in Devices.
- Fades: preset pushes and Wi-Fi driver bodies always carry fade and
  beat_time, so "off" no longer inherits an earlier fade.
- Also the sequences-v2 work in progress: desktop port, bridge firmware,
  serial bridge, Wi-Fi drivers, sequence timeline, audio and API changes.
- led-driver: ESP-NOW link, beat sync, control messages, sim hooks.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
jimmyandClaude Opus 5.5 committed 2026-11-16 19:32:46 +13:00
1 parent 698c1463c0
commit 581b751904
506 files changed
+42336 -3599

No files matched your search

+9
View File
@@ -0,0 +1,9 @@
/* SHA-1 and base64 for the WebSocket handshake (desktop/port/src/desktop_crypto.c) */
#pragma once
#include <stddef.h>
#include <stdint.h>
void desktop_sha1(const uint8_t *data, size_t len, uint8_t out[20]);
// Writes the NUL-terminated base64 of in; returns the length without the NUL, 0 if out is too small
size_t desktop_base64_encode(char *out, size_t cap, const uint8_t *in, size_t n);
+16
View File
@@ -0,0 +1,16 @@
#pragma once
#include <stdint.h>
typedef struct {
uint32_t magic_word;
uint32_t secure_version;
char version[32];
char project_name[32];
char time[16];
char date[16];
char idf_ver[32];
uint8_t app_elf_sha256[32];
} esp_app_desc_t;
const esp_app_desc_t *esp_app_get_description(void);
+39
View File
@@ -0,0 +1,39 @@
#pragma once
#include <stdlib.h>
#include "esp_err.h"
#include "esp_log.h"
#define ESP_RETURN_ON_ERROR(x, tag, fmt, ...) \
do { \
esp_err_t err_rc_ = (x); \
if (err_rc_ != ESP_OK) { \
ESP_LOGE(tag, "%s(%d): " fmt, __func__, (int)err_rc_, ##__VA_ARGS__); \
return err_rc_; \
} \
} while (0)
#define ESP_RETURN_ON_FALSE(cond, err, tag, fmt, ...) \
do { \
if (!(cond)) { \
ESP_LOGE(tag, "%s(%d): " fmt, __func__, (int)(err), ##__VA_ARGS__); \
return (err); \
} \
} while (0)
#define ESP_ERROR_CHECK(x) \
do { \
esp_err_t err_rc_ = (x); \
if (err_rc_ != ESP_OK) { \
ESP_LOGE("check", "%s:%d: %s", __FILE__, __LINE__, esp_err_to_name(err_rc_)); \
abort(); \
} \
} while (0)
#define ESP_ERROR_CHECK_WITHOUT_ABORT(x) \
do { \
esp_err_t err_rc_ = (x); \
if (err_rc_ != ESP_OK) { \
ESP_LOGE("check", "%s:%d: %s", __FILE__, __LINE__, esp_err_to_name(err_rc_)); \
} \
} while (0)
+65
View File
@@ -0,0 +1,65 @@
/* Desktop port: the ESP-IDF error codes the firmware uses (same values as ESP-IDF). */
#pragma once
#include <stdbool.h>
#include <stdint.h>
#include <stdlib.h>
#include "esp_log.h"
typedef int32_t esp_err_t;
#define ESP_OK 0
#define ESP_FAIL -1
#define ESP_ERR_NO_MEM 0x101
#define ESP_ERR_INVALID_ARG 0x102
#define ESP_ERR_INVALID_STATE 0x103
#define ESP_ERR_INVALID_SIZE 0x104
#define ESP_ERR_NOT_FOUND 0x105
#define ESP_ERR_NOT_SUPPORTED 0x106
#define ESP_ERR_TIMEOUT 0x107
#define ESP_ERR_INVALID_RESPONSE 0x108
#define ESP_ERR_INVALID_CRC 0x109
#define ESP_ERR_INVALID_VERSION 0x10A
#define ESP_ERR_INVALID_MAC 0x10B
#define ESP_ERR_NOT_FINISHED 0x10C
const char *esp_err_to_name(esp_err_t code);
// ESP-IDF's compiler pragmas around a known false-positive warning: nothing to do on the desktop
#define ESP_COMPILER_DIAGNOSTIC_PUSH_IGNORE(x)
#define ESP_COMPILER_DIAGNOSTIC_POP(x)
// ESP-IDF keeps these in esp_err.h; esp_check.h has the same macros
#define ESP_RETURN_ON_ERROR(x, tag, fmt, ...) \
do { \
esp_err_t err_rc_ = (x); \
if (err_rc_ != ESP_OK) { \
ESP_LOGE(tag, "%s(%d): " fmt, __func__, (int)err_rc_, ##__VA_ARGS__); \
return err_rc_; \
} \
} while (0)
#define ESP_RETURN_ON_FALSE(cond, err, tag, fmt, ...) \
do { \
if (!(cond)) { \
ESP_LOGE(tag, "%s(%d): " fmt, __func__, (int)(err), ##__VA_ARGS__); \
return (err); \
} \
} while (0)
#define ESP_ERROR_CHECK(x) \
do { \
esp_err_t err_rc_ = (x); \
if (err_rc_ != ESP_OK) { \
ESP_LOGE("check", "%s:%d: %s", __FILE__, __LINE__, esp_err_to_name(err_rc_)); \
abort(); \
} \
} while (0)
#define ESP_ERROR_CHECK_WITHOUT_ABORT(x) \
do { \
esp_err_t err_rc_ = (x); \
if (err_rc_ != ESP_OK) { \
ESP_LOGE("check", "%s:%d: %s", __FILE__, __LINE__, esp_err_to_name(err_rc_)); \
} \
} while (0)
+18
View File
@@ -0,0 +1,18 @@
/* Desktop port: no Wi-Fi events on the host, so the event loop is a stub. The base macros let the vendored
* esp_http_server declare its (unused) event base. */
#pragma once
#include <stddef.h>
#include <stdint.h>
#include "esp_err.h"
typedef const char *esp_event_base_t;
typedef void (*esp_event_handler_t)(void *handler_arg, esp_event_base_t base, int32_t id, void *event_data);
#define ESP_EVENT_DECLARE_BASE(id) extern const esp_event_base_t id
#define ESP_EVENT_DEFINE_BASE(id) const esp_event_base_t id = #id
#define ESP_EVENT_ANY_ID (-1)
#define portMAX_DELAY_EVENT 0xFFFFFFFFu
esp_err_t esp_event_loop_create_default(void);
esp_err_t esp_event_post(esp_event_base_t base, int32_t id, const void *data, size_t data_size, uint32_t ticks);
+3
View File
@@ -0,0 +1,3 @@
#pragma once
#include "esp_event.h"
+27
View File
@@ -0,0 +1,27 @@
/* Desktop port: there is one heap, so the capability flags are accepted and ignored */
#pragma once
#include <stddef.h>
#include <stdlib.h>
#define MALLOC_CAP_8BIT (1u << 2)
#define MALLOC_CAP_SPIRAM (1u << 10)
#define MALLOC_CAP_INTERNAL (1u << 11)
#define MALLOC_CAP_DEFAULT (1u << 12)
static inline void *heap_caps_malloc(size_t size, unsigned caps)
{
(void)caps;
return malloc(size);
}
static inline void *heap_caps_calloc(size_t n, size_t size, unsigned caps)
{
(void)caps;
return calloc(n, size);
}
static inline void heap_caps_free(void *p)
{
free(p);
}
+32
View File
@@ -0,0 +1,32 @@
/* Desktop port of ESP-IDF's logging: lines go to stderr with the same level letters and tags. */
#pragma once
#include <stdarg.h>
#include <stdint.h>
typedef enum {
ESP_LOG_NONE,
ESP_LOG_ERROR,
ESP_LOG_WARN,
ESP_LOG_INFO,
ESP_LOG_DEBUG,
ESP_LOG_VERBOSE
} esp_log_level_t;
typedef int (*vprintf_like_t)(const char *, va_list);
void esp_log_write(esp_log_level_t level, const char *tag, const char *fmt, ...) __attribute__((format(printf, 3, 4)));
void esp_log_level_set(const char *tag, esp_log_level_t level);
vprintf_like_t esp_log_set_vprintf(vprintf_like_t fn);
uint32_t esp_log_timestamp(void);
#define ESP_LOGE(tag, fmt, ...) esp_log_write(ESP_LOG_ERROR, tag, fmt, ##__VA_ARGS__)
#define ESP_LOGW(tag, fmt, ...) esp_log_write(ESP_LOG_WARN, tag, fmt, ##__VA_ARGS__)
#define ESP_LOGI(tag, fmt, ...) esp_log_write(ESP_LOG_INFO, tag, fmt, ##__VA_ARGS__)
#define ESP_LOGD(tag, fmt, ...) esp_log_write(ESP_LOG_DEBUG, tag, fmt, ##__VA_ARGS__)
#define ESP_LOGV(tag, fmt, ...) esp_log_write(ESP_LOG_VERBOSE, tag, fmt, ##__VA_ARGS__)
#define ESP_EARLY_LOGE(tag, fmt, ...) ESP_LOGE(tag, fmt, ##__VA_ARGS__)
#define ESP_EARLY_LOGW(tag, fmt, ...) ESP_LOGW(tag, fmt, ##__VA_ARGS__)
#define ESP_EARLY_LOGI(tag, fmt, ...) ESP_LOGI(tag, fmt, ##__VA_ARGS__)
#define ESP_EARLY_LOGD(tag, fmt, ...) ESP_LOGD(tag, fmt, ##__VA_ARGS__)
#define ESP_EARLY_LOGV(tag, fmt, ...) ESP_LOGV(tag, fmt, ##__VA_ARGS__)
+14
View File
@@ -0,0 +1,14 @@
/* Desktop port: the device MAC is the first real network interface's, so it is stable across runs */
#pragma once
#include <stdint.h>
#include "esp_err.h"
typedef enum {
ESP_MAC_WIFI_STA,
ESP_MAC_WIFI_SOFTAP,
ESP_MAC_BT,
ESP_MAC_ETH,
} esp_mac_type_t;
esp_err_t esp_read_mac(uint8_t mac[6], esp_mac_type_t type);
+24
View File
@@ -0,0 +1,24 @@
/* Desktop stand-in for ESP-IDF's esp_netif_ip_addr.h: the IPv4 address types the app uses. */
#pragma once
#include <stdint.h>
typedef struct {
uint32_t addr; /* network byte order, as the bytes sit in memory */
} esp_ip4_addr_t;
typedef enum {
ESP_IPADDR_TYPE_V4 = 0,
ESP_IPADDR_TYPE_V6 = 6,
ESP_IPADDR_TYPE_ANY = 46,
} esp_ip_addr_type_t;
typedef struct {
esp_ip_addr_type_t type;
union {
esp_ip4_addr_t ip4;
} u_addr;
} esp_ip_addr_t;
#define IPSTR "%d.%d.%d.%d"
#define IP2STR(p) ((const uint8_t *)(p))[0], ((const uint8_t *)(p))[1], ((const uint8_t *)(p))[2], ((const uint8_t *)(p))[3]
+7
View File
@@ -0,0 +1,7 @@
#pragma once
#include <stddef.h>
#include <stdint.h>
uint32_t esp_random(void);
void esp_fill_random(void *buf, size_t len);
+5
View File
@@ -0,0 +1,5 @@
#pragma once
#include <stdint.h>
void esp_rom_delay_us(uint32_t us);
+9
View File
@@ -0,0 +1,9 @@
#pragma once
#include <stdint.h>
#include "esp_err.h"
// Desktop: restart means exit, and systemd (or the user's shell) starts the program again
void esp_restart(void) __attribute__((noreturn));
uint32_t esp_get_free_heap_size(void);
uint32_t esp_get_minimum_free_heap_size(void);
+27
View File
@@ -0,0 +1,27 @@
/* Desktop port: esp_timer on the host clock (implemented in sim-controller/components/sim/sim_timer.c) */
#pragma once
#include <stdbool.h>
#include <stdint.h>
#include "esp_err.h"
typedef void (*esp_timer_cb_t)(void *arg);
typedef enum { ESP_TIMER_TASK } esp_timer_dispatch_t;
typedef struct {
esp_timer_cb_t callback;
void *arg;
esp_timer_dispatch_t dispatch_method;
const char *name;
bool skip_unhandled_events;
} esp_timer_create_args_t;
struct esp_timer;
typedef struct esp_timer *esp_timer_handle_t;
int64_t esp_timer_get_time(void);
esp_err_t esp_timer_create(const esp_timer_create_args_t *args, esp_timer_handle_t *out);
esp_err_t esp_timer_start_once(esp_timer_handle_t t, uint64_t timeout_us);
esp_err_t esp_timer_start_periodic(esp_timer_handle_t t, uint64_t period);
esp_err_t esp_timer_stop(esp_timer_handle_t t);
bool esp_timer_is_active(esp_timer_handle_t t);
+22
View File
@@ -0,0 +1,22 @@
/* Desktop port: the FreeRTOS subset the firmware uses, on POSIX threads (desktop/port/src/freertos.c). */
#pragma once
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include "portmacro.h"
typedef int BaseType_t;
typedef unsigned int UBaseType_t;
typedef uint32_t TickType_t;
#define pdTRUE ((BaseType_t)1)
#define pdFALSE ((BaseType_t)0)
#define pdPASS pdTRUE
#define pdFAIL pdFALSE
#define portMAX_DELAY ((TickType_t)0xFFFFFFFFUL)
#define pdMS_TO_TICKS(ms) ((TickType_t)(ms)) /* a tick is 1 ms */
#define portTICK_PERIOD_MS ((TickType_t)1)
#define configTICK_RATE_HZ 1000
#define portYIELD_FROM_ISR(x) ((void)(x))
@@ -0,0 +1,13 @@
#pragma once
#include "FreeRTOS.h"
typedef struct desk_events *EventGroupHandle_t;
typedef uint32_t EventBits_t;
EventGroupHandle_t xEventGroupCreate(void);
void vEventGroupDelete(EventGroupHandle_t g);
EventBits_t xEventGroupSetBits(EventGroupHandle_t g, EventBits_t bits);
EventBits_t xEventGroupClearBits(EventGroupHandle_t g, EventBits_t bits);
EventBits_t xEventGroupWaitBits(EventGroupHandle_t g, EventBits_t bits, BaseType_t clear_on_exit,
BaseType_t wait_all, TickType_t ticks);
+16
View File
@@ -0,0 +1,16 @@
/* Desktop port: critical sections are one process-wide recursive lock (desktop/port/src/freertos.c). */
#pragma once
#include <stdint.h>
typedef struct {
int unused;
} portMUX_TYPE;
#define portMUX_INITIALIZER_UNLOCKED {0}
void desk_critical_enter(void);
void desk_critical_exit(void);
#define portENTER_CRITICAL(mux) ((void)(mux), desk_critical_enter())
#define portEXIT_CRITICAL(mux) ((void)(mux), desk_critical_exit())
#define taskENTER_CRITICAL() desk_critical_enter()
#define taskEXIT_CRITICAL() desk_critical_exit()
+12
View File
@@ -0,0 +1,12 @@
#pragma once
#include "FreeRTOS.h"
typedef struct desk_queue *QueueHandle_t;
QueueHandle_t xQueueCreate(UBaseType_t length, UBaseType_t item_size);
void vQueueDelete(QueueHandle_t q);
BaseType_t xQueueSend(QueueHandle_t q, const void *item, TickType_t ticks);
BaseType_t xQueueSendToBack(QueueHandle_t q, const void *item, TickType_t ticks);
BaseType_t xQueueReceive(QueueHandle_t q, void *item, TickType_t ticks);
UBaseType_t uxQueueMessagesWaiting(QueueHandle_t q);
+18
View File
@@ -0,0 +1,18 @@
#pragma once
#include "FreeRTOS.h"
typedef struct desk_sem *SemaphoreHandle_t;
SemaphoreHandle_t xSemaphoreCreateMutex(void);
SemaphoreHandle_t xSemaphoreCreateRecursiveMutex(void);
SemaphoreHandle_t xSemaphoreCreateBinary(void);
SemaphoreHandle_t xSemaphoreCreateCounting(UBaseType_t max, UBaseType_t initial);
void vSemaphoreDelete(SemaphoreHandle_t s);
BaseType_t xSemaphoreTake(SemaphoreHandle_t s, TickType_t ticks);
BaseType_t xSemaphoreTakeRecursive(SemaphoreHandle_t s, TickType_t ticks);
BaseType_t xSemaphoreGive(SemaphoreHandle_t s);
BaseType_t xSemaphoreGiveRecursive(SemaphoreHandle_t s);
BaseType_t xSemaphoreGiveFromISR(SemaphoreHandle_t s, BaseType_t *woken);
#define xSemaphoreTakeFromISR(s, w) xSemaphoreTake((s), 0)
@@ -0,0 +1,12 @@
#pragma once
#include "FreeRTOS.h"
typedef struct desk_stream *StreamBufferHandle_t;
StreamBufferHandle_t xStreamBufferCreate(size_t size, size_t trigger_level);
void vStreamBufferDelete(StreamBufferHandle_t sb);
size_t xStreamBufferSend(StreamBufferHandle_t sb, const void *data, size_t len, TickType_t ticks);
size_t xStreamBufferReceive(StreamBufferHandle_t sb, void *data, size_t len, TickType_t ticks);
BaseType_t xStreamBufferReset(StreamBufferHandle_t sb);
size_t xStreamBufferBytesAvailable(StreamBufferHandle_t sb);
+15
View File
@@ -0,0 +1,15 @@
#pragma once
#include "FreeRTOS.h"
#define tskIDLE_PRIORITY ((UBaseType_t)0)
#define tskNO_AFFINITY 0x7FFFFFFF
typedef struct desk_task *TaskHandle_t;
typedef void (*TaskFunction_t)(void *);
BaseType_t xTaskCreate(TaskFunction_t fn, const char *name, uint32_t stack_words, void *arg, UBaseType_t prio,
TaskHandle_t *handle);
void vTaskDelete(TaskHandle_t task);
void vTaskDelay(TickType_t ticks);
TaskHandle_t xTaskGetCurrentTaskHandle(void);
+34
View File
@@ -0,0 +1,34 @@
/* Desktop stand-in for ESP-IDF's mdns component: the query API the controller uses (wifi_drv.c).
* The browser is in port/src/mdns_host.c. */
#pragma once
#include <stddef.h>
#include <stdint.h>
#include "esp_err.h"
#include "esp_netif_ip_addr.h"
typedef struct {
char *key;
char *value;
} mdns_txt_item_t;
typedef struct mdns_ip_addr_s {
esp_ip_addr_t addr;
struct mdns_ip_addr_s *next;
} mdns_ip_addr_t;
typedef struct mdns_result_s {
struct mdns_result_s *next;
char *instance_name;
char *hostname; /* without the .local suffix */
mdns_txt_item_t *txt;
size_t txt_count;
mdns_ip_addr_t *addr;
} mdns_result_t;
/* Browse for service._proto.local (for example "_http", "_tcp") for timeout_ms. Results are IN_ADDR answers
* with their TXT items; free them with mdns_query_results_free. ESP_ERR_NOT_FOUND when nothing answered. */
esp_err_t mdns_query_ptr(const char *service, const char *proto, uint32_t timeout_ms, size_t max_results,
mdns_result_t **results);
void mdns_query_results_free(mdns_result_t *results);
+37
View File
@@ -0,0 +1,37 @@
/* Desktop port of the httpd thread wrappers (replaces ESP-IDF's src/port/esp32/osal.h) */
#pragma once
#include <stdint.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_err.h"
#define OS_SUCCESS ESP_OK
#define OS_FAIL ESP_FAIL
typedef TaskHandle_t othread_t;
static inline int httpd_os_thread_create(othread_t *thread, const char *name, uint16_t stacksize, int prio,
void (*thread_routine)(void *arg), void *arg, BaseType_t core_id,
uint32_t caps)
{
(void)core_id;
(void)caps;
return xTaskCreate(thread_routine, name, stacksize, arg, (UBaseType_t)prio, thread) == pdPASS ? OS_SUCCESS : OS_FAIL;
}
// Only the calling task can delete itself
static inline void httpd_os_thread_delete(void)
{
vTaskDelete(NULL);
}
static inline void httpd_os_thread_sleep(int msecs)
{
vTaskDelay(msecs / portTICK_PERIOD_MS);
}
static inline othread_t httpd_os_thread_handle(void)
{
return xTaskGetCurrentTaskHandle();
}
+403
View File
@@ -0,0 +1,403 @@
/*
* Automatically generated file. DO NOT EDIT.
* Espressif IoT Development Framework (ESP-IDF) 6.1.0 Configuration Header
*/
#pragma once
#define CONFIG_SOC_EFUSE_SUPPORTED 1
#define CONFIG_SOC_EFUSE_KEY_PURPOSE_FIELD 1
#define CONFIG_SOC_CPU_CORES_NUM 1
#define CONFIG_SOC_GPIO_IN_RANGE_MAX 65535
#define CONFIG_SOC_GPIO_OUT_RANGE_MAX 65535
#define CONFIG_SOC_I2C_SUPPORT_SLAVE 1
#define CONFIG_SOC_I2C_SUPPORT_10BIT_ADDR 1
#define CONFIG_SOC_EFUSE_DIS_DOWNLOAD_ICACHE 1
#define CONFIG_SOC_EFUSE_DIS_DOWNLOAD_DCACHE 1
#define CONFIG_SOC_EFUSE_HARD_DIS_JTAG 1
#define CONFIG_SOC_EFUSE_DIS_USB_JTAG 1
#define CONFIG_SOC_EFUSE_SOFT_DIS_JTAG 1
#define CONFIG_SOC_EFUSE_DIS_DIRECT_BOOT 1
#define CONFIG_SOC_EFUSE_DIS_ICACHE 1
#define CONFIG_SOC_SECURE_BOOT_V2_RSA 1
#define CONFIG_SOC_EFUSE_SECURE_BOOT_KEY_DIGESTS 3
#define CONFIG_SOC_EFUSE_REVOKE_BOOT_KEY_DIGESTS 1
#define CONFIG_SOC_SUPPORT_SECURE_BOOT_REVOKE_KEY 1
#define CONFIG_SOC_FLASH_ENCRYPTION_XTS_AES 1
#define CONFIG_SOC_FLASH_ENCRYPTION_XTS_AES_OPTIONS 1
#define CONFIG_SOC_FLASH_ENCRYPTION_XTS_AES_128 1
#define CONFIG_SOC_FLASH_ENCRYPTION_XTS_AES_256 1
#define CONFIG_IDF_CMAKE 1
#define CONFIG_IDF_TOOLCHAIN ""
#define CONFIG_IDF_TARGET "linux"
#define CONFIG_IDF_INIT_VERSION "5.5.5"
#define CONFIG_IDF_TARGET_LINUX 1
#define CONFIG_IDF_FIRMWARE_CHIP_ID 0xFFFF
#define CONFIG_APP_BUILD_TYPE_RAM 1
#define CONFIG_APP_BUILD_GENERATE_BINARIES 1
#define CONFIG_APP_COMPILE_TIME_DATE 1
#define CONFIG_APP_RETRIEVE_LEN_ELF_SHA 9
#define CONFIG_ESP_ROM_USB_OTG_NUM -1
#define CONFIG_ESP_ROM_USB_SERIAL_DEVICE_NUM -1
#define CONFIG_ESP_ROM_HAS_ETS_PRINTF_BUG 1
#define CONFIG_ESP_ROM_HAS_OUTPUT_PUTC_FUNC 1
#define CONFIG_ESP_ROM_BOOTLOADER_OFFSET_FLASH 0x0
#define CONFIG_BOOT_ROM_LOG_ALWAYS_ON 1
#define CONFIG_W5500_SPI_HOST 1
#define CONFIG_W5500_SPI_CLOCK_MHZ 10
#define CONFIG_W5500_SCLK_GPIO 7
#define CONFIG_W5500_MISO_GPIO 8
#define CONFIG_W5500_MOSI_GPIO 9
#define CONFIG_W5500_CS_GPIO 2
#define CONFIG_W5500_INT_GPIO 3
#define CONFIG_W5500_POLL_PERIOD_MS 10
#define CONFIG_W5500_RST_GPIO 1
#define CONFIG_MIC_SCK_GPIO 5
#define CONFIG_MIC_WS_GPIO 6
#define CONFIG_MIC_SD_GPIO 43
#define CONFIG_MIC_STREAM_GAIN 16
#define CONFIG_BEAT_LED_GPIO 21
#define CONFIG_BEAT_LED_ACTIVE_LOW 1
#define CONFIG_BEAT_LED_PULSE_MS 60
#define CONFIG_BEAT_LED_DOWNBEAT_MS 200
#define CONFIG_BEAT_GATE_DBFS -75
#define CONFIG_BEAT_LEAD_MS 30
#define CONFIG_AP_BUTTON_GPIO 44
#define CONFIG_AP_HOLD_MS 1000
#define CONFIG_ESPNOW_CHANNEL 5
#define CONFIG_BEAT_TX_COPIES 2
#define CONFIG_BEAT_TX_GAP_US 2000
#define CONFIG_BEAT_TEST_GPIO -1
#define CONFIG_BULK_HOLDOFF_US 3000
#define CONFIG_COMPILER_OPTIMIZATION_DEBUG 1
#define CONFIG_COMPILER_OPTIMIZATION_ASSERTIONS_ENABLE 1
#define CONFIG_COMPILER_ASSERT_NDEBUG_EVALUATE 1
#define CONFIG_COMPILER_FLOAT_LIB_FROM_GCCLIB 1
#define CONFIG_COMPILER_OPTIMIZATION_ASSERTION_LEVEL 2
#define CONFIG_COMPILER_HIDE_PATHS_MACROS 1
#define CONFIG_COMPILER_STACK_CHECK_MODE_NONE 1
#define CONFIG_COMPILER_DISABLE_DEFAULT_ERRORS 1
#define CONFIG_COMPILER_RT_LIB_HOST 1
#define CONFIG_COMPILER_RT_LIB_NAME ""
#define CONFIG_ESP_ERR_TO_NAME_LOOKUP 1
#define CONFIG_ESP_EVENT_POST_FROM_ISR 1
#define CONFIG_ESP_EVENT_POST_FROM_ISR_SIZE 4
#define CONFIG_ESP_EVENT_POST_FROM_IRAM_ISR 1
#define CONFIG_HTTPD_MAX_REQ_HDR_LEN 1024
#define CONFIG_HTTPD_MAX_URI_LEN 512
#define CONFIG_HTTPD_ERR_RESP_NO_DELAY 1
#define CONFIG_HTTPD_PURGE_BUF_LEN 32
#define CONFIG_HTTPD_WS_SUPPORT 1
#define CONFIG_HTTPD_ENABLE_EVENTS 1
#define CONFIG_HTTPD_SERVER_EVENT_POST_TIMEOUT 2000
#define CONFIG_HTTPD_WS_POST_HANDSHAKE_CB_SUPPORT 1
#define CONFIG_ESP_HW_SUPPORT_FUNC_IN_IRAM 1
#define CONFIG_ESP_REV_MIN_FULL 0
#define CONFIG_ESP_REV_MAX_FULL 999
#define CONFIG_ESP_EFUSE_BLOCK_REV_MIN_FULL 0
#define CONFIG_ESP_EFUSE_BLOCK_REV_MAX_FULL 999
#define CONFIG_ESP_SLEEP_FLASH_LEAKAGE_WORKAROUND 1
#define CONFIG_ESP_SLEEP_GPIO_RESET_WORKAROUND 1
#define CONFIG_ESP_SLEEP_WAIT_FLASH_READY_EXTRA_DELAY 0
#define CONFIG_ESP_SLEEP_GPIO_ENABLE_INTERNAL_RESISTORS 1
#define CONFIG_RTC_CLK_FUNC_IN_IRAM 1
#define CONFIG_RTC_TIME_FUNC_IN_IRAM 1
#define CONFIG_ESP_PERIPH_CTRL_FUNC_IN_IRAM 1
#define CONFIG_ESP_REGI2C_CTRL_FUNC_IN_IRAM 1
#define CONFIG_ESP_BRINGUP_BYPASS_CPU_CLK_SETTING 1
#define CONFIG_ESP_BRINGUP_BYPASS_RANDOM_SETTING 1
#define CONFIG_ESP_INTR_IN_IRAM 1
#define CONFIG_ESP_ROM_PRINT_IN_IRAM 1
#define CONFIG_ESP_CONSOLE_UART_DEFAULT 1
#define CONFIG_ESP_CONSOLE_UART 1
#define CONFIG_ESP_CONSOLE_UART_NUM 0
#define CONFIG_ESP_CONSOLE_ROM_SERIAL_PORT_NUM 0
#define CONFIG_ESP_CONSOLE_UART_BAUDRATE 115200
#define CONFIG_ESP_SYSTEM_IN_IRAM 1
#define CONFIG_ESP_SYSTEM_PANIC_PRINT_REBOOT 1
#define CONFIG_ESP_SYSTEM_PANIC_REBOOT_DELAY_SECONDS 0
#define CONFIG_ESP_SYSTEM_SINGLE_CORE_MODE 1
#define CONFIG_ESP_SYSTEM_EVENT_QUEUE_SIZE 32
#define CONFIG_ESP_SYSTEM_EVENT_TASK_STACK_SIZE 2304
#define CONFIG_ESP_MAIN_TASK_STACK_SIZE 3584
#define CONFIG_ESP_MAIN_TASK_AFFINITY_CPU0 1
#define CONFIG_ESP_MAIN_TASK_AFFINITY 0x0
#define CONFIG_ESP_MINIMAL_SHARED_STACK_SIZE 2048
#define CONFIG_ESP_DEBUG_OCDAWARE 1
#define CONFIG_ESP_SYSTEM_CHECK_INT_LEVEL_4 1
#define CONFIG_ESP_IPC_TASK_STACK_SIZE 1024
#define CONFIG_ESP_TIMER_IN_IRAM 1
#define CONFIG_ESP_TIMER_TASK_STACK_SIZE 3584
#define CONFIG_ESP_TIMER_INTERRUPT_LEVEL 1
#define CONFIG_ESP_TIMER_TASK_AFFINITY 0x0
#define CONFIG_ESP_TIMER_TASK_AFFINITY_CPU0 1
#define CONFIG_ESP_TIMER_ISR_AFFINITY_CPU0 1
#define CONFIG_ESP_TIMER_IMPL_SYSTIMER 1
#define CONFIG_FREERTOS_UNICORE 1
#define CONFIG_FREERTOS_HZ 1000
#define CONFIG_FREERTOS_OPTIMIZED_SCHEDULER 1
#define CONFIG_FREERTOS_CHECK_STACKOVERFLOW_CANARY 1
#define CONFIG_FREERTOS_THREAD_LOCAL_STORAGE_POINTERS 1
#define CONFIG_FREERTOS_IDLE_TASK_STACKSIZE 1536
#define CONFIG_FREERTOS_MAX_TASK_NAME_LEN 16
#define CONFIG_FREERTOS_USE_TIMERS 1
#define CONFIG_FREERTOS_TIMER_SERVICE_TASK_NAME "Tmr Svc"
#define CONFIG_FREERTOS_TIMER_TASK_NO_AFFINITY 1
#define CONFIG_FREERTOS_TIMER_SERVICE_TASK_CORE_AFFINITY 0x7FFFFFFF
#define CONFIG_FREERTOS_TIMER_TASK_PRIORITY 1
#define CONFIG_FREERTOS_TIMER_TASK_STACK_DEPTH 2053
#define CONFIG_FREERTOS_TIMER_QUEUE_LENGTH 10
#define CONFIG_FREERTOS_QUEUE_REGISTRY_SIZE 0
#define CONFIG_FREERTOS_TASK_NOTIFICATION_ARRAY_ENTRIES 1
#define CONFIG_FREERTOS_TASK_FUNCTION_WRAPPER 1
#define CONFIG_FREERTOS_TLSP_DELETION_CALLBACKS 1
#define CONFIG_FREERTOS_CHECK_MUTEX_GIVEN_BY_OWNER 1
#define CONFIG_FREERTOS_ISR_STACKSIZE 1536
#define CONFIG_FREERTOS_INTERRUPT_BACKTRACE 1
#define CONFIG_FREERTOS_TICK_SUPPORT_SYSTIMER 1
#define CONFIG_FREERTOS_CORETIMER_SYSTIMER_LVL1 1
#define CONFIG_FREERTOS_SYSTICK_USES_SYSTIMER 1
#define CONFIG_FREERTOS_IN_IRAM 1
#define CONFIG_FREERTOS_PORT 1
#define CONFIG_FREERTOS_NO_AFFINITY 0x7FFFFFFF
#define CONFIG_FREERTOS_SUPPORT_STATIC_ALLOCATION 1
#define CONFIG_FREERTOS_DEBUG_OCDAWARE 1
#define CONFIG_FREERTOS_NUMBER_OF_CORES 1
#define CONFIG_HAL_ASSERTION_EQUALS_SYSTEM 1
#define CONFIG_HAL_DEFAULT_ASSERTION_LEVEL 2
#define CONFIG_HAL_GPIO_USE_ROM_IMPL 1
#define CONFIG_HEAP_HAS_EXEC_HEAP 1
#define CONFIG_HEAP_POISONING_DISABLED 1
#define CONFIG_HEAP_TRACING_OFF 1
#define CONFIG_LOG_VERSION_1 1
#define CONFIG_LOG_VERSION 1
#define CONFIG_LOG_DEFAULT_LEVEL_INFO 1
#define CONFIG_LOG_DEFAULT_LEVEL 3
#define CONFIG_LOG_MAXIMUM_EQUALS_DEFAULT 1
#define CONFIG_LOG_MAXIMUM_LEVEL 3
#define CONFIG_LOG_DYNAMIC_LEVEL_CONTROL 1
#define CONFIG_LOG_TAG_LEVEL_IMPL_CACHE_AND_LINKED_LIST 1
#define CONFIG_LOG_TAG_LEVEL_CACHE_BINARY_MIN_HEAP 1
#define CONFIG_LOG_TAG_LEVEL_IMPL_CACHE_SIZE 31
#define CONFIG_LOG_TIMESTAMP_SOURCE_RTOS 1
#define CONFIG_LOG_MODE_TEXT_EN 1
#define CONFIG_LOG_MODE_TEXT 1
#define CONFIG_LOG_IN_IRAM 1
#define CONFIG_LWIP_LOCAL_HOSTNAME "espressif"
#define CONFIG_LWIP_TCPIP_TASK_PRIO 18
#define CONFIG_LWIP_DNS_SUPPORT_MDNS_QUERIES 1
#define CONFIG_LWIP_TIMERS_ONDEMAND 1
#define CONFIG_LWIP_ND6 1
#define CONFIG_LWIP_MAX_SOCKETS 60
#define CONFIG_LWIP_SO_REUSE 1
#define CONFIG_LWIP_SO_REUSE_RXTOALL 1
#define CONFIG_LWIP_IP_DEFAULT_TTL 64
#define CONFIG_LWIP_IP4_FRAG 1
#define CONFIG_LWIP_IP6_FRAG 1
#define CONFIG_LWIP_IP_REASS_MAX_PBUFS 10
#define CONFIG_LWIP_IPV6_DUP_DETECT_ATTEMPTS 1
#define CONFIG_LWIP_ESP_GRATUITOUS_ARP 1
#define CONFIG_LWIP_GARP_TMR_INTERVAL 60
#define CONFIG_LWIP_ESP_MLDV6_REPORT 1
#define CONFIG_LWIP_MLDV6_TMR_INTERVAL 40
#define CONFIG_LWIP_TCPIP_RECVMBOX_SIZE 32
#define CONFIG_LWIP_DHCP_DOES_ARP_CHECK 1
#define CONFIG_LWIP_DHCP_DISABLE_VENDOR_CLASS_ID 1
#define CONFIG_LWIP_DHCP_OPTIONS_LEN 69
#define CONFIG_LWIP_NUM_NETIF_CLIENT_DATA 0
#define CONFIG_LWIP_DHCP_COARSE_TIMER_SECS 1
#define CONFIG_LWIP_DHCPS 1
#define CONFIG_LWIP_DHCPS_REPORT_CLIENT_HOSTNAME 1
#define CONFIG_LWIP_DHCPS_LEASE_UNIT 60
#define CONFIG_LWIP_DHCPS_MAX_STATION_NUM 8
#define CONFIG_LWIP_DHCPS_MAX_HOSTNAME_LEN 64
#define CONFIG_LWIP_DHCPS_STATIC_ENTRIES 1
#define CONFIG_LWIP_IPV4 1
#define CONFIG_LWIP_IPV6 1
#define CONFIG_LWIP_IPV6_NUM_ADDRESSES 3
#define CONFIG_LWIP_NETIF_LOOPBACK 1
#define CONFIG_LWIP_LOOPBACK_MAX_PBUFS 8
#define CONFIG_LWIP_MAX_ACTIVE_TCP 16
#define CONFIG_LWIP_MAX_LISTENING_TCP 16
#define CONFIG_LWIP_TCP_HIGH_SPEED_RETRANSMISSION 1
#define CONFIG_LWIP_TCP_MAXRTX 12
#define CONFIG_LWIP_TCP_SYNMAXRTX 12
#define CONFIG_LWIP_TCP_MSS 1440
#define CONFIG_LWIP_TCP_TMR_INTERVAL 250
#define CONFIG_LWIP_TCP_MSL 60000
#define CONFIG_LWIP_TCP_FIN_WAIT_TIMEOUT 20000
#define CONFIG_LWIP_TCP_SND_BUF_DEFAULT 5760
#define CONFIG_LWIP_TCP_WND_DEFAULT 5760
#define CONFIG_LWIP_TCP_RECVMBOX_SIZE 6
#define CONFIG_LWIP_TCP_ACCEPTMBOX_SIZE 6
#define CONFIG_LWIP_TCP_QUEUE_OOSEQ 1
#define CONFIG_LWIP_TCP_OOSEQ_TIMEOUT 6
#define CONFIG_LWIP_TCP_OOSEQ_MAX_PBUFS 4
#define CONFIG_LWIP_TCP_OVERSIZE_MSS 1
#define CONFIG_LWIP_TCP_RTO_TIME 1500
#define CONFIG_LWIP_MAX_UDP_PCBS 16
#define CONFIG_LWIP_UDP_RECVMBOX_SIZE 6
#define CONFIG_LWIP_CHECKSUM_CHECK_ICMP 1
#define CONFIG_LWIP_TCPIP_TASK_STACK_SIZE 3072
#define CONFIG_LWIP_TCPIP_TASK_AFFINITY_NO_AFFINITY 1
#define CONFIG_LWIP_TCPIP_TASK_AFFINITY 0x7FFFFFFF
#define CONFIG_LWIP_IPV6_MEMP_NUM_ND6_QUEUE 3
#define CONFIG_LWIP_IPV6_ND6_NUM_NEIGHBORS 5
#define CONFIG_LWIP_IPV6_ND6_NUM_PREFIXES 5
#define CONFIG_LWIP_IPV6_ND6_NUM_ROUTERS 3
#define CONFIG_LWIP_IPV6_ND6_NUM_DESTINATIONS 10
#define CONFIG_LWIP_ICMP 1
#define CONFIG_LWIP_MAX_RAW_PCBS 16
#define CONFIG_LWIP_SNTP_MAX_SERVERS 1
#define CONFIG_LWIP_SNTP_UPDATE_DELAY 3600000
#define CONFIG_LWIP_SNTP_STARTUP_DELAY 1
#define CONFIG_LWIP_SNTP_MAXIMUM_STARTUP_DELAY 5000
#define CONFIG_LWIP_DNS_MAX_HOST_IP 1
#define CONFIG_LWIP_DNS_MAX_SERVERS 3
#define CONFIG_LWIP_BRIDGEIF_MAX_PORTS 7
#define CONFIG_LWIP_ESP_LWIP_ASSERT 1
#define CONFIG_LWIP_HOOK_TCP_ISN_DEFAULT 1
#define CONFIG_LWIP_HOOK_IP6_ROUTE_NONE 1
#define CONFIG_LWIP_HOOK_ND6_GET_GW_NONE 1
#define CONFIG_LWIP_HOOK_IP6_SELECT_SRC_ADDR_NONE 1
#define CONFIG_LWIP_HOOK_DHCP_EXTRA_OPTION_NONE 1
#define CONFIG_LWIP_HOOK_NETCONN_EXT_RESOLVE_NONE 1
#define CONFIG_LWIP_HOOK_DNS_EXT_RESOLVE_NONE 1
#define CONFIG_LWIP_HOOK_IP6_INPUT_DEFAULT 1
#define CONFIG_MBEDTLS_VER_4_X_SUPPORT 1
#define CONFIG_MBEDTLS_COMPILER_OPTIMIZATION_SIZE 1
#define CONFIG_MBEDTLS_FS_IO 1
#define CONFIG_MBEDTLS_ERROR_STRINGS 1
#define CONFIG_MBEDTLS_VERSION_C 1
#define CONFIG_MBEDTLS_HAVE_TIME 1
#define CONFIG_MBEDTLS_INTERNAL_MEM_ALLOC 1
#define CONFIG_MBEDTLS_ASYMMETRIC_CONTENT_LEN 1
#define CONFIG_MBEDTLS_SSL_IN_CONTENT_LEN 16384
#define CONFIG_MBEDTLS_SSL_OUT_CONTENT_LEN 4096
#define CONFIG_MBEDTLS_SELF_TEST 1
#define CONFIG_MBEDTLS_X509_USE_C 1
#define CONFIG_MBEDTLS_PEM_PARSE_C 1
#define CONFIG_MBEDTLS_PEM_WRITE_C 1
#define CONFIG_MBEDTLS_PK_C 1
#define CONFIG_MBEDTLS_PK_PARSE_C 1
#define CONFIG_MBEDTLS_PK_WRITE_C 1
#define CONFIG_MBEDTLS_X509_CRL_PARSE_C 1
#define CONFIG_MBEDTLS_X509_CRT_PARSE_C 1
#define CONFIG_MBEDTLS_X509_CSR_PARSE_C 1
#define CONFIG_MBEDTLS_X509_RSASSA_PSS_SUPPORT 1
#define CONFIG_MBEDTLS_ASN1_PARSE_C 1
#define CONFIG_MBEDTLS_ASN1_WRITE_C 1
#define CONFIG_MBEDTLS_CERTIFICATE_BUNDLE 1
#define CONFIG_MBEDTLS_CERTIFICATE_BUNDLE_DEFAULT_FULL 1
#define CONFIG_MBEDTLS_CERTIFICATE_BUNDLE_MAX_CERTS 200
#define CONFIG_MBEDTLS_TLS_ENABLED 1
#define CONFIG_MBEDTLS_SSL_PROTO_TLS1_2 1
#define CONFIG_MBEDTLS_TLS_SERVER 1
#define CONFIG_MBEDTLS_TLS_CLIENT 1
#define CONFIG_MBEDTLS_TLS_SERVER_AND_CLIENT 1
#define CONFIG_MBEDTLS_SSL_KEEP_PEER_CERTIFICATE 1
#define CONFIG_MBEDTLS_SSL_CACHE_C 1
#define CONFIG_MBEDTLS_SSL_ALL_ALERT_MESSAGES 1
#define CONFIG_MBEDTLS_KEY_EXCHANGE_RSA 1
#define CONFIG_MBEDTLS_KEY_EXCHANGE_ELLIPTIC_CURVE 1
#define CONFIG_MBEDTLS_KEY_EXCHANGE_ECDHE_RSA 1
#define CONFIG_MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA 1
#define CONFIG_MBEDTLS_SSL_SERVER_NAME_INDICATION 1
#define CONFIG_MBEDTLS_SSL_ALPN 1
#define CONFIG_MBEDTLS_SSL_MAX_FRAGMENT_LENGTH 1
#define CONFIG_MBEDTLS_SSL_RENEGOTIATION 1
#define CONFIG_MBEDTLS_CLIENT_SSL_SESSION_TICKETS 1
#define CONFIG_MBEDTLS_SERVER_SSL_SESSION_TICKETS 1
#define CONFIG_MBEDTLS_AES_C 1
#define CONFIG_MBEDTLS_CCM_C 1
#define CONFIG_MBEDTLS_CIPHER_MODE_CBC 1
#define CONFIG_MBEDTLS_CIPHER_MODE_CFB 1
#define CONFIG_MBEDTLS_CIPHER_MODE_CTR 1
#define CONFIG_MBEDTLS_CIPHER_MODE_OFB 1
#define CONFIG_MBEDTLS_CIPHER_MODE_XTS 1
#define CONFIG_MBEDTLS_GCM_C 1
#define CONFIG_MBEDTLS_AES_ROM_TABLES 1
#define CONFIG_MBEDTLS_RSA_C 1
#define CONFIG_MBEDTLS_ECP_C 1
#define CONFIG_MBEDTLS_ECP_DP_SECP256R1_ENABLED 1
#define CONFIG_MBEDTLS_ECP_DP_SECP384R1_ENABLED 1
#define CONFIG_MBEDTLS_ECP_DP_SECP521R1_ENABLED 1
#define CONFIG_MBEDTLS_ECP_DP_SECP256K1_ENABLED 1
#define CONFIG_MBEDTLS_ECP_DP_BP256R1_ENABLED 1
#define CONFIG_MBEDTLS_ECP_DP_BP384R1_ENABLED 1
#define CONFIG_MBEDTLS_ECP_DP_BP512R1_ENABLED 1
#define CONFIG_MBEDTLS_ECP_DP_CURVE25519_ENABLED 1
#define CONFIG_MBEDTLS_ECP_NIST_OPTIM 1
#define CONFIG_MBEDTLS_ECDH_C 1
#define CONFIG_MBEDTLS_ECDSA_C 1
#define CONFIG_MBEDTLS_PK_PARSE_EC_EXTENDED 1
#define CONFIG_MBEDTLS_PK_PARSE_EC_COMPRESSED 1
#define CONFIG_MBEDTLS_ECDSA_DETERMINISTIC 1
#define CONFIG_MBEDTLS_MD_C 1
#define CONFIG_MBEDTLS_MD5_C 1
#define CONFIG_MBEDTLS_SHA1_C 1
#define CONFIG_MBEDTLS_SHA256_C 1
#define CONFIG_MBEDTLS_SHA384_C 1
#define CONFIG_MBEDTLS_SHA512_C 1
#define CONFIG_MBEDTLS_ROM_MD5 1
#define CONFIG_MBEDTLS_CTR_DRBG_C 1
#define CONFIG_MBEDTLS_HMAC_DRBG_C 1
#define CONFIG_MBEDTLS_BASE64_C 1
#define CONFIG_MBEDTLS_PKCS5_C 1
#define CONFIG_MBEDTLS_PKCS7_C 1
#define CONFIG_MBEDTLS_PKCS1_V15 1
#define CONFIG_MBEDTLS_PKCS1_V21 1
#define CONFIG_MMU_PAGE_SIZE_64KB 1
#define CONFIG_MMU_PAGE_MODE "64KB"
#define CONFIG_MMU_PAGE_SIZE 0x10000
#define CONFIG_SPI_FLASH_BROWNOUT_RESET_XMC 1
#define CONFIG_SPI_FLASH_BROWNOUT_RESET 1
#define CONFIG_SPI_FLASH_SUSPEND_TSUS_VAL_US 50
#define CONFIG_SPI_FLASH_PLACE_FUNCTIONS_IN_IRAM 1
#define CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED 1
#define CONFIG_SPI_FLASH_YIELD_DURING_ERASE 1
#define CONFIG_SPI_FLASH_ERASE_YIELD_DURATION_MS 20
#define CONFIG_SPI_FLASH_ERASE_YIELD_TICKS 1
#define CONFIG_SPI_FLASH_WRITE_CHUNK_SIZE 8192
#define CONFIG_SPI_FLASH_ENABLE_ENCRYPTED_READ_WRITE 1
#define CONFIG_CJSON_NESTING_LIMIT 1000
#define CONFIG_CJSON_CIRCULAR_LIMIT 10000
/* List of deprecated options */
#define CONFIG_APP_BUILD_TYPE_ELF_RAM CONFIG_APP_BUILD_TYPE_RAM
#define CONFIG_COMPILER_OPTIMIZATION_DEFAULT CONFIG_COMPILER_OPTIMIZATION_DEBUG
#define CONFIG_COMPILER_OPTIMIZATION_LEVEL_DEBUG CONFIG_COMPILER_OPTIMIZATION_DEBUG
#define CONFIG_CONSOLE_UART CONFIG_ESP_CONSOLE_UART
#define CONFIG_CONSOLE_UART_BAUDRATE CONFIG_ESP_CONSOLE_UART_BAUDRATE
#define CONFIG_CONSOLE_UART_DEFAULT CONFIG_ESP_CONSOLE_UART_DEFAULT
#define CONFIG_CONSOLE_UART_NUM CONFIG_ESP_CONSOLE_UART_NUM
#define CONFIG_ESP_GRATUITOUS_ARP CONFIG_LWIP_ESP_GRATUITOUS_ARP
#define CONFIG_GARP_TMR_INTERVAL CONFIG_LWIP_GARP_TMR_INTERVAL
#define CONFIG_IPC_TASK_STACK_SIZE CONFIG_ESP_IPC_TASK_STACK_SIZE
#define CONFIG_MAIN_TASK_STACK_SIZE CONFIG_ESP_MAIN_TASK_STACK_SIZE
#define CONFIG_OPTIMIZATION_ASSERTIONS_ENABLED CONFIG_COMPILER_OPTIMIZATION_ASSERTIONS_ENABLE
#define CONFIG_OPTIMIZATION_ASSERTION_LEVEL CONFIG_COMPILER_OPTIMIZATION_ASSERTION_LEVEL
#define CONFIG_OPTIMIZATION_LEVEL_DEBUG CONFIG_COMPILER_OPTIMIZATION_DEBUG
#define CONFIG_PERIPH_CTRL_FUNC_IN_IRAM CONFIG_ESP_PERIPH_CTRL_FUNC_IN_IRAM
#define CONFIG_POST_EVENTS_FROM_IRAM_ISR CONFIG_ESP_EVENT_POST_FROM_IRAM_ISR
#define CONFIG_POST_EVENTS_FROM_ISR CONFIG_ESP_EVENT_POST_FROM_ISR
#define CONFIG_SPI_FLASH_WRITING_DANGEROUS_REGIONS_ALLOWED CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED
#define CONFIG_STACK_CHECK_NONE CONFIG_COMPILER_STACK_CHECK_MODE_NONE
#define CONFIG_SYSTEM_EVENT_QUEUE_SIZE CONFIG_ESP_SYSTEM_EVENT_QUEUE_SIZE
#define CONFIG_SYSTEM_EVENT_TASK_STACK_SIZE CONFIG_ESP_SYSTEM_EVENT_TASK_STACK_SIZE
#define CONFIG_TCPIP_RECVMBOX_SIZE CONFIG_LWIP_TCPIP_RECVMBOX_SIZE
#define CONFIG_TCPIP_TASK_AFFINITY CONFIG_LWIP_TCPIP_TASK_AFFINITY
#define CONFIG_TCPIP_TASK_AFFINITY_NO_AFFINITY CONFIG_LWIP_TCPIP_TASK_AFFINITY_NO_AFFINITY
#define CONFIG_TCPIP_TASK_STACK_SIZE CONFIG_LWIP_TCPIP_TASK_STACK_SIZE
#define CONFIG_TCP_MAXRTX CONFIG_LWIP_TCP_MAXRTX
#define CONFIG_TCP_MSL CONFIG_LWIP_TCP_MSL
#define CONFIG_TCP_MSS CONFIG_LWIP_TCP_MSS
#define CONFIG_TCP_OVERSIZE_MSS CONFIG_LWIP_TCP_OVERSIZE_MSS
#define CONFIG_TCP_QUEUE_OOSEQ CONFIG_LWIP_TCP_QUEUE_OOSEQ
#define CONFIG_TCP_RECVMBOX_SIZE CONFIG_LWIP_TCP_RECVMBOX_SIZE
#define CONFIG_TCP_SND_BUF_DEFAULT CONFIG_LWIP_TCP_SND_BUF_DEFAULT
#define CONFIG_TCP_SYNMAXRTX CONFIG_LWIP_TCP_SYNMAXRTX
#define CONFIG_TCP_WND_DEFAULT CONFIG_LWIP_TCP_WND_DEFAULT
#define CONFIG_TIMER_QUEUE_LENGTH CONFIG_FREERTOS_TIMER_QUEUE_LENGTH
#define CONFIG_TIMER_TASK_PRIORITY CONFIG_FREERTOS_TIMER_TASK_PRIORITY
#define CONFIG_TIMER_TASK_STACK_DEPTH CONFIG_FREERTOS_TIMER_TASK_STACK_DEPTH
#define CONFIG_TIMER_TASK_STACK_SIZE CONFIG_ESP_TIMER_TASK_STACK_SIZE
#define CONFIG_UDP_RECVMBOX_SIZE CONFIG_LWIP_UDP_RECVMBOX_SIZE
+91
View File
@@ -0,0 +1,91 @@
/* SHA-1 (FIPS 180-1) and base64 (RFC 4648) for the WebSocket handshake: no TLS library on the desktop */
#include "desktop_crypto.h"
#include <string.h>
static uint32_t rol(uint32_t v, int n)
{
return (v << n) | (v >> (32 - n));
}
static void sha1_block(uint32_t h[5], const uint8_t blk[64])
{
uint32_t w[80];
for (int i = 0; i < 16; i++) {
w[i] = ((uint32_t)blk[i * 4] << 24) | ((uint32_t)blk[i * 4 + 1] << 16) |
((uint32_t)blk[i * 4 + 2] << 8) | blk[i * 4 + 3];
}
for (int i = 16; i < 80; i++) {
w[i] = rol(w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16], 1);
}
uint32_t a = h[0], b = h[1], c = h[2], d = h[3], e = h[4];
for (int i = 0; i < 80; i++) {
uint32_t f, k;
if (i < 20) { f = (b & c) | (~b & d); k = 0x5A827999; }
else if (i < 40) { f = b ^ c ^ d; k = 0x6ED9EBA1; }
else if (i < 60) { f = (b & c) | (b & d) | (c & d); k = 0x8F1BBCDC; }
else { f = b ^ c ^ d; k = 0xCA62C1D6; }
uint32_t t = rol(a, 5) + f + e + k + w[i];
e = d;
d = c;
c = rol(b, 30);
b = a;
a = t;
}
h[0] += a;
h[1] += b;
h[2] += c;
h[3] += d;
h[4] += e;
}
void desktop_sha1(const uint8_t *data, size_t len, uint8_t out[20])
{
uint32_t h[5] = { 0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0 };
size_t i = 0;
for (; i + 64 <= len; i += 64) {
sha1_block(h, data + i);
}
// the tail: the rest, a 0x80 byte, zeros, and the message length in bits, in one or two blocks
uint8_t tail[128];
memset(tail, 0, sizeof(tail));
size_t rest = len - i;
memcpy(tail, data + i, rest);
tail[rest] = 0x80;
size_t tail_len = rest < 56 ? 64 : 128;
uint64_t bits = (uint64_t)len * 8;
for (int k = 0; k < 8; k++) {
tail[tail_len - 1 - k] = (uint8_t)(bits >> (8 * k));
}
sha1_block(h, tail);
if (tail_len == 128) {
sha1_block(h, tail + 64);
}
for (int k = 0; k < 5; k++) {
out[k * 4] = (uint8_t)(h[k] >> 24);
out[k * 4 + 1] = (uint8_t)(h[k] >> 16);
out[k * 4 + 2] = (uint8_t)(h[k] >> 8);
out[k * 4 + 3] = (uint8_t)h[k];
}
}
size_t desktop_base64_encode(char *out, size_t cap, const uint8_t *in, size_t n)
{
static const char tbl[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
size_t need = ((n + 2) / 3) * 4;
if (cap < need + 1) {
return 0;
}
size_t o = 0;
for (size_t i = 0; i < n; i += 3) {
uint32_t v = (uint32_t)in[i] << 16;
if (i + 1 < n) v |= (uint32_t)in[i + 1] << 8;
if (i + 2 < n) v |= in[i + 2];
out[o++] = tbl[(v >> 18) & 63];
out[o++] = tbl[(v >> 12) & 63];
out[o++] = (i + 1 < n) ? tbl[(v >> 6) & 63] : '=';
out[o++] = (i + 2 < n) ? tbl[v & 63] : '=';
}
out[o] = '\0';
return o;
}
+205
View File
@@ -0,0 +1,205 @@
/* Desktop port: the ESP-IDF runtime calls the firmware makes (logging, errors, random, MAC, restart) */
#define _GNU_SOURCE
#include <dirent.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/random.h>
#include <time.h>
#include <unistd.h>
#include "esp_app_desc.h"
#include "esp_err.h"
#include "esp_event.h"
#include "esp_log.h"
#include "esp_mac.h"
#include "esp_random.h"
#include "esp_rom_sys.h"
#include "esp_system.h"
#include "esp_timer.h"
#ifndef LED_APP_VERSION
#define LED_APP_VERSION "desktop"
#endif
static esp_log_level_t s_level = ESP_LOG_INFO;
static vprintf_like_t s_vprintf;
// LED_LOG_LEVEL=error|warn|info|debug|verbose (default info)
static void init_level(void)
{
static bool done;
if (done) return;
done = true;
const char *env = getenv("LED_LOG_LEVEL");
if (!env) return;
if (!strcmp(env, "error")) s_level = ESP_LOG_ERROR;
else if (!strcmp(env, "warn")) s_level = ESP_LOG_WARN;
else if (!strcmp(env, "debug")) s_level = ESP_LOG_DEBUG;
else if (!strcmp(env, "verbose")) s_level = ESP_LOG_VERBOSE;
else s_level = ESP_LOG_INFO;
}
void esp_log_level_set(const char *tag, esp_log_level_t level)
{
(void)tag;
s_level = level;
}
vprintf_like_t esp_log_set_vprintf(vprintf_like_t fn)
{
vprintf_like_t old = s_vprintf;
s_vprintf = fn;
return old;
}
uint32_t esp_log_timestamp(void)
{
return (uint32_t)(esp_timer_get_time() / 1000);
}
void esp_log_write(esp_log_level_t level, const char *tag, const char *fmt, ...)
{
init_level();
if (level > s_level) return;
static const char letters[] = " EWIDV";
char text[512];
va_list args;
va_start(args, fmt);
if (s_vprintf) {
// a hook (the bridge firmware's LOG frames) formats the line itself
s_vprintf(fmt, args);
va_end(args);
return;
}
vsnprintf(text, sizeof(text), fmt, args);
va_end(args);
fprintf(stderr, "%c (%u) %s: %s\n", letters[level], esp_log_timestamp(), tag, text);
}
const char *esp_err_to_name(esp_err_t code)
{
switch (code) {
case ESP_OK: return "ESP_OK";
case ESP_FAIL: return "ESP_FAIL";
case ESP_ERR_NO_MEM: return "ESP_ERR_NO_MEM";
case ESP_ERR_INVALID_ARG: return "ESP_ERR_INVALID_ARG";
case ESP_ERR_INVALID_STATE: return "ESP_ERR_INVALID_STATE";
case ESP_ERR_INVALID_SIZE: return "ESP_ERR_INVALID_SIZE";
case ESP_ERR_NOT_FOUND: return "ESP_ERR_NOT_FOUND";
case ESP_ERR_NOT_SUPPORTED: return "ESP_ERR_NOT_SUPPORTED";
case ESP_ERR_TIMEOUT: return "ESP_ERR_TIMEOUT";
case ESP_ERR_INVALID_RESPONSE: return "ESP_ERR_INVALID_RESPONSE";
case ESP_ERR_INVALID_CRC: return "ESP_ERR_INVALID_CRC";
case ESP_ERR_INVALID_VERSION: return "ESP_ERR_INVALID_VERSION";
case ESP_ERR_INVALID_MAC: return "ESP_ERR_INVALID_MAC";
case ESP_ERR_NOT_FINISHED: return "ESP_ERR_NOT_FINISHED";
default: return "ESP_ERR_UNKNOWN";
}
}
uint32_t esp_random(void)
{
uint32_t v = 0;
esp_fill_random(&v, sizeof(v));
return v;
}
void esp_fill_random(void *buf, size_t len)
{
uint8_t *p = buf;
while (len) {
ssize_t n = getrandom(p, len, 0);
if (n <= 0) {
// getrandom can be interrupted: fall back to the clock rather than returning zeros
for (size_t i = 0; i < len; i++) p[i] = (uint8_t)(esp_timer_get_time() >> (i % 8));
return;
}
p += n;
len -= (size_t)n;
}
}
void esp_rom_delay_us(uint32_t us)
{
usleep(us);
}
// The first real network interface's MAC (not loopback), so a driver keeps its identity across runs
esp_err_t esp_read_mac(uint8_t mac[6], esp_mac_type_t type)
{
(void)type;
DIR *d = opendir("/sys/class/net");
if (d) {
struct dirent *e;
char best[256] = "";
while ((e = readdir(d))) {
if (e->d_name[0] == '.' || !strcmp(e->d_name, "lo")) continue;
if (!best[0] || strcmp(e->d_name, best) < 0) snprintf(best, sizeof(best), "%s", e->d_name);
}
closedir(d);
if (best[0]) {
char path[320];
snprintf(path, sizeof(path), "/sys/class/net/%s/address", best);
FILE *f = fopen(path, "r");
if (f) {
unsigned v[6];
int n = fscanf(f, "%x:%x:%x:%x:%x:%x", &v[0], &v[1], &v[2], &v[3], &v[4], &v[5]);
fclose(f);
if (n == 6) {
for (int i = 0; i < 6; i++) mac[i] = (uint8_t)v[i];
return ESP_OK;
}
}
}
}
const uint8_t fallback[6] = { 0x02, 0x51, 0x4d, 0x00, 0x00, 0x01 }; // locally administered
memcpy(mac, fallback, 6);
return ESP_OK;
}
// On the desktop a restart is an exit: the service manager starts the program again
void esp_restart(void)
{
fprintf(stderr, "restart requested: exiting for the service manager to start us again\n");
fflush(stderr);
_exit(0);
}
uint32_t esp_get_free_heap_size(void)
{
return 64u * 1024u * 1024u; // the host heap is not limited the way the board's is
}
uint32_t esp_get_minimum_free_heap_size(void)
{
return esp_get_free_heap_size();
}
esp_err_t esp_event_loop_create_default(void)
{
return ESP_OK;
}
esp_err_t esp_event_post(esp_event_base_t base, int32_t id, const void *data, size_t data_size, uint32_t ticks)
{
(void)base;
(void)id;
(void)data;
(void)data_size;
(void)ticks;
return ESP_OK; // nobody listens on the desktop
}
const esp_app_desc_t *esp_app_get_description(void)
{
static esp_app_desc_t desc;
static bool init;
if (!init) {
init = true;
snprintf(desc.version, sizeof(desc.version), "%s", LED_APP_VERSION);
snprintf(desc.project_name, sizeof(desc.project_name), "led_controller_desktop");
snprintf(desc.idf_ver, sizeof(desc.idf_ver), "none");
}
return &desc;
}
+522
View File
@@ -0,0 +1,522 @@
/*
* Desktop port: the FreeRTOS calls the firmware makes, on POSIX threads.
* task a detached pthread; the handle is kept so a task can be named, and vTaskDelete(NULL) exits it
* queue a ring of fixed-size items, blocking send and receive with a deadline
* semaphore counting, binary and (recursive) mutex, with the owner and depth for recursive takes
* critical one process-wide recursive lock
* A tick is 1 ms. Timeouts are real: a blocked task sleeps in the kernel, so the others run.
*/
#define _GNU_SOURCE
#include <errno.h>
#include <pthread.h>
#include <sched.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include "freertos/FreeRTOS.h"
#include "freertos/event_groups.h"
#include "freertos/queue.h"
#include "freertos/semphr.h"
#include "freertos/stream_buffer.h"
#include "freertos/task.h"
static pthread_mutex_t s_crit = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
void desk_critical_enter(void)
{
pthread_mutex_lock(&s_crit);
}
void desk_critical_exit(void)
{
pthread_mutex_unlock(&s_crit);
}
// Absolute deadline for a timeout in ticks (ms), on the realtime clock
static void make_deadline(TickType_t ticks, struct timespec *dl)
{
clock_gettime(CLOCK_REALTIME, dl);
dl->tv_sec += ticks / 1000;
dl->tv_nsec += (long)(ticks % 1000) * 1000000L;
if (dl->tv_nsec >= 1000000000L) {
dl->tv_sec++;
dl->tv_nsec -= 1000000000L;
}
}
// Wait on c (with m held) until signalled. Returns 0 when signalled, ETIMEDOUT when the deadline passed.
// ticks == portMAX_DELAY waits without a deadline.
static int wait_on(pthread_cond_t *c, pthread_mutex_t *m, TickType_t ticks, const struct timespec *dl)
{
if (ticks == portMAX_DELAY) {
return pthread_cond_wait(c, m);
}
return pthread_cond_timedwait(c, m, dl);
}
/* ---- tasks ------------------------------------------------------------------------------------ */
struct desk_task {
pthread_t th;
char name[16];
TaskFunction_t fn;
void *arg;
};
static __thread struct desk_task *t_self;
static struct desk_task t_main = { .name = "main" };
static void *task_entry(void *p)
{
struct desk_task *t = p;
t_self = t;
t->fn(t->arg);
return NULL; // a FreeRTOS task must not return; here it ends its thread
}
BaseType_t xTaskCreate(TaskFunction_t fn, const char *name, uint32_t stack_words, void *arg, UBaseType_t prio,
TaskHandle_t *handle)
{
(void)prio; // scheduling is the host's
struct desk_task *t = calloc(1, sizeof(*t));
if (!t) {
return pdFAIL;
}
snprintf(t->name, sizeof(t->name), "%s", name ? name : "task");
t->fn = fn;
t->arg = arg;
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
size_t want = (size_t)stack_words * 16; // firmware stacks are in words; give the host plenty
if (want < (size_t)512 * 1024) {
want = (size_t)512 * 1024;
}
pthread_attr_setstacksize(&attr, want);
int err = pthread_create(&t->th, &attr, task_entry, t);
pthread_attr_destroy(&attr);
if (err != 0) {
free(t);
return pdFAIL;
}
if (handle) {
*handle = t;
}
return pdPASS;
}
void vTaskDelete(TaskHandle_t task)
{
if (task == NULL || task == t_self) {
pthread_exit(NULL); // self-delete: the thread ends, the handle is not reused
}
pthread_cancel(task->th);
}
void vTaskDelay(TickType_t ticks)
{
if (ticks == 0) {
sched_yield();
return;
}
struct timespec ts = { .tv_sec = ticks / 1000, .tv_nsec = (long)(ticks % 1000) * 1000000L };
while (nanosleep(&ts, &ts) != 0 && errno == EINTR) {
}
}
TaskHandle_t xTaskGetCurrentTaskHandle(void)
{
if (!t_self) {
t_self = &t_main;
}
return t_self;
}
/* ---- queues ----------------------------------------------------------------------------------- */
struct desk_queue {
pthread_mutex_t m;
pthread_cond_t not_empty;
pthread_cond_t not_full;
uint8_t *buf;
UBaseType_t len;
UBaseType_t item;
UBaseType_t head;
UBaseType_t count;
};
QueueHandle_t xQueueCreate(UBaseType_t length, UBaseType_t item_size)
{
QueueHandle_t q = calloc(1, sizeof(*q));
if (!q) {
return NULL;
}
q->buf = calloc(length ? length : 1, item_size ? item_size : 1);
if (!q->buf) {
free(q);
return NULL;
}
q->len = length;
q->item = item_size;
pthread_mutex_init(&q->m, NULL);
pthread_cond_init(&q->not_empty, NULL);
pthread_cond_init(&q->not_full, NULL);
return q;
}
void vQueueDelete(QueueHandle_t q)
{
if (!q) return;
pthread_mutex_destroy(&q->m);
pthread_cond_destroy(&q->not_empty);
pthread_cond_destroy(&q->not_full);
free(q->buf);
free(q);
}
static BaseType_t queue_send(QueueHandle_t q, const void *item, TickType_t ticks)
{
struct timespec dl;
if (ticks != portMAX_DELAY) make_deadline(ticks, &dl);
pthread_mutex_lock(&q->m);
while (q->count == q->len) {
if (ticks == 0 || wait_on(&q->not_full, &q->m, ticks, &dl) != 0) {
pthread_mutex_unlock(&q->m);
return pdFAIL;
}
}
UBaseType_t slot = (q->head + q->count) % q->len;
memcpy(q->buf + (size_t)slot * q->item, item, q->item);
q->count++;
pthread_cond_signal(&q->not_empty);
pthread_mutex_unlock(&q->m);
return pdTRUE;
}
BaseType_t xQueueSend(QueueHandle_t q, const void *item, TickType_t ticks)
{
return queue_send(q, item, ticks);
}
BaseType_t xQueueSendToBack(QueueHandle_t q, const void *item, TickType_t ticks)
{
return queue_send(q, item, ticks);
}
BaseType_t xQueueReceive(QueueHandle_t q, void *item, TickType_t ticks)
{
struct timespec dl;
if (ticks != portMAX_DELAY) make_deadline(ticks, &dl);
pthread_mutex_lock(&q->m);
while (q->count == 0) {
if (ticks == 0 || wait_on(&q->not_empty, &q->m, ticks, &dl) != 0) {
pthread_mutex_unlock(&q->m);
return pdFAIL;
}
}
memcpy(item, q->buf + (size_t)q->head * q->item, q->item);
q->head = (q->head + 1) % q->len;
q->count--;
pthread_cond_signal(&q->not_full);
pthread_mutex_unlock(&q->m);
return pdTRUE;
}
UBaseType_t uxQueueMessagesWaiting(QueueHandle_t q)
{
pthread_mutex_lock(&q->m);
UBaseType_t n = q->count;
pthread_mutex_unlock(&q->m);
return n;
}
/* ---- semaphores ------------------------------------------------------------------------------- */
struct desk_sem {
pthread_mutex_t m;
pthread_cond_t c;
UBaseType_t count; // free "tokens"
UBaseType_t max;
int recursive; // the owning task may take it again
pthread_t owner;
UBaseType_t depth; // takes by the owner not yet given back
};
static SemaphoreHandle_t sem_new(UBaseType_t init, UBaseType_t max, int recursive)
{
SemaphoreHandle_t s = calloc(1, sizeof(*s));
if (!s) return NULL;
s->count = init;
s->max = max;
s->recursive = recursive;
pthread_mutex_init(&s->m, NULL);
pthread_cond_init(&s->c, NULL);
return s;
}
SemaphoreHandle_t xSemaphoreCreateMutex(void)
{
return sem_new(1, 1, 0);
}
SemaphoreHandle_t xSemaphoreCreateRecursiveMutex(void)
{
return sem_new(1, 1, 1);
}
SemaphoreHandle_t xSemaphoreCreateBinary(void)
{
return sem_new(0, 1, 0);
}
SemaphoreHandle_t xSemaphoreCreateCounting(UBaseType_t max, UBaseType_t initial)
{
return sem_new(initial, max, 0);
}
void vSemaphoreDelete(SemaphoreHandle_t s)
{
if (!s) return;
pthread_mutex_destroy(&s->m);
pthread_cond_destroy(&s->c);
free(s);
}
static BaseType_t sem_take(SemaphoreHandle_t s, TickType_t ticks)
{
pthread_t me = pthread_self();
struct timespec dl;
if (ticks != portMAX_DELAY) make_deadline(ticks, &dl);
pthread_mutex_lock(&s->m);
if (s->recursive && s->depth > 0 && pthread_equal(s->owner, me)) {
s->depth++;
pthread_mutex_unlock(&s->m);
return pdTRUE;
}
while (s->count == 0) {
if (ticks == 0 || wait_on(&s->c, &s->m, ticks, &dl) != 0) {
pthread_mutex_unlock(&s->m);
return pdFAIL;
}
}
s->count--;
s->owner = me;
s->depth = 1;
pthread_mutex_unlock(&s->m);
return pdTRUE;
}
static BaseType_t sem_give(SemaphoreHandle_t s)
{
pthread_mutex_lock(&s->m);
if (s->recursive && s->depth > 1 && pthread_equal(s->owner, pthread_self())) {
s->depth--;
pthread_mutex_unlock(&s->m);
return pdTRUE;
}
if (s->count >= s->max) {
pthread_mutex_unlock(&s->m);
return pdFAIL;
}
s->count++;
s->depth = 0;
pthread_cond_signal(&s->c);
pthread_mutex_unlock(&s->m);
return pdTRUE;
}
BaseType_t xSemaphoreTake(SemaphoreHandle_t s, TickType_t ticks)
{
return sem_take(s, ticks);
}
BaseType_t xSemaphoreTakeRecursive(SemaphoreHandle_t s, TickType_t ticks)
{
return sem_take(s, ticks);
}
BaseType_t xSemaphoreGive(SemaphoreHandle_t s)
{
return sem_give(s);
}
BaseType_t xSemaphoreGiveRecursive(SemaphoreHandle_t s)
{
return sem_give(s);
}
BaseType_t xSemaphoreGiveFromISR(SemaphoreHandle_t s, BaseType_t *woken)
{
if (woken) *woken = pdFALSE;
return sem_give(s);
}
/* ---- stream buffers --------------------------------------------------------------------------- */
struct desk_stream {
pthread_mutex_t m;
pthread_cond_t not_empty;
pthread_cond_t not_full;
uint8_t *buf;
size_t cap;
size_t head;
size_t count;
};
StreamBufferHandle_t xStreamBufferCreate(size_t size, size_t trigger_level)
{
(void)trigger_level;
StreamBufferHandle_t sb = calloc(1, sizeof(*sb));
if (!sb) return NULL;
sb->buf = malloc(size ? size : 1);
if (!sb->buf) {
free(sb);
return NULL;
}
sb->cap = size;
pthread_mutex_init(&sb->m, NULL);
pthread_cond_init(&sb->not_empty, NULL);
pthread_cond_init(&sb->not_full, NULL);
return sb;
}
void vStreamBufferDelete(StreamBufferHandle_t sb)
{
if (!sb) return;
pthread_mutex_destroy(&sb->m);
pthread_cond_destroy(&sb->not_empty);
pthread_cond_destroy(&sb->not_full);
free(sb->buf);
free(sb);
}
size_t xStreamBufferSend(StreamBufferHandle_t sb, const void *data, size_t len, TickType_t ticks)
{
struct timespec dl;
if (ticks != portMAX_DELAY) make_deadline(ticks, &dl);
pthread_mutex_lock(&sb->m);
while (sb->count == sb->cap) {
if (ticks == 0 || wait_on(&sb->not_full, &sb->m, ticks, &dl) != 0) {
pthread_mutex_unlock(&sb->m);
return 0;
}
}
size_t room = sb->cap - sb->count;
size_t n = len < room ? len : room;
for (size_t i = 0; i < n; i++) {
sb->buf[(sb->head + sb->count + i) % sb->cap] = ((const uint8_t *)data)[i];
}
sb->count += n;
pthread_cond_signal(&sb->not_empty);
pthread_mutex_unlock(&sb->m);
return n;
}
size_t xStreamBufferReceive(StreamBufferHandle_t sb, void *data, size_t len, TickType_t ticks)
{
struct timespec dl;
if (ticks != portMAX_DELAY) make_deadline(ticks, &dl);
pthread_mutex_lock(&sb->m);
while (sb->count == 0) {
if (ticks == 0 || wait_on(&sb->not_empty, &sb->m, ticks, &dl) != 0) {
pthread_mutex_unlock(&sb->m);
return 0;
}
}
size_t n = len < sb->count ? len : sb->count;
for (size_t i = 0; i < n; i++) {
((uint8_t *)data)[i] = sb->buf[(sb->head + i) % sb->cap];
}
sb->head = (sb->head + n) % sb->cap;
sb->count -= n;
pthread_cond_signal(&sb->not_full);
pthread_mutex_unlock(&sb->m);
return n;
}
BaseType_t xStreamBufferReset(StreamBufferHandle_t sb)
{
pthread_mutex_lock(&sb->m);
sb->head = 0;
sb->count = 0;
pthread_cond_broadcast(&sb->not_full);
pthread_mutex_unlock(&sb->m);
return pdTRUE;
}
size_t xStreamBufferBytesAvailable(StreamBufferHandle_t sb)
{
pthread_mutex_lock(&sb->m);
size_t n = sb->count;
pthread_mutex_unlock(&sb->m);
return n;
}
/* ---- event groups ----------------------------------------------------------------------------- */
struct desk_events {
pthread_mutex_t m;
pthread_cond_t c;
EventBits_t bits;
};
EventGroupHandle_t xEventGroupCreate(void)
{
EventGroupHandle_t g = calloc(1, sizeof(*g));
if (!g) return NULL;
pthread_mutex_init(&g->m, NULL);
pthread_cond_init(&g->c, NULL);
return g;
}
void vEventGroupDelete(EventGroupHandle_t g)
{
if (!g) return;
pthread_mutex_destroy(&g->m);
pthread_cond_destroy(&g->c);
free(g);
}
EventBits_t xEventGroupSetBits(EventGroupHandle_t g, EventBits_t bits)
{
pthread_mutex_lock(&g->m);
g->bits |= bits;
EventBits_t now = g->bits;
pthread_cond_broadcast(&g->c);
pthread_mutex_unlock(&g->m);
return now;
}
EventBits_t xEventGroupClearBits(EventGroupHandle_t g, EventBits_t bits)
{
pthread_mutex_lock(&g->m);
g->bits &= ~bits;
EventBits_t now = g->bits;
pthread_mutex_unlock(&g->m);
return now;
}
EventBits_t xEventGroupWaitBits(EventGroupHandle_t g, EventBits_t bits, BaseType_t clear_on_exit,
BaseType_t wait_all, TickType_t ticks)
{
struct timespec dl;
if (ticks != portMAX_DELAY) make_deadline(ticks, &dl);
pthread_mutex_lock(&g->m);
for (;;) {
EventBits_t got = g->bits & bits;
bool ok = wait_all ? got == bits : got != 0;
if (ok) {
if (clear_on_exit) {
g->bits &= ~bits;
}
pthread_mutex_unlock(&g->m);
return got;
}
if (ticks == 0 || wait_on(&g->c, &g->m, ticks, &dl) != 0) {
EventBits_t now = g->bits;
pthread_mutex_unlock(&g->m);
return now;
}
}
}
+371
View File
@@ -0,0 +1,371 @@
/*
* Minimal mDNS browser for the desktop build, behind the ESP-IDF mdns API used by wifi_drv.c.
* It sends a PTR query for _service._proto.local from an ephemeral port, so responders answer unicast,
* then reads PTR, SRV, TXT and A answers until the timeout. Only the parts of RFC 6762/1035 these need.
*/
#include <arpa/inet.h>
#include <stdbool.h>
#include <netinet/in.h>
#include <poll.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <time.h>
#include <unistd.h>
#include "esp_err.h"
#include "esp_log.h"
#include "mdns.h"
#define MDNS_PORT 5353
#define MAX_RECS 64
#define NAME_MAX_LEN 256
typedef struct { char name[NAME_MAX_LEN]; char target[NAME_MAX_LEN]; } srv_rec_t;
typedef struct { char name[NAME_MAX_LEN]; char items[8][80]; int n; } txt_rec_t;
typedef struct { char name[NAME_MAX_LEN]; uint8_t ip[4]; } a_rec_t;
typedef struct { char name[NAME_MAX_LEN]; } ptr_rec_t;
typedef struct {
ptr_rec_t ptr[MAX_RECS];
int nptr;
srv_rec_t srv[MAX_RECS];
int nsrv;
txt_rec_t txt[MAX_RECS];
int ntxt;
a_rec_t a[MAX_RECS];
int na;
} browse_t;
static uint16_t rd16(const uint8_t *p)
{
return (uint16_t)((p[0] << 8) | p[1]);
}
/* Decode a (possibly compressed) name at off. Sets *next to the byte after the name in place. */
static bool decode_name(const uint8_t *m, size_t len, size_t off, char *out, size_t cap, size_t *next)
{
size_t o = off, n = 0, after = 0;
bool jumped = false;
int hops = 0;
out[0] = '\0';
for (;;) {
if (o >= len || ++hops > 64) {
return false;
}
uint8_t l = m[o];
if ((l & 0xC0) == 0xC0) {
if (o + 1 >= len) {
return false;
}
if (!jumped) {
after = o + 2;
}
jumped = true;
o = (size_t)(((l & 0x3F) << 8) | m[o + 1]);
continue;
}
if (l == 0) {
o++;
break;
}
if (l > 63 || o + 1 + l > len) {
return false;
}
if (n) {
if (n + 1 >= cap) {
return false;
}
out[n++] = '.';
}
if (n + l >= cap) {
return false;
}
memcpy(out + n, m + o + 1, l);
n += l;
o += 1 + l;
}
out[n] = '\0';
if (next) {
*next = jumped ? after : o;
}
return true;
}
static void add_ptr(browse_t *b, const char *name)
{
if (b->nptr < MAX_RECS) {
snprintf(b->ptr[b->nptr++].name, NAME_MAX_LEN, "%s", name);
}
}
static void handle_rr(browse_t *b, const uint8_t *m, size_t len, const char *name, uint16_t type, size_t rd, uint16_t rdlen)
{
char tmp[NAME_MAX_LEN];
switch (type) {
case 12: /* PTR */
if (decode_name(m, len, rd, tmp, sizeof(tmp), NULL)) {
if (!strcmp(name, "_http._tcp.local") && b->nptr < MAX_RECS) {
add_ptr(b, tmp);
}
}
break;
case 33: /* SRV: priority, weight, port, target */
if (rdlen > 6 && b->nsrv < MAX_RECS && decode_name(m, len, rd + 6, tmp, sizeof(tmp), NULL)) {
srv_rec_t *s = &b->srv[b->nsrv++];
snprintf(s->name, NAME_MAX_LEN, "%s", name);
snprintf(s->target, NAME_MAX_LEN, "%s", tmp);
}
break;
case 16: { /* TXT: length-prefixed strings */
if (b->ntxt >= MAX_RECS) {
break;
}
txt_rec_t *t = &b->txt[b->ntxt];
snprintf(t->name, NAME_MAX_LEN, "%s", name);
t->n = 0;
size_t p = rd, end = rd + rdlen;
while (p < end && t->n < 8) {
size_t l = m[p];
if (p + 1 + l > end) {
break;
}
size_t copy = l < sizeof(t->items[0]) - 1 ? l : sizeof(t->items[0]) - 1;
memcpy(t->items[t->n], m + p + 1, copy);
t->items[t->n][copy] = '\0';
t->n++;
p += 1 + l;
}
b->ntxt++;
break;
}
case 1: /* A */
if (rdlen == 4 && b->na < MAX_RECS) {
a_rec_t *a = &b->a[b->na++];
snprintf(a->name, NAME_MAX_LEN, "%s", name);
memcpy(a->ip, m + rd, 4);
}
break;
default:
break;
}
}
static void parse_packet(browse_t *b, const uint8_t *m, size_t len)
{
if (len < 12) {
return;
}
uint16_t qd = rd16(m + 4), an = rd16(m + 6), ns = rd16(m + 8), ar = rd16(m + 10);
size_t o = 12;
char name[NAME_MAX_LEN];
for (int i = 0; i < qd; i++) {
if (!decode_name(m, len, o, name, sizeof(name), &o) || o + 4 > len) {
return;
}
o += 4;
}
int total = an + ns + ar;
for (int i = 0; i < total; i++) {
if (!decode_name(m, len, o, name, sizeof(name), &o) || o + 10 > len) {
return;
}
uint16_t type = rd16(m + o);
uint16_t rdlen = rd16(m + o + 8);
size_t rd = o + 10;
if (rd + rdlen > len) {
return;
}
handle_rr(b, m, len, name, type, rd, rdlen);
o = rd + rdlen;
}
}
/* DNS query for PTR _service._proto.local */
static size_t build_query(uint8_t *buf, size_t cap, const char *name)
{
size_t o = 12;
memset(buf, 0, 12);
buf[5] = 1; /* one question */
const char *p = name;
while (*p) {
const char *dot = strchr(p, '.');
size_t l = dot ? (size_t)(dot - p) : strlen(p);
if (l == 0 || l > 63 || o + 1 + l + 6 > cap) {
return 0;
}
buf[o++] = (uint8_t)l;
memcpy(buf + o, p, l);
o += l;
if (!dot) {
break;
}
p = dot + 1;
}
buf[o++] = 0;
buf[o++] = 0; /* PTR */
buf[o++] = 12;
buf[o++] = 0; /* IN, not unicast-response */
buf[o++] = 1;
return o;
}
static char *mdns_dup(const char *s)
{
return strdup(s ? s : "");
}
esp_err_t mdns_query_ptr(const char *service, const char *proto, uint32_t timeout_ms, size_t max_results,
mdns_result_t **results)
{
*results = NULL;
char qname[160];
snprintf(qname, sizeof(qname), "%s.%s.local", service, proto); /* the caller gives "_http", "_tcp" */
/* the query is not sent to the app's own names, so the search is only for the given service */
uint8_t q[256];
size_t qlen = build_query(q, sizeof(q), qname);
if (!qlen) {
return ESP_ERR_INVALID_ARG;
}
int fd = socket(AF_INET, SOCK_DGRAM, 0);
if (fd < 0) {
return ESP_FAIL;
}
struct sockaddr_in dst = { .sin_family = AF_INET, .sin_port = htons(MDNS_PORT) };
inet_pton(AF_INET, "224.0.0.251", &dst.sin_addr);
browse_t *b = calloc(1, sizeof(*b));
if (!b) {
close(fd);
return ESP_ERR_NO_MEM;
}
struct timespec t0;
clock_gettime(CLOCK_MONOTONIC, &t0);
int64_t start = (int64_t)t0.tv_sec * 1000 + t0.tv_nsec / 1000000;
int64_t sent_at = -1000000;
uint8_t pkt[2048];
for (;;) {
struct timespec t;
clock_gettime(CLOCK_MONOTONIC, &t);
int64_t now = (int64_t)t.tv_sec * 1000 + t.tv_nsec / 1000000;
int64_t elapsed = now - start;
if (elapsed >= (int64_t)timeout_ms) {
break;
}
if (now - sent_at >= (int64_t)timeout_ms / 2 + 1 && elapsed < (int64_t)timeout_ms / 2) {
sendto(fd, q, qlen, 0, (struct sockaddr *)&dst, sizeof(dst)); /* a second query, for lost packets */
sent_at = now;
} else if (sent_at < 0) {
sendto(fd, q, qlen, 0, (struct sockaddr *)&dst, sizeof(dst));
sent_at = now;
}
struct pollfd pfd = { .fd = fd, .events = POLLIN };
int wait = (int)((int64_t)timeout_ms - elapsed);
if (wait > 100) {
wait = 100;
}
if (poll(&pfd, 1, wait) > 0 && (pfd.revents & POLLIN)) {
ssize_t n = recv(fd, pkt, sizeof(pkt), 0);
if (n > 0) {
parse_packet(b, pkt, (size_t)n);
}
}
}
close(fd);
/* Build one result per instance that has a PTR, an SRV and an A record for its target */
mdns_result_t *head = NULL, **tail = &head;
size_t count = 0;
for (int i = 0; i < b->nptr && count < max_results; i++) {
const char *inst = b->ptr[i].name;
const srv_rec_t *srv = NULL;
for (int k = 0; k < b->nsrv && !srv; k++) {
if (!strcmp(b->srv[k].name, inst)) {
srv = &b->srv[k];
}
}
if (!srv) {
continue;
}
mdns_result_t *r = calloc(1, sizeof(*r));
if (!r) {
break;
}
r->instance_name = mdns_dup(inst);
/* the SRV target is host.local: the hostname without the suffix */
char host[NAME_MAX_LEN];
snprintf(host, sizeof(host), "%s", srv->target);
size_t hl = strlen(host);
if (hl > 6 && !strcmp(host + hl - 6, ".local")) {
host[hl - 6] = '\0';
}
r->hostname = mdns_dup(host);
for (int k = 0; k < b->ntxt; k++) {
if (!strcmp(b->txt[k].name, inst)) {
r->txt_count = (size_t)b->txt[k].n;
r->txt = calloc(r->txt_count ? r->txt_count : 1, sizeof(mdns_txt_item_t));
for (size_t j = 0; r->txt && j < r->txt_count; j++) {
char *eq = strchr(b->txt[k].items[j], '=');
if (eq) {
*eq = '\0';
r->txt[j].key = mdns_dup(b->txt[k].items[j]);
r->txt[j].value = mdns_dup(eq + 1);
*eq = '=';
} else {
r->txt[j].key = mdns_dup(b->txt[k].items[j]);
r->txt[j].value = mdns_dup("");
}
}
break;
}
}
mdns_ip_addr_t **at = &r->addr;
for (int k = 0; k < b->na; k++) {
if (!strcmp(b->a[k].name, srv->target)) {
mdns_ip_addr_t *a = calloc(1, sizeof(*a));
if (a) {
a->addr.type = ESP_IPADDR_TYPE_V4;
memcpy(&a->addr.u_addr.ip4.addr, b->a[k].ip, 4);
*at = a;
at = &a->next;
}
}
}
*tail = r;
tail = &r->next;
count++;
}
free(b);
if (!head) {
return ESP_ERR_NOT_FOUND;
}
*results = head;
return ESP_OK;
}
void mdns_query_results_free(mdns_result_t *results)
{
while (results) {
mdns_result_t *next = results->next;
free(results->instance_name);
free(results->hostname);
for (size_t i = 0; i < results->txt_count && results->txt; i++) {
free(results->txt[i].key);
free(results->txt[i].value);
}
free(results->txt);
mdns_ip_addr_t *a = results->addr;
while (a) {
mdns_ip_addr_t *an = a->next;
free(a);
a = an;
}
free(results);
results = next;
}
}
+440
View File
@@ -0,0 +1,440 @@
/*
* Desktop microphone: captures from a Linux ALSA capture device (a USB mic such as the Blue Snowball) and feeds
* the same level meter, beat detector and /audio.wav stream as the board's I2S mic.c. Only the devices named by
* mic_list_devices() are selectable: plughw:CARD=... capture devices, which convert to 16 kHz mono for us.
*/
#include <alsa/asoundlib.h>
#include <errno.h>
#include <math.h>
#include <pthread.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#include "cJSON.h"
#include "esp_log.h"
#include "beat.h"
#include "bridge.h"
#include "mic.h"
#define BRIDGE_DEVICE "bridge:mic" // the microphone of a bridge board (bridge/, ESP32-S3), see bridge_serial.h
#define BLOCK_FRAMES (MIC_SAMPLE_RATE / 50) // 20 ms per read
#define LEVEL_BLOCKS 5 // 100 ms per level reading
#define RING_SAMPLES MIC_SAMPLE_RATE // 1 s of 16-bit mono for the stream
#define DBFS_FLOOR -120.0f
#define SPL_OFFSET 120.0f // same nominal offset as the I2S mic; not calibrated for USB mics
#define DEVICE_NAME_MAX 128
static const char *TAG = "mic_alsa";
static pthread_mutex_t s_lock = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t s_cond = PTHREAD_COND_INITIALIZER;
static bool s_open; // capture wanted (set by mic_open / mic_close)
static uint64_t s_gen; // bumped by mic_open so the capture thread reopens the device
static char s_device[DEVICE_NAME_MAX] = "default";
static mic_level_t s_level = { DBFS_FLOOR, DBFS_FLOOR, DBFS_FLOOR + SPL_OFFSET };
static char s_error[160]; // why the last open failed, "" when it works
static bool s_streaming;
static int16_t s_ring[RING_SAMPLES];
static size_t s_ring_fill; // samples waiting in the ring, oldest first from s_ring_head
static size_t s_ring_head;
static float to_dbfs(float x)
{
return x > 0.0f ? fmaxf(20.0f * log10f(x), DBFS_FLOOR) : DBFS_FLOOR;
}
// Called with s_lock held: a block of 16-bit samples for the stream listener, dropped when it is full
static void ring_push_locked(const int16_t *pcm, size_t n)
{
if (!s_streaming || s_ring_fill + n > RING_SAMPLES) {
return;
}
for (size_t i = 0; i < n; i++) {
s_ring[(s_ring_head + s_ring_fill + i) % RING_SAMPLES] = pcm[i];
}
s_ring_fill += n;
pthread_cond_broadcast(&s_cond);
}
static void reset_level_locked(void)
{
s_level.rms_dbfs = DBFS_FLOOR;
s_level.peak_dbfs = DBFS_FLOOR;
s_level.spl_db = DBFS_FLOOR + SPL_OFFSET;
}
// Per-stream state of the level meter and high-pass filter, see process_block
typedef struct {
float hp_in, hp_out;
double sum_sq;
float peak;
size_t frames;
size_t blocks;
} proc_t;
// One block of 16-bit mono at MIC_SAMPLE_RATE: level meter, beat detector and the stream listener's copy
static void process_block(proc_t *p, const int16_t *raw, size_t frames)
{
static float filtered[BLOCK_FRAMES];
static int16_t pcm_out[BLOCK_FRAMES];
const float gain = CONFIG_MIC_STREAM_GAIN;
for (size_t i = 0; i < frames; i++) {
float x = (float)raw[i] / 32768.0f;
float y = x - p->hp_in + 0.995f * p->hp_out; // one-pole high-pass, as in mic.c
p->hp_in = x;
p->hp_out = y;
filtered[i] = y;
p->sum_sq += (double)y * y;
p->peak = fmaxf(p->peak, fabsf(y));
pcm_out[i] = (int16_t)fmaxf(fminf(y * gain * 32767.0f, 32767.0f), -32768.0f);
}
p->frames += frames;
beat_feed(filtered, frames);
pthread_mutex_lock(&s_lock);
ring_push_locked(pcm_out, frames);
if (++p->blocks >= LEVEL_BLOCKS) {
s_level.rms_dbfs = to_dbfs(sqrtf((float)(p->sum_sq / p->frames)));
s_level.peak_dbfs = to_dbfs(p->peak);
s_level.spl_db = s_level.rms_dbfs + SPL_OFFSET;
p->sum_sq = 0.0;
p->peak = 0.0f;
p->frames = p->blocks = 0;
}
pthread_mutex_unlock(&s_lock);
}
// Read blocks from one open device until it fails or mic_open/mic_close changes the request
static void capture_loop(snd_pcm_t *pcm, uint64_t gen)
{
static int16_t raw[BLOCK_FRAMES];
proc_t p = { 0 };
for (;;) {
pthread_mutex_lock(&s_lock);
bool keep = s_open && s_gen == gen;
pthread_mutex_unlock(&s_lock);
if (!keep) {
return;
}
snd_pcm_sframes_t n = snd_pcm_readi(pcm, raw, BLOCK_FRAMES);
if (n < 0) {
if (snd_pcm_recover(pcm, (int)n, 1) < 0) {
ESP_LOGW(TAG, "capture read failed: %s", snd_strerror((int)n));
return;
}
continue;
}
process_block(&p, raw, (size_t)n);
}
}
// Audio from a bridge board: the bridge's link task calls this while the bridge device is selected
static proc_t s_bridge_proc;
static void on_bridge_audio(const int16_t *pcm, size_t n)
{
pthread_mutex_lock(&s_lock);
bool mine = s_open && !strcmp(s_device, BRIDGE_DEVICE);
pthread_mutex_unlock(&s_lock);
if (mine) {
process_block(&s_bridge_proc, pcm, n);
}
}
static void *capture_thread(void *arg)
{
(void)arg;
for (;;) {
pthread_mutex_lock(&s_lock);
bool open = s_open;
uint64_t gen = s_gen;
char name[DEVICE_NAME_MAX];
memcpy(name, s_device, sizeof(name));
pthread_mutex_unlock(&s_lock);
if (!open || !strcmp(name, BRIDGE_DEVICE)) {
usleep(100 * 1000); // idle: a bridge device is fed by on_bridge_audio
continue;
}
// "pulse:<source>" is a PipeWire/PulseAudio source, opened through the pulse ALSA plugin
const char *pcm_name = name;
if (!strncmp(name, "pulse:", 6)) {
setenv("PULSE_SOURCE", name + 6, 1);
pcm_name = "pulse";
}
snd_pcm_t *pcm = NULL;
int err = snd_pcm_open(&pcm, pcm_name, SND_PCM_STREAM_CAPTURE, 0);
if (err < 0) {
ESP_LOGW(TAG, "cannot open %s: %s", name, snd_strerror(err));
pthread_mutex_lock(&s_lock);
snprintf(s_error, sizeof(s_error), "Cannot open %s: %s", name, snd_strerror(err));
pthread_mutex_unlock(&s_lock);
sleep(1);
continue;
}
err = snd_pcm_set_params(pcm, SND_PCM_FORMAT_S16_LE, SND_PCM_ACCESS_RW_INTERLEAVED, 1,
MIC_SAMPLE_RATE, 1, 500000);
if (err < 0) {
ESP_LOGW(TAG, "cannot set %s to %d Hz mono: %s", name, MIC_SAMPLE_RATE, snd_strerror(err));
snd_pcm_close(pcm);
sleep(1);
continue;
}
ESP_LOGI(TAG, "capturing from %s", name);
pthread_mutex_lock(&s_lock);
s_error[0] = '\0';
pthread_mutex_unlock(&s_lock);
capture_loop(pcm, gen);
snd_pcm_drop(pcm);
snd_pcm_close(pcm);
pthread_mutex_lock(&s_lock);
if (s_gen == gen) {
reset_level_locked();
}
pthread_mutex_unlock(&s_lock);
}
return NULL;
}
esp_err_t mic_start(void)
{
esp_err_t err = beat_start(MIC_SAMPLE_RATE);
if (err != ESP_OK) {
return err;
}
bridge_set_audio_cb(on_bridge_audio);
pthread_t t;
if (pthread_create(&t, NULL, capture_thread, NULL) != 0) {
return ESP_ERR_NO_MEM;
}
pthread_detach(t);
return ESP_OK;
}
void mic_get_level(mic_level_t *out)
{
pthread_mutex_lock(&s_lock);
*out = s_level;
pthread_mutex_unlock(&s_lock);
}
esp_err_t mic_open(const char *device)
{
if (!device || !device[0]) {
device = "default";
}
if (strlen(device) >= DEVICE_NAME_MAX) {
return ESP_ERR_INVALID_ARG;
}
bool bridge = !strcmp(device, BRIDGE_DEVICE);
if (bridge && !bridge_has_mic()) {
pthread_mutex_lock(&s_lock);
snprintf(s_error, sizeof(s_error), "No bridge board with a microphone is connected");
pthread_mutex_unlock(&s_lock);
return ESP_ERR_NOT_FOUND;
}
if (bridge && bridge_mic(true) != ESP_OK) {
pthread_mutex_lock(&s_lock);
snprintf(s_error, sizeof(s_error), "The bridge microphone did not start");
pthread_mutex_unlock(&s_lock);
return ESP_ERR_NOT_SUPPORTED;
}
pthread_mutex_lock(&s_lock);
strcpy(s_device, device);
s_open = true;
s_gen++;
s_ring_fill = 0;
s_bridge_proc = (proc_t){ 0 };
s_error[0] = '\0';
reset_level_locked();
pthread_mutex_unlock(&s_lock);
return ESP_OK;
}
void mic_close(void)
{
pthread_mutex_lock(&s_lock);
s_open = false;
s_gen++;
reset_level_locked();
pthread_mutex_unlock(&s_lock);
bridge_mic(false); // harmless when no bridge is attached
}
void mic_error(char *out, size_t len)
{
pthread_mutex_lock(&s_lock);
snprintf(out, len, "%s", s_error);
pthread_mutex_unlock(&s_lock);
}
bool mic_is_open(void)
{
pthread_mutex_lock(&s_lock);
bool open = s_open;
pthread_mutex_unlock(&s_lock);
return open;
}
esp_err_t mic_stream_open(void)
{
pthread_mutex_lock(&s_lock);
if (s_streaming) {
pthread_mutex_unlock(&s_lock);
return ESP_ERR_INVALID_STATE;
}
s_streaming = true;
s_ring_fill = 0;
pthread_mutex_unlock(&s_lock);
return ESP_OK;
}
size_t mic_stream_read(void *buf, size_t len, TickType_t timeout)
{
struct timespec deadline;
clock_gettime(CLOCK_REALTIME, &deadline);
long ms = (long)(timeout * portTICK_PERIOD_MS);
deadline.tv_sec += ms / 1000;
deadline.tv_nsec += (ms % 1000) * 1000000L;
if (deadline.tv_nsec >= 1000000000L) {
deadline.tv_sec++;
deadline.tv_nsec -= 1000000000L;
}
pthread_mutex_lock(&s_lock);
while (s_ring_fill == 0) {
if (pthread_cond_timedwait(&s_cond, &s_lock, &deadline) == ETIMEDOUT) {
break;
}
}
size_t want = len / sizeof(int16_t);
size_t n = want < s_ring_fill ? want : s_ring_fill;
uint8_t *out = buf;
for (size_t i = 0; i < n; i++) {
int16_t v = s_ring[(s_ring_head + i) % RING_SAMPLES];
out[2 * i] = (uint8_t)(v & 0xFF);
out[2 * i + 1] = (uint8_t)((uint16_t)v >> 8);
}
s_ring_head = (s_ring_head + n) % RING_SAMPLES;
s_ring_fill -= n;
pthread_mutex_unlock(&s_lock);
return n * sizeof(int16_t);
}
void mic_stream_close(void)
{
pthread_mutex_lock(&s_lock);
s_streaming = false;
pthread_mutex_unlock(&s_lock);
}
// Input sources the desktop can record from. On a PipeWire/PulseAudio desktop the USB mic is shared through the
// sound server, so it is listed as a pulse source (pactl). Otherwise the raw ALSA plughw:CARD=... inputs are used.
static int list_alsa_devices(mic_device_t *out, int max);
static int list_pulse_sources(mic_device_t *out, int max)
{
FILE *p = popen("pactl -f json list sources 2>/dev/null", "r");
if (!p) {
return 0;
}
char *buf = NULL;
size_t cap = 0, len = 0;
for (;;) {
if (len + 4096 > cap) {
cap = cap ? cap * 2 : 8192;
buf = realloc(buf, cap);
if (!buf) {
pclose(p);
return 0;
}
}
size_t got = fread(buf + len, 1, cap - len - 1, p);
if (got == 0) {
break;
}
len += got;
}
pclose(p);
buf[len] = '\0';
int count = 0;
cJSON *list = cJSON_Parse(buf);
free(buf);
for (const cJSON *src = list ? list->child : NULL; src && count < max; src = src->next) {
const cJSON *name = cJSON_GetObjectItem(src, "name");
const cJSON *desc = cJSON_GetObjectItem(src, "description");
if (!cJSON_IsString(name) || strncmp(name->valuestring, "alsa_input.", 11) != 0) {
continue; // monitors and other sources
}
mic_device_t *d = &out[count];
if (strlen(name->valuestring) + 6 >= sizeof(d->id)) {
continue;
}
snprintf(d->id, sizeof(d->id), "pulse:%s", name->valuestring);
snprintf(d->name, sizeof(d->name), "%s", cJSON_IsString(desc) ? desc->valuestring : name->valuestring);
snprintf(d->label, sizeof(d->label), "%s", name->valuestring);
count++;
}
cJSON_Delete(list);
return count;
}
int mic_list_devices(mic_device_t *out, int max)
{
int count = 0;
if (bridge_has_mic() && max > 0) {
mic_device_t *d = &out[count++];
snprintf(d->id, sizeof(d->id), "%s", BRIDGE_DEVICE);
snprintf(d->name, sizeof(d->name), "I2S microphone on the bridge board");
snprintf(d->label, sizeof(d->label), "%s", BRIDGE_DEVICE);
}
int more = list_pulse_sources(out + count, max - count);
if (more == 0) {
more = list_alsa_devices(out + count, max - count);
}
return count + more;
}
// Raw ALSA capture devices: each plughw:CARD=... input (ALSA converts to our format)
static int list_alsa_devices(mic_device_t *out, int max)
{
void **hints = NULL;
int count = 0;
if (snd_device_name_hint(-1, "pcm", &hints) < 0) {
return 0;
}
for (void **h = hints; *h && count < max; h++) {
char *name = snd_device_name_get_hint(*h, "NAME");
char *desc = snd_device_name_get_hint(*h, "DESC");
char *ioid = snd_device_name_get_hint(*h, "IOID");
bool input = !ioid || !strcmp(ioid, "Input");
if (name && input && !strncmp(name, "plughw:CARD=", 12) && strlen(name) < sizeof(out[count].id)) {
mic_device_t *d = &out[count];
strcpy(d->id, name);
strcpy(d->label, name);
// The description runs over several lines; the first is the device's name
const char *first = desc ? desc : name;
size_t len = strcspn(first, "\n");
if (len >= sizeof(d->name)) {
len = sizeof(d->name) - 1;
}
memcpy(d->name, first, len);
d->name[len] = '\0';
count++;
}
free(name);
free(desc);
free(ioid);
}
snd_device_name_free_hint(hints);
return count;
}
+21
View File
@@ -0,0 +1,21 @@
/* The simulated rig's page and drivers (www_dist/sim.pack, built by tools/build_sim_web.sh), embedded in the
* program and served at /sim/ (sim-controller/components/sim/sim_rig.c). SIM_PACK is the path, set by CMake. */
#include <stdint.h>
#ifndef SIM_PACK
#error "SIM_PACK must name www_dist/sim.pack"
#endif
#define STR2(x) #x
#define STR(x) STR2(x)
__asm__(
".section .rodata\n"
".balign 16\n"
".global _binary_sim_pack_start\n"
"_binary_sim_pack_start:\n"
".incbin " STR(SIM_PACK) "\n"
".global _binary_sim_pack_end\n"
"_binary_sim_pack_end:\n"
".byte 0\n"
".previous\n");
+21
View File
@@ -0,0 +1,21 @@
/* The gzipped web UI (www_dist/www.pack, built by tools/build_web.sh), embedded in the program: the same
* symbols the firmware's web.c reads on the board. WWW_PACK is the file's path, set by CMake. */
#include <stdint.h>
#ifndef WWW_PACK
#error "WWW_PACK must name www_dist/www.pack"
#endif
#define STR2(x) #x
#define STR(x) STR2(x)
__asm__(
".section .rodata\n"
".balign 16\n"
".global _binary_www_pack_start\n"
"_binary_www_pack_start:\n"
".incbin " STR(WWW_PACK) "\n"
".global _binary_www_pack_end\n"
"_binary_www_pack_end:\n"
".byte 0\n"
".previous\n");