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:
1 parent
698c1463c0
commit
581b751904
506 files changed
+42336
-3599
No files matched your search
@@ -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);
|
||||
@@ -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);
|
||||
@@ -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)
|
||||
@@ -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)
|
||||
@@ -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);
|
||||
@@ -0,0 +1,3 @@
|
||||
#pragma once
|
||||
|
||||
#include "esp_event.h"
|
||||
@@ -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);
|
||||
}
|
||||
@@ -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__)
|
||||
@@ -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);
|
||||
@@ -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]
|
||||
@@ -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);
|
||||
@@ -0,0 +1,5 @@
|
||||
#pragma once
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
void esp_rom_delay_us(uint32_t us);
|
||||
@@ -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);
|
||||
@@ -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);
|
||||
@@ -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);
|
||||
@@ -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()
|
||||
@@ -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);
|
||||
@@ -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);
|
||||
@@ -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);
|
||||
@@ -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);
|
||||
@@ -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();
|
||||
}
|
||||
@@ -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
|
||||
@@ -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;
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
@@ -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");
|
||||
@@ -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");
|
||||
Reference in new issue
Block a user