desklock/firmware/main/net.c

/* Wi-Fi STA via ESP-Hosted (C6 radio) + SNTP, then start the gateway link. */

#include <string.h>

#include "esp_event.h"
#include "esp_log.h"
#include "esp_netif.h"
#include "esp_netif_sntp.h"
#include "esp_wifi.h"
#include "nvs_flash.h"

#include "desklock.h"
#include "secrets.h"

static const char *TAG = "net";

static esp_netif_t *s_netif;
static volatile bool s_got_ip;

/* Router DHCP has been observed to go silent for this MAC (flap throttling).
 * After 15 s without a lease, claim the previously granted address statically. */
static void static_ip_fallback(void *arg)
{
    (void)arg;
    vTaskDelay(pdMS_TO_TICKS(15000));
    if (!s_got_ip) {
        ESP_LOGW(TAG, "no DHCP lease after 15s — falling back to static 192.168.86.53");
        esp_netif_dhcpc_stop(s_netif);
        esp_netif_ip_info_t ip = { 0 };
        ip.ip.addr = esp_ip4addr_aton("192.168.86.53");
        ip.gw.addr = esp_ip4addr_aton("192.168.86.1");
        ip.netmask.addr = esp_ip4addr_aton("255.255.255.0");
        esp_netif_set_ip_info(s_netif, &ip);
        esp_netif_dns_info_t dns = { 0 };
        dns.ip.u_addr.ip4.addr = esp_ip4addr_aton("192.168.86.1");
        dns.ip.type = ESP_IPADDR_TYPE_V4;
        esp_netif_set_dns_info(s_netif, ESP_NETIF_DNS_MAIN, &dns);
        setenv("TZ", "CET-1CEST,M3.5.0,M10.5.0/3", 1);
        tzset();
        esp_sntp_config_t sntp = ESP_NETIF_SNTP_DEFAULT_CONFIG("pool.ntp.org");
        esp_netif_sntp_init(&sntp);
        gw_start();
    }
    vTaskDelete(NULL);
}

static void scan_then_connect(void *arg)
{
    (void)arg;
    ESP_LOGI(TAG, "scanning for APs…");
    if (esp_wifi_scan_start(NULL, true) == ESP_OK) {
        uint16_t n = 12;
        wifi_ap_record_t recs[12];
        if (esp_wifi_scan_get_ap_records(&n, recs) == ESP_OK) {
            for (int i = 0; i < n; i++) {
                ESP_LOGI(TAG, "  ap: '%s' rssi=%d ch=%d auth=%d",
                         (const char *)recs[i].ssid, recs[i].rssi,
                         recs[i].primary, recs[i].authmode);
            }
        }
    }
    esp_wifi_connect();
    vTaskDelete(NULL);
}

static void wifi_event(void *arg, esp_event_base_t base, int32_t id, void *data)
{
    (void)arg;
    (void)data;
    if (base == WIFI_EVENT && id == WIFI_EVENT_STA_START) {
        esp_wifi_connect();
    } else if (base == WIFI_EVENT && id == WIFI_EVENT_STA_DISCONNECTED) {
        wifi_event_sta_disconnected_t *dc = (wifi_event_sta_disconnected_t *)data;
        ESP_LOGW(TAG, "wifi disconnected (reason %d), retrying", dc ? dc->reason : -1);
        face_set(FACE_ERROR);
        vTaskDelay(pdMS_TO_TICKS(3000));
        esp_wifi_connect();
    } else if (base == IP_EVENT && id == IP_EVENT_STA_GOT_IP) {
        ip_event_got_ip_t *ev = (ip_event_got_ip_t *)data;
        s_got_ip = true;
        ESP_LOGI(TAG, "got ip " IPSTR, IP2STR(&ev->ip_info.ip));
        setenv("TZ", "CET-1CEST,M3.5.0,M10.5.0/3", 1);
        tzset();
        esp_sntp_config_t sntp = ESP_NETIF_SNTP_DEFAULT_CONFIG("pool.ntp.org");
        esp_netif_sntp_init(&sntp);
        gw_start();
    }
}

void net_start(void)
{
    esp_err_t err = nvs_flash_init();
    if (err == ESP_ERR_NVS_NO_FREE_PAGES || err == ESP_ERR_NVS_NEW_VERSION_FOUND) {
        ESP_ERROR_CHECK(nvs_flash_erase());
        ESP_ERROR_CHECK(nvs_flash_init());
    }
    ESP_ERROR_CHECK(esp_netif_init());
    ESP_ERROR_CHECK(esp_event_loop_create_default());
    s_netif = esp_netif_create_default_wifi_sta();

    wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
    ESP_ERROR_CHECK(esp_wifi_init(&cfg));
    ESP_ERROR_CHECK(esp_event_handler_register(WIFI_EVENT, ESP_EVENT_ANY_ID, wifi_event, NULL));
    ESP_ERROR_CHECK(esp_event_handler_register(IP_EVENT, IP_EVENT_STA_GOT_IP, wifi_event, NULL));

    wifi_config_t wc = { 0 };
    wc.sta.scan_method = WIFI_ALL_CHANNEL_SCAN;
    strlcpy((char *)wc.sta.ssid, WIFI_SSID, sizeof(wc.sta.ssid));
    strlcpy((char *)wc.sta.password, WIFI_PASS, sizeof(wc.sta.password));
    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());
    xTaskCreate(static_ip_fallback, "ipfb", 4096, NULL, 3, NULL);
    ESP_LOGI(TAG, "wifi starting, ssid=%s", WIFI_SSID);
}