222 lines
7.7 KiB
C
222 lines
7.7 KiB
C
// Wi-Fi station with exponential-backoff reconnect and queued event POSTs.
|
|
// HTTP requests run in their own task so networking cannot block audio.
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include "esp_crt_bundle.h"
|
|
#include "esp_event.h"
|
|
#include "esp_http_client.h"
|
|
#include "esp_log.h"
|
|
#include "esp_netif.h"
|
|
#include "esp_timer.h"
|
|
#include "esp_wifi.h"
|
|
#include "freertos/FreeRTOS.h"
|
|
#include "freertos/event_groups.h"
|
|
#include "freertos/queue.h"
|
|
#include "freertos/task.h"
|
|
#include "notifier.h"
|
|
|
|
static const char *TAG = "notify";
|
|
|
|
#define WIFI_CONNECTED_BIT BIT0
|
|
#define NET_TASK_STACK 8192
|
|
#define NET_TASK_PRIO 5
|
|
#define BACKOFF_MIN_MS 1000
|
|
#define BACKOFF_MAX_MS 60000
|
|
#define EVENT_BODY_SIZE 512
|
|
|
|
typedef struct {
|
|
uint32_t delay_ms;
|
|
} event_msg_t;
|
|
|
|
static QueueHandle_t s_q;
|
|
static EventGroupHandle_t s_eg;
|
|
static esp_timer_handle_t s_reconnect_timer;
|
|
static uint32_t s_backoff_ms = BACKOFF_MIN_MS;
|
|
static notifier_stats_t s_stats;
|
|
|
|
static void reconnect_cb(void *arg)
|
|
{
|
|
esp_err_t err = esp_wifi_connect();
|
|
if (err != ESP_OK && err != ESP_ERR_WIFI_CONN) {
|
|
ESP_LOGW(TAG, "esp_wifi_connect: %s", esp_err_to_name(err));
|
|
}
|
|
}
|
|
|
|
static void wifi_event_handler(void *arg, esp_event_base_t base, int32_t id, void *data)
|
|
{
|
|
if (base == WIFI_EVENT && id == WIFI_EVENT_STA_START) {
|
|
esp_wifi_connect();
|
|
} else if (base == WIFI_EVENT && id == WIFI_EVENT_STA_DISCONNECTED) {
|
|
xEventGroupClearBits(s_eg, WIFI_CONNECTED_BIT);
|
|
s_stats.wifi_connected = false;
|
|
ESP_LOGW(TAG, "Wi-Fi disconnected, retry in %lu ms", (unsigned long)s_backoff_ms);
|
|
esp_timer_stop(s_reconnect_timer);
|
|
esp_timer_start_once(s_reconnect_timer, (uint64_t)s_backoff_ms * 1000ULL);
|
|
s_backoff_ms = s_backoff_ms * 2 > BACKOFF_MAX_MS ? BACKOFF_MAX_MS : s_backoff_ms * 2;
|
|
} else if (base == IP_EVENT && id == IP_EVENT_STA_GOT_IP) {
|
|
ip_event_got_ip_t *ev = (ip_event_got_ip_t *)data;
|
|
snprintf(s_stats.ip, sizeof(s_stats.ip), IPSTR, IP2STR(&ev->ip_info.ip));
|
|
s_stats.wifi_connected = true;
|
|
s_backoff_ms = BACKOFF_MIN_MS;
|
|
xEventGroupSetBits(s_eg, WIFI_CONNECTED_BIT);
|
|
ESP_LOGI(TAG, "Wi-Fi up, IP %s", s_stats.ip);
|
|
}
|
|
}
|
|
|
|
static bool make_event_body(uint32_t delay_ms, char *body, size_t body_size)
|
|
{
|
|
int n = snprintf(body, body_size, "{\"delay_ms\":%lu,\"secret\":\"",
|
|
(unsigned long)delay_ms);
|
|
if (n < 0 || (size_t)n >= body_size) return false;
|
|
size_t used = (size_t)n;
|
|
|
|
for (const unsigned char *p = (const unsigned char *)CONFIG_BUZZ_EVENT_SECRET; *p; p++) {
|
|
char escaped[7];
|
|
const char *text = (const char *)p;
|
|
size_t len = 1;
|
|
if (*p == '"' || *p == '\\') {
|
|
escaped[0] = '\\';
|
|
escaped[1] = (char)*p;
|
|
text = escaped;
|
|
len = 2;
|
|
} else if (*p < 0x20) {
|
|
snprintf(escaped, sizeof(escaped), "\\u%04x", *p);
|
|
text = escaped;
|
|
len = 6;
|
|
}
|
|
if (len >= body_size - used) return false;
|
|
memcpy(body + used, text, len);
|
|
used += len;
|
|
}
|
|
if (body_size - used < 3) return false;
|
|
body[used++] = '"';
|
|
body[used++] = '}';
|
|
body[used] = '\0';
|
|
return true;
|
|
}
|
|
|
|
// One queue item produces at most one HTTP request: there is deliberately no retry.
|
|
static bool post_event(uint32_t delay_ms)
|
|
{
|
|
EventBits_t bits = xEventGroupWaitBits(s_eg, WIFI_CONNECTED_BIT, pdFALSE, pdTRUE,
|
|
pdMS_TO_TICKS(15000));
|
|
if (!(bits & WIFI_CONNECTED_BIT)) {
|
|
ESP_LOGE(TAG, "Wi-Fi unavailable; event was not sent");
|
|
return false;
|
|
}
|
|
|
|
char body[EVENT_BODY_SIZE];
|
|
if (!make_event_body(delay_ms, body, sizeof(body))) {
|
|
ESP_LOGE(TAG, "event body exceeds buffer");
|
|
return false;
|
|
}
|
|
|
|
const char *url = "http://192.168.0.154:3000/event/buzz";
|
|
esp_http_client_config_t cfg = {
|
|
.url = url,
|
|
.method = HTTP_METHOD_POST,
|
|
.timeout_ms = 10000,
|
|
.disable_auto_redirect = true,
|
|
.crt_bundle_attach = esp_crt_bundle_attach,
|
|
};
|
|
esp_http_client_handle_t c = esp_http_client_init(&cfg);
|
|
if (!c) {
|
|
ESP_LOGE(TAG, "could not create HTTP client");
|
|
return false;
|
|
}
|
|
esp_err_t err = esp_http_client_set_header(c, "Content-Type", "application/json");
|
|
if (err == ESP_OK) err = esp_http_client_set_post_field(c, body, (int)strlen(body));
|
|
if (err != ESP_OK) {
|
|
ESP_LOGE(TAG, "configure event POST: %s", esp_err_to_name(err));
|
|
esp_http_client_cleanup(c);
|
|
return false;
|
|
}
|
|
|
|
err = esp_http_client_perform(c);
|
|
int status = err == ESP_OK ? esp_http_client_get_status_code(c) : 0;
|
|
esp_http_client_cleanup(c);
|
|
if (err != ESP_OK) {
|
|
ESP_LOGE(TAG, "event POST failed: %s", esp_err_to_name(err));
|
|
return false;
|
|
}
|
|
if (status < 200 || status >= 300) {
|
|
ESP_LOGE(TAG, "event endpoint returned HTTP %d", status);
|
|
return false;
|
|
}
|
|
ESP_LOGI(TAG, "sent buzz duration %lu ms (HTTP %d)", (unsigned long)delay_ms, status);
|
|
return true;
|
|
}
|
|
|
|
static void net_task(void *arg)
|
|
{
|
|
event_msg_t msg;
|
|
for (;;) {
|
|
if (xQueueReceive(s_q, &msg, portMAX_DELAY) == pdTRUE) {
|
|
if (post_event(msg.delay_ms)) s_stats.sent_ok++;
|
|
else s_stats.sent_failed++;
|
|
}
|
|
}
|
|
}
|
|
|
|
bool notifier_send(uint32_t delay_ms)
|
|
{
|
|
event_msg_t msg = { .delay_ms = delay_ms };
|
|
if (xQueueSend(s_q, &msg, 0) != pdTRUE) {
|
|
s_stats.dropped++;
|
|
ESP_LOGW(TAG, "event queue full, dropped");
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void notifier_get_stats(notifier_stats_t *out)
|
|
{
|
|
*out = s_stats;
|
|
out->wifi_configured = strlen(CONFIG_BUZZ_WIFI_SSID) > 0;
|
|
out->endpoint_configured = strlen(CONFIG_BUZZ_EVENT_URL) > 0;
|
|
}
|
|
|
|
esp_err_t notifier_init(void)
|
|
{
|
|
s_q = xQueueCreate(4, sizeof(event_msg_t));
|
|
s_eg = xEventGroupCreate();
|
|
if (!s_q || !s_eg) return ESP_ERR_NO_MEM;
|
|
|
|
s_stats.endpoint_configured = strlen(CONFIG_BUZZ_EVENT_URL) > 0;
|
|
if (!s_stats.endpoint_configured) {
|
|
ESP_LOGW(TAG, "no event endpoint configured; buzz events will be dropped");
|
|
}
|
|
if (!strlen(CONFIG_BUZZ_EVENT_SECRET)) {
|
|
ESP_LOGW(TAG, "event secret is empty; configure it before using the endpoint");
|
|
}
|
|
|
|
s_stats.wifi_configured = strlen(CONFIG_BUZZ_WIFI_SSID) > 0;
|
|
if (s_stats.wifi_configured) {
|
|
ESP_ERROR_CHECK(esp_netif_init());
|
|
ESP_ERROR_CHECK(esp_event_loop_create_default());
|
|
esp_netif_create_default_wifi_sta();
|
|
|
|
const esp_timer_create_args_t targs = { .callback = reconnect_cb, .name = "wifi_retry" };
|
|
ESP_ERROR_CHECK(esp_timer_create(&targs, &s_reconnect_timer));
|
|
|
|
wifi_init_config_t icfg = WIFI_INIT_CONFIG_DEFAULT();
|
|
ESP_ERROR_CHECK(esp_wifi_init(&icfg));
|
|
ESP_ERROR_CHECK(esp_event_handler_register(WIFI_EVENT, ESP_EVENT_ANY_ID, wifi_event_handler, NULL));
|
|
ESP_ERROR_CHECK(esp_event_handler_register(IP_EVENT, IP_EVENT_STA_GOT_IP, wifi_event_handler, NULL));
|
|
|
|
wifi_config_t wc = { 0 };
|
|
strlcpy((char *)wc.sta.ssid, CONFIG_BUZZ_WIFI_SSID, sizeof(wc.sta.ssid));
|
|
strlcpy((char *)wc.sta.password, CONFIG_BUZZ_WIFI_PASSWORD, sizeof(wc.sta.password));
|
|
wc.sta.threshold.authmode = strlen(CONFIG_BUZZ_WIFI_PASSWORD) ? WIFI_AUTH_WPA2_PSK : WIFI_AUTH_OPEN;
|
|
wc.sta.sae_pwe_h2e = WPA3_SAE_PWE_BOTH;
|
|
ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA));
|
|
ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA, &wc));
|
|
ESP_ERROR_CHECK(esp_wifi_start());
|
|
} else {
|
|
ESP_LOGW(TAG, "no Wi-Fi SSID configured; event requests cannot be sent");
|
|
}
|
|
|
|
BaseType_t ok = xTaskCreatePinnedToCore(net_task, "net", NET_TASK_STACK, NULL, NET_TASK_PRIO, NULL, 0);
|
|
return ok == pdPASS ? ESP_OK : ESP_ERR_NO_MEM;
|
|
}
|