201 lines
7.5 KiB
C
201 lines
7.5 KiB
C
// Wi-Fi station with exponential-backoff reconnect + ntfy.sh HTTPS notifications.
|
|
// Sending happens in its own task fed by a queue so networking can never 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 "config_store.h"
|
|
#include "notifier.h"
|
|
|
|
static const char *TAG = "notify";
|
|
|
|
#define WIFI_CONNECTED_BIT BIT0
|
|
#define SEND_ATTEMPTS 4
|
|
#define NET_TASK_STACK 8192
|
|
#define NET_TASK_PRIO 5
|
|
#define BACKOFF_MIN_MS 1000
|
|
#define BACKOFF_MAX_MS 60000
|
|
|
|
typedef struct {
|
|
notif_kind_t kind;
|
|
char msg[96];
|
|
} notif_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 bool s_wifi_configured;
|
|
|
|
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); // ok if not running
|
|
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 esp_err_t post_ntfy(const char *topic, const char *title, const char *prio, const char *tags, const char *body)
|
|
{
|
|
char url[192];
|
|
size_t sl = strlen(CONFIG_BUZZ_NTFY_SERVER);
|
|
while (sl > 0 && CONFIG_BUZZ_NTFY_SERVER[sl - 1] == '/') sl--;
|
|
snprintf(url, sizeof(url), "%.*s/%s", (int)sl, CONFIG_BUZZ_NTFY_SERVER, topic);
|
|
|
|
esp_http_client_config_t cfg = {
|
|
.url = url,
|
|
.method = HTTP_METHOD_POST,
|
|
.timeout_ms = 10000,
|
|
.crt_bundle_attach = esp_crt_bundle_attach,
|
|
};
|
|
esp_http_client_handle_t c = esp_http_client_init(&cfg);
|
|
if (!c) return ESP_ERR_NO_MEM;
|
|
esp_http_client_set_header(c, "Title", title);
|
|
esp_http_client_set_header(c, "Priority", prio);
|
|
esp_http_client_set_header(c, "Tags", tags);
|
|
esp_http_client_set_post_field(c, body, (int)strlen(body));
|
|
esp_err_t err = esp_http_client_perform(c);
|
|
if (err == ESP_OK) {
|
|
int st = esp_http_client_get_status_code(c);
|
|
if (st != 200) {
|
|
ESP_LOGW(TAG, "ntfy HTTP status %d", st);
|
|
err = ESP_FAIL;
|
|
}
|
|
} else {
|
|
ESP_LOGW(TAG, "HTTP perform: %s", esp_err_to_name(err));
|
|
}
|
|
esp_http_client_cleanup(c);
|
|
return err;
|
|
}
|
|
|
|
// Retry a few times with backoff while Wi-Fi is down / the request fails, then drop.
|
|
static bool deliver(const char *topic, const char *title, const char *prio, const char *tags, const char *body)
|
|
{
|
|
uint32_t wait_ms = 2000;
|
|
for (int attempt = 1; attempt <= SEND_ATTEMPTS; attempt++) {
|
|
EventBits_t bits = xEventGroupWaitBits(s_eg, WIFI_CONNECTED_BIT, pdFALSE, pdTRUE, pdMS_TO_TICKS(15000));
|
|
if (bits & WIFI_CONNECTED_BIT) {
|
|
if (post_ntfy(topic, title, prio, tags, body) == ESP_OK) {
|
|
ESP_LOGI(TAG, "sent '%s' to %s (attempt %d)", body, topic, attempt);
|
|
return true;
|
|
}
|
|
} else {
|
|
ESP_LOGW(TAG, "Wi-Fi down (attempt %d/%d)", attempt, SEND_ATTEMPTS);
|
|
}
|
|
vTaskDelay(pdMS_TO_TICKS(wait_ms));
|
|
wait_ms *= 2;
|
|
}
|
|
ESP_LOGE(TAG, "giving up on '%s', dropped", body);
|
|
return false;
|
|
}
|
|
|
|
static void net_task(void *arg)
|
|
{
|
|
int64_t last_hb_us = esp_timer_get_time();
|
|
notif_msg_t m;
|
|
for (;;) {
|
|
if (xQueueReceive(s_q, &m, pdMS_TO_TICKS(30000)) == pdTRUE) {
|
|
bool ok = deliver(CONFIG_BUZZ_NTFY_TOPIC, "Door buzzer",
|
|
m.kind == NOTIF_ALERT ? "high" : "default",
|
|
m.kind == NOTIF_ALERT ? "bell" : "wrench", m.msg);
|
|
if (ok) s_stats.sent_ok++; else s_stats.sent_failed++;
|
|
last_hb_us = esp_timer_get_time(); // an alert proves liveness; restart the heartbeat timer
|
|
}
|
|
app_config_t cfg;
|
|
config_get(&cfg);
|
|
if (cfg.heartbeat_h > 0 &&
|
|
(esp_timer_get_time() - last_hb_us) >= (int64_t)cfg.heartbeat_h * 3600LL * 1000000LL) {
|
|
last_hb_us = esp_timer_get_time();
|
|
if (deliver(CONFIG_BUZZ_NTFY_HB_TOPIC, "Door buzzer heartbeat", "min", "green_heart", "alive")) {
|
|
s_stats.sent_ok++;
|
|
} else {
|
|
s_stats.sent_failed++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool notifier_send(notif_kind_t kind, const char *msg)
|
|
{
|
|
notif_msg_t m = { .kind = kind };
|
|
snprintf(m.msg, sizeof(m.msg), "%s", msg);
|
|
if (xQueueSend(s_q, &m, 0) != pdTRUE) {
|
|
s_stats.dropped++;
|
|
ESP_LOGW(TAG, "notification queue full, dropped");
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void notifier_get_stats(notifier_stats_t *out)
|
|
{
|
|
*out = s_stats;
|
|
out->wifi_configured = s_wifi_configured;
|
|
}
|
|
|
|
esp_err_t notifier_init(void)
|
|
{
|
|
s_q = xQueueCreate(4, sizeof(notif_msg_t));
|
|
s_eg = xEventGroupCreate();
|
|
if (!s_q || !s_eg) return ESP_ERR_NO_MEM;
|
|
|
|
s_wifi_configured = strlen(CONFIG_BUZZ_WIFI_SSID) > 0;
|
|
if (s_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 (menuconfig): notifications will be dropped");
|
|
}
|
|
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;
|
|
}
|