max80_fw/esp32/max80/wifi.cpp

#include "common.h"
#include "WiFi.h"
#include "wifi.h"
#include "config.h"
#include "httpd.h"
#include "led.h"

#include <lwip/dns.h>
#include <lwip/inet.h>
#include <lwip/apps/sntp.h>
#include <esp_sntp.h>
#include <esp_wifi.h>

static String ssid, password, hostname, dnsserver, sntpserver;
static TimerHandle_t sta_failure_timer;

static bool sta_timeout_enabled;

static void sta_timeout(void)
{
    // Enable the AP if the STA doesn't connect after a timeout
    WiFi.enableAP(true);
}

static void sta_timeout_enable(void)
{
    if (!sta_failure_timer || sta_timeout_enabled)
	return;

    sta_timeout_enabled =
	xTimerStart(sta_failure_timer, 1);
}

static void sta_timeout_disable(void)
{
    if (!sta_failure_timer || !sta_timeout_enabled)
	return;

    sta_timeout_enabled =
	!xTimerStop(sta_failure_timer, 1);
}

static void sntp_sync_cb(struct timeval *tv)
{
    static uint8_t prev_sync_status = SNTP_SYNC_STATUS_RESET;
    uint8_t sync_status = sntp_get_sync_status();

    switch (sync_status) {
    case SNTP_SYNC_STATUS_RESET:
	sntp_set_sync_mode(SNTP_SYNC_MODE_IMMED); // Until first sync
	if (prev_sync_status != sync_status) {
	    printf("[SNTP] time synchronization lost\n");
	}
	break;
    case SNTP_SYNC_STATUS_COMPLETED:
	sntp_set_sync_mode(SNTP_SYNC_MODE_SMOOTH); // After successful sync
	if (prev_sync_status != sync_status) {
	    char timebuf[64];
	    const struct tm *tm = localtime(&tv->tv_sec);
	    strftime(timebuf, sizeof timebuf, "%a %Y-%m-%d %H:%M:%S %z", tm);
	    printf("[SNTP] Time synchronized: %s\n", timebuf);
	}
	break;
    default:
	break;
    }

    prev_sync_status = sync_status;
}

static void my_sntp_start()
{
    if (getenv_bool("sntp.enabled")) {
	sntp_set_time_sync_notification_cb(sntp_sync_cb);
	sntp_setoperatingmode(SNTP_OPMODE_POLL);
	sntp_servermode_dhcp(!getenv_bool("ip4.dhcp.nosntp"));
	sntp_set_sync_mode(SNTP_SYNC_MODE_IMMED); // Until first sync
	sntp_init();
    } else {
	sntp_stop();
    }
}

static bool services_started;

static void stop_services(void)
{
    if (services_started) {
	esp_unregister_shutdown_handler(stop_services);
	my_httpd_stop();
	services_started = false;
    }
}

static inline bool invalid_ip(const ip_addr_t *ip)
{
    return !memcmp(ip, &ip_addr_any, sizeof *ip);
}

static void start_services(void)
{
    /* Always run after (re)connect */
    const ip_addr_t *dns_ip = dns_getserver(0);
    if (invalid_ip(dns_ip) || getenv_bool("ip4.dhcp.nodns")) {
	/* Static DNS server configuration */
	ip_addr_t addr;
	if (dnsserver != "" && inet_aton(dnsserver.c_str(), &addr)) {
	    if (memcmp(dns_ip, &addr, sizeof addr))
		dns_setserver(0, &addr);
	}
    }

    dns_ip = dns_getserver(0);
    printf("[DNS]  DNS server: %s\n", inet_ntoa(*dns_ip));

    // If Arduino supported both of these at the same that would be
    // awesome, but it requires ESP-IDF reconfiguration...
    if (sntp_enabled()) {
	const ip_addr_t *sntp_ip = sntp_getserver(0);

	if (invalid_ip(sntp_ip)) {
	    if (sntpserver != "") {
		sntp_setservername(0, sntpserver.c_str());
		sntp_ip = sntp_getserver(0);
	    }
	}

	if (!invalid_ip(sntp_ip))
	    printf("[SNTP] Time server: %s\n", inet_ntoa(*sntp_ip));
    }

    /* Only run on first start */
    if (!services_started) {
	services_started = true;
	my_httpd_start();
	esp_register_shutdown_handler(stop_services);
    }
}

