open ap when no successful wifi connection

CMakeLists.txt

     mcufont/decoder/mf_bwfont.c
     mcufont/decoder/mf_scaledfont.c
     mcufont/decoder/mf_wordwrap.c
+
+    picowota/dhcpserver/dhcpserver.c
 )
 
 # external dependency include directories
 target_include_directories(gadget PUBLIC ${CMAKE_CURRENT_LIST_DIR}/data)
 target_include_directories(gadget PUBLIC ${CMAKE_CURRENT_LIST_DIR}/build)
 target_include_directories(gadget PUBLIC ${CMAKE_CURRENT_BINARY_DIR})
+target_include_directories(gadget PUBLIC ${CMAKE_CURRENT_LIST_DIR}/picowota/dhcpserver)
 
 # compress source code and stuff we want to include
 add_custom_target(pack bash -c "./pack_data.sh ${CMAKE_CURRENT_BINARY_DIR}"
     ${CMAKE_CURRENT_SOURCE_DIR}/src/workflow_default.c
     ${CMAKE_CURRENT_SOURCE_DIR}/src/buttons.c
     ${CMAKE_CURRENT_SOURCE_DIR}/src/util.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/usb_descriptors.c
 
     ${CMAKE_CURRENT_SOURCE_DIR}/st7789/src/driver_st7789.c
 

README.md

 Also included are the [MCUFont library](https://github.com/mcufont/mcufont) and the [st7789 library](https://github.com/hepingood/st7789), both licensed under the MIT license.
 It also uses the [BTstack](https://github.com/bluekitchen/btstack/blob/master/LICENSE) included with the Pico SDK, following their [license terms](https://github.com/raspberrypi/pico-sdk/blob/master/src/rp2_common/pico_btstack/LICENSE.RP).
 The included bootloader is [picowota](https://github.com/usedbytes/picowota), licensed as BSD 3-clause.
+I'm also using the MicroPython DHCP server, licensed as MIT and included with picowota.
 
 The case design is also licensed as GPLv3.
 It uses a [Pi Pico case model](https://www.printables.com/model/210898-raspberry-pi-pico-case) licensed as CC-BY-NC-SA.

include/usb_descriptors.h

 #ifndef USB_DESCRIPTORS_H_
 #define USB_DESCRIPTORS_H_
 
+#include "pico/unique_id.h"
+
+extern char string_pico_serial[2 * PICO_UNIQUE_BOARD_ID_SIZE_BYTES + 1];
+
 void usb_descriptor_init_id(void);
 
 #endif /* USB_DESCRIPTORS_H_ */

src/ota_shim.c

 #include "textbox.h"
 #include "mem.h"
 #include "util.h"
+#include "usb_descriptors.h"
 #include "wifi.h"
 
 static int16_t lcd_off = 0;
 }
 
 int picowota_init(void) {
+    usb_descriptor_init_id();
     buttons_init();
     buttons_callback(ota_buttons);
     mem_load();
         }
 
         picowota_poll();
-
-        // TODO open AP when timed out?
     }
 
     debug("wifi ready");

src/state_about.c

     "hepingood/st7789\n"
     "usedbytes/picowota\n"
     "lwip-tcpip/lwip\n"
+    "micropython/dhcpserver\n"
     "\n"
 
     "This program is free software: you can redistribute it and/or modify "

src/usb_descriptors.c

  *
  */
 
-#include "pico/unique_id.h"
 #include "tusb.h"
 
 #include "config.h"
 #include "usb_descriptors.h"
 
+#ifndef PICOWOTA
+
 /*
  * A combination of interfaces must have a unique product id,
  * since PC will save device driver after the first plug.
     return desc_configuration;
 }
 
+#endif // PICOWOTA
+
 //--------------------------------------------------------------------+
 // String Descriptors
 //--------------------------------------------------------------------+
     pico_get_unique_board_id_string(string_pico_serial, sizeof(string_pico_serial));
 }
 
+#ifndef PICOWOTA
+
 // array of pointer to string descriptors
 char const* string_desc_arr [] = {
     (const char[]) { 0x09, 0x04 }, // 0: is supported language is English (0x0409)
 
     return _desc_str;
 }
+
+#endif // PICOWOTA

src/wifi.c

 #include "pico/cyw43_arch.h"
 #include "lwip/netif.h"
 #include "lwip/ip4_addr.h"
+#include "dhcpserver.h"
 
 #include "config.h"
 #include "log.h"
 #include "mem.h"
+#include "usb_descriptors.h"
 #include "wifi.h"
 
-#define CONNECT_TIMEOUT (5 * 1000)
+#define CONNECT_TIMEOUT_MS (8UL * 1000UL)
+#define SCAN_AP_TIMEOUT_MS (20UL * 1000UL)
+
+#define WIFI_AP_SSID_PREFIX "Volcano-"
+#define WIFI_AP_SSID_LEN 4
+#define WIFI_AP_PASS_LEN 8
+static_assert((WIFI_AP_SSID_LEN + WIFI_AP_PASS_LEN) <= (2 * PICO_UNIQUE_BOARD_ID_SIZE_BYTES),
+              "SSID and Password parts for AP need to fit Pico serial number");
 
 enum wifi_state {
     WS_IDLE = 0,
 };
 
 static enum wifi_state state = WS_IDLE;
-static uint32_t start_time = 0;
+static uint32_t start_scan_time = 0;
+static uint32_t start_connect_time = 0;
+static uint32_t start_ip_time = 0;
+static dhcp_server_t dhcp_server;
+static bool enabled_ap = false;
+static char curr_ssid[WIFI_MAX_NAME_LEN + 1] = {0};
+static char curr_pass[WIFI_MAX_PASS_LEN + 1] = {0};
+
+static void wifi_ap(void) {
+    cyw43_thread_enter();
+
+    // last N chars of serial for ssid and password
+    const size_t prefix_len = strlen(WIFI_AP_SSID_PREFIX);
+    char wifi_ssid[prefix_len + WIFI_AP_SSID_LEN + 1];
+    memcpy(wifi_ssid, WIFI_AP_SSID_PREFIX, prefix_len);
+    memcpy(wifi_ssid + prefix_len,
+           string_pico_serial + (2 * PICO_UNIQUE_BOARD_ID_SIZE_BYTES) - WIFI_AP_SSID_LEN,
+           WIFI_AP_SSID_LEN);
+    wifi_ssid[prefix_len + WIFI_AP_SSID_LEN] = '\0';
+    strncpy(curr_ssid, wifi_ssid, WIFI_MAX_NAME_LEN);
+
+    char wifi_pass[WIFI_AP_PASS_LEN + 1] = {0};
+    memcpy(wifi_pass,
+           string_pico_serial + (2 * PICO_UNIQUE_BOARD_ID_SIZE_BYTES) - WIFI_AP_SSID_LEN - WIFI_AP_PASS_LEN,
+           WIFI_AP_PASS_LEN);
+    strncpy(curr_pass, wifi_pass, WIFI_MAX_PASS_LEN);
+
+    debug("disable sta");
+    cyw43_arch_disable_sta_mode();
+
+    debug("enable ap '%s' '%s'", wifi_ssid, wifi_pass);
+    cyw43_arch_enable_ap_mode(wifi_ssid, wifi_pass, CYW43_AUTH_WPA2_AES_PSK);
+
+    ip4_addr_t gw, mask;
+    IP4_ADDR(&gw, 192, 168, 4, 1);
+    IP4_ADDR(&mask, 255, 255, 255, 0);
+
+    debug("enable dhcp");
+    dhcp_server_init(&dhcp_server, &gw, &mask);
+
+    state = WS_READY;
+    enabled_ap = true;
+
+    cyw43_thread_exit();
+}
 
 static void wifi_connect(const char *ssid, const char *pw, uint32_t auth) {
+    cyw43_thread_enter();
+
     debug("connecting to '%s'", ssid);
-    start_time = to_ms_since_boot(get_absolute_time());
-    state = WS_CONNECT;
+    strncpy(curr_ssid, ssid, WIFI_MAX_NAME_LEN);
+    strncpy(curr_pass, pw, WIFI_MAX_PASS_LEN);
 
     // https://github.com/raspberrypi/pico-sdk/issues/1413
     uint32_t a = 0;
     if (r != 0) {
         debug("failed to connect %d", r);
         state = WS_SCAN;
+    } else {
+        start_connect_time = to_ms_since_boot(get_absolute_time());
+        state = WS_CONNECT;
     }
+
+    cyw43_thread_exit();
 }
 
 static int scan_result(void *env, const cyw43_ev_scan_result_t *result) {
     }
 
     cyw43_thread_enter();
+
     cyw43_arch_enable_sta_mode();
+
     wifi_scan();
+    start_scan_time = to_ms_since_boot(get_absolute_time());
+
     cyw43_thread_exit();
 }
 
 void wifi_deinit(void) {
     cyw43_thread_enter();
+
     cyw43_arch_disable_sta_mode();
+    cyw43_arch_disable_ap_mode();
     state = WS_IDLE;
+
+    if (enabled_ap) {
+        enabled_ap = false;
+        dhcp_server_deinit(&dhcp_server);
+    }
+
     cyw43_thread_exit();
 }
 
         return "Waiting for IP";
 
     case WS_READY: {
-        cyw43_arch_lwip_begin();
-        const ip4_addr_t *ip = netif_ip4_addr(netif_default);
-        cyw43_arch_lwip_end();
-
-        return ip4addr_ntoa(ip);
+        uint32_t now = to_ms_since_boot(get_absolute_time()) % (enabled_ap ? 9000 : 6000);
+        if (now < 3000) {
+            // show SSID
+            return curr_ssid;
+        } else if (now < 6000) {
+            // show IP
+            cyw43_arch_lwip_begin();
+            const ip4_addr_t *ip = netif_ip4_addr(netif_default);
+            cyw43_arch_lwip_end();
+
+            return ip4addr_ntoa(ip);
+        } else {
+            // show Pass (only AP)
+            return curr_pass;
+        }
     }
     }
 
             debug("restarting scan");
             wifi_scan();
         }
+
+        uint32_t now = to_ms_since_boot(get_absolute_time());
+        if ((now - start_scan_time) >= SCAN_AP_TIMEOUT_MS) {
+            debug("wifi sta timeout. opening ap.");
+            wifi_ap();
+        }
     } else if (state == WS_CONNECT) {
         int link = cyw43_wifi_link_status(&cyw43_state, CYW43_ITF_STA);
 
 
         if (link == CYW43_LINK_JOIN) {
             debug("joined network");
-            start_time = to_ms_since_boot(get_absolute_time());
+            start_ip_time = to_ms_since_boot(get_absolute_time());
             state = WS_WAIT_FOR_IP;
         } else if (link < CYW43_LINK_DOWN) {
             debug("net connection failed. retry.");
         }
 
         uint32_t now = to_ms_since_boot(get_absolute_time());
-        if ((now - start_time) >= CONNECT_TIMEOUT) {
+        if ((now - start_connect_time) >= CONNECT_TIMEOUT_MS) {
             debug("net connection timeout. retry.");
             wifi_scan();
         }
         }
 
         uint32_t now = to_ms_since_boot(get_absolute_time());
-        if ((now - start_time) >= CONNECT_TIMEOUT) {
+        if ((now - start_ip_time) >= CONNECT_TIMEOUT_MS) {
             debug("net dhcp timeout. retry.");
-            start_time = now;
 
             //cyw43_arch_lwip_begin();
             //dhcp_renew(netif_default);