static String wifi_local_ip(void)
{
    return WiFi.localIP().toString();
}

static void WiFiEvent(WiFiEvent_t event, WiFiEventInfo_t info)
{
    bool retry_sta  = false;
    bool is_connect = false;
    enum connected {
	CON_STA = 1,
	CON_ETH = 2,
	CON_AP  = 4
    };
    static int connected;
    static int ap_clients = 0;

    switch (event) {
    case ARDUINO_EVENT_WIFI_READY:
	printf("[WIFI] Interface ready\n");
	break;
    case ARDUINO_EVENT_WIFI_SCAN_DONE:
	printf("[WIFI] Completed scan for access points\n");
	break;
    case ARDUINO_EVENT_WIFI_STA_START:
	printf("[WIFI] Client started\n");
	break;
    case ARDUINO_EVENT_WIFI_STA_STOP:
	printf("[WIFI] Clients stopped\n");
	connected &= ~CON_STA;
	break;
    case ARDUINO_EVENT_WIFI_STA_CONNECTED:
	printf("[WIFI] Connected to access point\n");
	break;
    case ARDUINO_EVENT_WIFI_STA_DISCONNECTED:
	printf("[WIFI] Disconnected from WiFi access point\n");
	connected &= ~CON_STA;
	retry_sta = true;
	break;
    case ARDUINO_EVENT_WIFI_STA_AUTHMODE_CHANGE:
	printf("[WIFI] Authentication mode of access point has changed\n");
	break;
    case ARDUINO_EVENT_WIFI_STA_GOT_IP:
	printf("[WIFI] Obtained IP address: %s\n", wifi_local_ip().c_str());
	connected |= CON_STA;
	is_connect = true;
	break;
    case ARDUINO_EVENT_WIFI_STA_LOST_IP:
	printf("[WIFI] Lost IP address and IP address is reset to 0\n");
	connected &= ~CON_STA;
	retry_sta = true;
	break;
    case ARDUINO_EVENT_WPS_ER_SUCCESS:
	printf("[WIFI] WiFi Protected Setup (WPS): succeeded in enrollee mode\n");
	break;
    case ARDUINO_EVENT_WPS_ER_FAILED:
	printf("[WIFI] WiFi Protected Setup (WPS): failed in enrollee mode\n");
	break;
    case ARDUINO_EVENT_WPS_ER_TIMEOUT:
	printf("[WIFI] WiFi Protected Setup (WPS): timeout in enrollee mode\n");
	break;
    case ARDUINO_EVENT_WPS_ER_PIN:
	printf("[WIFI] WiFi Protected Setup (WPS): pin code in enrollee mode\n");
	break;
    case ARDUINO_EVENT_WIFI_AP_START:
	printf("[WIFI] Access point started\n");
	ap_clients  = 0;
	connected  |= CON_AP;
	is_connect  = true;
	break;
    case ARDUINO_EVENT_WIFI_AP_STOP:
	printf("[WIFI] Access point stopped\n");
	connected  &= ~CON_AP;
	ap_clients  = 0;
	break;
    case ARDUINO_EVENT_WIFI_AP_STACONNECTED:
	printf("[WIFI] Client connected\n");
	ap_clients++;
	break;
    case ARDUINO_EVENT_WIFI_AP_STADISCONNECTED:
	printf("[WIFI] Client disconnected\n");
	ap_clients--;
	break;
    case ARDUINO_EVENT_WIFI_AP_STAIPASSIGNED:
	printf("[WIFI] Assigned IP address %s to client\n",
	       inet_ntoa(info.wifi_ap_staipassigned.ip));
	break;
    case ARDUINO_EVENT_WIFI_AP_PROBEREQRECVED:
	printf("[WIFI] Received probe request\n");
	break;
    case ARDUINO_EVENT_WIFI_AP_GOT_IP6:
	printf("[WIFI] AP IPv6 is preferred\n");
	break;
    case ARDUINO_EVENT_WIFI_STA_GOT_IP6:
	printf("[WIFI] STA IPv6 is preferred\n");
	is_connect = true;
	break;
    case ARDUINO_EVENT_ETH_GOT_IP6:
	printf("[ETH]  Ethernet IPv6 is preferred\n");
	is_connect = true;
	break;
    case ARDUINO_EVENT_ETH_START:
	printf("[ETH]  Ethernet started\n");
	break;
    case ARDUINO_EVENT_ETH_STOP:
	printf("[ETH]  Ethernet stopped\n");
	connected &= ~CON_ETH;
	break;
    case ARDUINO_EVENT_ETH_CONNECTED:
	printf("[ETH]  Ethernet connected\n");
	break;
    case ARDUINO_EVENT_ETH_DISCONNECTED:
	printf("[ETH]  Ethernet disconnected\n");
	connected &= ~CON_ETH;
	retry_sta = true;
	break;
    case ARDUINO_EVENT_ETH_GOT_IP:
	printf("[ETH]  Obtained IP address: %s\n", wifi_local_ip().c_str());
	connected |= CON_ETH;
	is_connect = true;
    default:
	break;
    }

    if (connected & ~CON_AP) {
	sta_timeout_disable();
	if (!ap_clients)
	    WiFi.enableAP(false);
    } else if (ssid != "") {
	sta_timeout_enable();
    }

    if (ssid == "") {
	// No network configured
	led_set(LED_GREEN, connected & CON_AP ? LED_FLASH_SLOW : LED_OFF);
    } else {
	led_set(LED_GREEN, connected & CON_AP ? LED_FLASH_FAST : LED_ON);
    }
    
    /* Maybe need to do these in a different thread? */
    if (is_connect) {
	start_services();
    }
    if (retry_sta) {
	WiFi.disconnect();
	WiFi.begin();
    }
}

static void wifi_config_ap(void)
{
    /* No network configuration set */
    IPAddress AP_IP      = IPAddress(192,168,0,1);
    IPAddress AP_Netmask = IPAddress(255,255,255,0);
    IPAddress AP_Gateway = IPAddress(0,0,0,0); // No gateway
    unsigned int channel = time(NULL) % 11;	   // Pseudo-random
    uint8_t mac[6];
    char ap_ssid[64];

    WiFi.macAddress(mac);
    /* The last two bytes of the MAC */
    snprintf(ap_ssid, sizeof ap_ssid, "MAX80_%02X%02X", mac[4], mac[5]);

    printf("[WIFI] AP SSID %s IP %s netmask %s channel %u\n",
	       ap_ssid, AP_IP.toString(), AP_Netmask.toString(), channel+1);

    printf("WiFi.softAP\n");
    
    WiFi.softAP(ap_ssid, NULL, channel+1, 0, 4, true);

    printf("WiFi.softAPConfig\n");
    WiFi.softAPConfig(AP_IP, AP_Gateway, AP_Netmask);

    printf("WiFi.softAPsetHostname\n");
    WiFi.softAPsetHostname(ap_ssid);

    // Conservative setting: 20 MHz (single channel) only; this is for
    // reliability, not performance.
    printf("esp_wifi_set_bandwidth\n");
    esp_wifi_set_bandwidth((wifi_interface_t)ESP_IF_WIFI_AP, WIFI_BW_HT20);

    printf("WiFi.enableAP\n");
    WiFi.enableAP(ssid == "");

    printf("wifi_config_ap done\n");
}

static void wifi_config_sta(void)
{
    if (ssid == "") {
	WiFi.enableSTA(false);
	return;
    }
    sta_failure_timer = xTimerCreate("wifi_sta", configTICK_RATE_HZ*30,
				     pdFALSE, NULL,
				     (TimerCallbackFunction_t)sta_timeout);

    sta_timeout_enable();

    WiFi.begin(ssid.c_str(), password.c_str());
    WiFi.setAutoConnect(true);
    WiFi.setAutoReconnect(true);
    WiFi.enableSTA(true);
}

static void wifi_config(void)
{
    ssid         = getenv("wifi.ssid");
    password     = getenv("wifi.psk");
    hostname     = getenv("hostname");
    dnsserver    = getenv("ip4.dns");

    WiFi.persistent(false);
    WiFi.setSleep(false);

    if (hostname != "")
	WiFi.hostname(hostname);

    wifi_config_sta();
    wifi_config_ap();
}

void SetupWiFi() {
    services_started = false;

    WiFi.onEvent(WiFiEvent);

    my_sntp_start();

    printf("[INFO] Setting up WiFi\n");
    wifi_config();
}