Wifi

static void wifi_event_handler(void *argument, esp_event_base_t event_base,
                               int32_t event_id, void *event_data)

1. Execute(void)argument;
2. Execute(void)event_data;
3. Decisionevent_base == WIFI_EVENT && event_id == WIFI_EVENT_SCAN_DONE
   True

   1. 1. Executescan_done = true;

   False

   1. Decisionevent_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_DISCONNECTED
      True

      1. 1. Executeconnection_state = WIFI_CONNECTION_FAILED;
         2. Executelast_error = "CONNECTION FAILED";

      False

      1. Decisionevent_base == IP_EVENT && event_id == IP_EVENT_STA_GOT_IP
         True

         1. 1. Executeconnection_state = WIFI_CONNECTION_CONNECTED;
            2. Executelast_error = "";

         False

         Continue after this decision.

static void wifi_event_handler(void *argument, esp_event_base_t event_base,
                               int32_t event_id, void *event_data)
{
    (void)argument;
    (void)event_data;
    if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_SCAN_DONE) {
        scan_done = true;
    } else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_DISCONNECTED) {
        connection_state = WIFI_CONNECTION_FAILED;
        last_error = "CONNECTION FAILED";
    } else if (event_base == IP_EVENT && event_id == IP_EVENT_STA_GOT_IP) {
        connection_state = WIFI_CONNECTION_CONNECTED;
        last_error = "";
    }
}

static bool accept_already_initialized(esp_err_t result)

1. Exit this functionreturn result == ESP_OK || result == ESP_ERR_INVALID_STATE;

static bool accept_already_initialized(esp_err_t result)
{
    return result == ESP_OK || result == ESP_ERR_INVALID_STATE;
}

static bool record_error(esp_err_t result)

1. Executeservice_state = WIFI_SERVICE_FAILED;
2. Executelast_error = esp_err_to_name(result);
3. Exit this functionreturn false;

static bool record_error(esp_err_t result)
{
    service_state = WIFI_SERVICE_FAILED;
    last_error = esp_err_to_name(result);
    return false;
}

bool wifiServicePrepare(void)

Calls into this documentation:

1. Decisionservice_state == WIFI_SERVICE_READY
   True

   1. Exit this functionreturn true;

   False

   Continue after this decision.

2. Decisionservice_state == WIFI_SERVICE_FAILED
   True

   1. Exit this functionreturn false;

   False

   Continue after this decision.

3. Executeconst esp_err_t netif_result = esp_netif_init();
4. Decision!accept_already_initialized(netif_result)
   True

   1. Exit this functionreturn record_error(netif_result);

   False

   Continue after this decision.

5. Executeconst esp_err_t event_result = esp_event_loop_create_default();
6. Decision!accept_already_initialized(event_result)
   True

   1. Exit this functionreturn record_error(event_result);

   False

   Continue after this decision.

7. Executestation_interface = esp_netif_create_default_wifi_sta();
8. Decisionstation_interface == NULL
   True

   1. 1. Executeservice_state = WIFI_SERVICE_FAILED;
      2. Executelast_error = "NO STATION INTERFACE";
      3. Exit this functionreturn false;

   False

   Continue after this decision.

9. Executewifi_init_config_t configuration = WIFI_INIT_CONFIG_DEFAULT();
10. Executeconst esp_err_t init_result = esp_wifi_init(&configuration);
11. Decisioninit_result != ESP_OK
    True

    1. Exit this functionreturn record_error(init_result);

    False

    Continue after this decision.

12. Executeconst esp_err_t storage_result = esp_wifi_set_storage(WIFI_STORAGE_RAM);
13. Decisionstorage_result != ESP_OK
    True

    1. Exit this functionreturn record_error(storage_result);

    False

    Continue after this decision.

14. Executeconst esp_err_t mode_result = esp_wifi_set_mode(WIFI_MODE_STA);
15. Decisionmode_result != ESP_OK
    True

    1. Exit this functionreturn record_error(mode_result);

    False

    Continue after this decision.

16. Executeconst esp_err_t handler_result = esp_event_handler_instance_register( WIFI_EVENT, WIFI_EVENT_SCAN_DONE, wifi_event_handler, NULL, &scan_event_handler);
17. Decisionhandler_result != ESP_OK
    True

    1. Exit this functionreturn record_error(handler_result);

    False

    Continue after this decision.

18. Executeconst esp_err_t connected_handler_result = esp_event_handler_instance_register( WIFI_EVENT, WIFI_EVENT_STA_CONNECTED, wifi_event_handler, NULL, &connected_event_handler);
19. Decisionconnected_handler_result != ESP_OK
    True

    1. Exit this functionreturn record_error(connected_handler_result);

    False

    Continue after this decision.

20. Executeconst esp_err_t disconnected_handler_result = esp_event_handler_instance_register( WIFI_EVENT, WIFI_EVENT_STA_DISCONNECTED, wifi_event_handler, NULL, &disconnected_event_handler);
21. Decisiondisconnected_handler_result != ESP_OK
    True

    1. Exit this functionreturn record_error(disconnected_handler_result);

    False

    Continue after this decision.

22. Executeconst esp_err_t got_ip_handler_result = esp_event_handler_instance_register( IP_EVENT, IP_EVENT_STA_GOT_IP, wifi_event_handler, NULL, &got_ip_event_handler);
23. Decisiongot_ip_handler_result != ESP_OK
    True

    1. Exit this functionreturn record_error(got_ip_handler_result);

    False

    Continue after this decision.

24. Executeservice_state = WIFI_SERVICE_READY;
25. Executelast_error = "";
26. Exit this functionreturn true;

bool wifiServicePrepare(void)
{
    if (service_state == WIFI_SERVICE_READY) return true;
    if (service_state == WIFI_SERVICE_FAILED) return false;

    const esp_err_t netif_result = esp_netif_init();
    if (!accept_already_initialized(netif_result)) return record_error(netif_result);

    const esp_err_t event_result = esp_event_loop_create_default();
    if (!accept_already_initialized(event_result)) return record_error(event_result);

    station_interface = esp_netif_create_default_wifi_sta();
    if (station_interface == NULL) {
        service_state = WIFI_SERVICE_FAILED;
        last_error = "NO STATION INTERFACE";
        return false;
    }

    wifi_init_config_t configuration = WIFI_INIT_CONFIG_DEFAULT();
    const esp_err_t init_result = esp_wifi_init(&configuration);
    if (init_result != ESP_OK) return record_error(init_result);

    const esp_err_t storage_result = esp_wifi_set_storage(WIFI_STORAGE_RAM);
    if (storage_result != ESP_OK) return record_error(storage_result);

    const esp_err_t mode_result = esp_wifi_set_mode(WIFI_MODE_STA);
    if (mode_result != ESP_OK) return record_error(mode_result);

    const esp_err_t handler_result = esp_event_handler_instance_register(
        WIFI_EVENT, WIFI_EVENT_SCAN_DONE, wifi_event_handler, NULL, &scan_event_handler);
    if (handler_result != ESP_OK) return record_error(handler_result);
    const esp_err_t connected_handler_result = esp_event_handler_instance_register(
        WIFI_EVENT, WIFI_EVENT_STA_CONNECTED, wifi_event_handler, NULL, &connected_event_handler);
    if (connected_handler_result != ESP_OK) return record_error(connected_handler_result);
    const esp_err_t disconnected_handler_result = esp_event_handler_instance_register(
        WIFI_EVENT, WIFI_EVENT_STA_DISCONNECTED, wifi_event_handler, NULL, &disconnected_event_handler);
    if (disconnected_handler_result != ESP_OK) return record_error(disconnected_handler_result);
    const esp_err_t got_ip_handler_result = esp_event_handler_instance_register(
        IP_EVENT, IP_EVENT_STA_GOT_IP, wifi_event_handler, NULL, &got_ip_event_handler);
    if (got_ip_handler_result != ESP_OK) return record_error(got_ip_handler_result);

    service_state = WIFI_SERVICE_READY;
    last_error = "";
    return true;
}

bool wifiServiceStart(void)

Calls into this documentation:

1. Decision!wifiServicePrepare()
   True

   1. Exit this functionreturn false;

   False

   Continue after this decision.

2. Decisionradio_started
   True

   1. Exit this functionreturn true;

   False

   Continue after this decision.

3. Executeconst esp_err_t result = esp_wifi_start();
4. Decisionresult != ESP_OK
   True

   1. 1. Executelast_error = esp_err_to_name(result);
      2. Exit this functionreturn false;

   False

   Continue after this decision.

5. Executeradio_started = true;
6. Executelast_error = "";
7. Exit this functionreturn true;

bool wifiServiceStart(void)
{
    if (!wifiServicePrepare()) return false;
    if (radio_started) return true;

    const esp_err_t result = esp_wifi_start();
    if (result != ESP_OK) {
        last_error = esp_err_to_name(result);
        return false;
    }
    radio_started = true;
    last_error = "";
    return true;
}

bool wifiServiceStop(void)

1. Decision!radio_started
   True

   1. Exit this functionreturn true;

   False

   Continue after this decision.

2. Executeconst esp_err_t result = esp_wifi_stop();
3. Decisionresult != ESP_OK
   True

   1. 1. Executelast_error = esp_err_to_name(result);
      2. Exit this functionreturn false;

   False

   Continue after this decision.

4. Executeradio_started = false;
5. Executeconnection_state = WIFI_CONNECTION_DISCONNECTED;
6. Executescan_in_progress = false;
7. Executescan_done = false;
8. Executelast_error = "";
9. Exit this functionreturn true;

bool wifiServiceStop(void)
{
    if (!radio_started) return true;

    const esp_err_t result = esp_wifi_stop();
    if (result != ESP_OK) {
        last_error = esp_err_to_name(result);
        return false;
    }
    radio_started = false;
    connection_state = WIFI_CONNECTION_DISCONNECTED;
    scan_in_progress = false;
    scan_done = false;
    last_error = "";
    return true;
}

bool wifiServiceStartScan(void)

1. Decision!radio_started
   True

   1. 1. Executelast_error = "RADIO OFF";
      2. Exit this functionreturn false;

   False

   Continue after this decision.

2. Decisionscan_in_progress
   True

   1. Exit this functionreturn true;

   False

   Continue after this decision.

3. Executeconst wifi_scan_config_t configuration = {0};
4. Executeconst esp_err_t result = esp_wifi_scan_start(&configuration, false);
5. Decisionresult != ESP_OK
   True

   1. 1. Executelast_error = esp_err_to_name(result);
      2. Exit this functionreturn false;

   False

   Continue after this decision.

6. Executescan_entry_count = 0U;
7. Executescan_done = false;
8. Executescan_in_progress = true;
9. Executelast_error = "";
10. Exit this functionreturn true;

bool wifiServiceStartScan(void)
{
    if (!radio_started) {
        last_error = "RADIO OFF";
        return false;
    }
    if (scan_in_progress) return true;

    const wifi_scan_config_t configuration = {0};
    const esp_err_t result = esp_wifi_scan_start(&configuration, false);
    if (result != ESP_OK) {
        last_error = esp_err_to_name(result);
        return false;
    }
    scan_entry_count = 0U;
    scan_done = false;
    scan_in_progress = true;
    last_error = "";
    return true;
}

void wifiServiceUpdateScan(void)

1. Decision!scan_in_progress || !scan_done
   True

   1. Exit this functionreturn;

   False

   Continue after this decision.

2. Executewifi_ap_record_t records[WIFI_SCAN_MAX_NETWORKS] = {0};
3. Executeuint16_t record_count = WIFI_SCAN_MAX_NETWORKS;
4. Executeconst esp_err_t result = esp_wifi_scan_get_ap_records(&record_count, records);
5. Executescan_done = false;
6. Executescan_in_progress = false;
7. Decisionresult != ESP_OK
   True

   1. 1. Executelast_error = esp_err_to_name(result);
      2. Exit this functionreturn;

   False

   Continue after this decision.

8. Executescan_entry_count = record_count;
9. FOR loopsize_t index = 0; index < scan_entry_count; ++index

   Repeat body while the loop condition permits; then continue below.

   1. 1. Executememcpy(scan_entries[index].ssid, records[index].ssid, WIFI_SCAN_SSID_CHARS);
      2. Executescan_entries[index].ssid[WIFI_SCAN_SSID_CHARS] = '\0';
      3. Executescan_entries[index].rssi = records[index].rssi;

void wifiServiceUpdateScan(void)
{
    if (!scan_in_progress || !scan_done) return;

    wifi_ap_record_t records[WIFI_SCAN_MAX_NETWORKS] = {0};
    uint16_t record_count = WIFI_SCAN_MAX_NETWORKS;
    const esp_err_t result = esp_wifi_scan_get_ap_records(&record_count, records);
    scan_done = false;
    scan_in_progress = false;
    if (result != ESP_OK) {
        last_error = esp_err_to_name(result);
        return;
    }

    scan_entry_count = record_count;
    for (size_t index = 0; index < scan_entry_count; ++index) {
        memcpy(scan_entries[index].ssid, records[index].ssid, WIFI_SCAN_SSID_CHARS);
        scan_entries[index].ssid[WIFI_SCAN_SSID_CHARS] = '\0';
        scan_entries[index].rssi = records[index].rssi;
    }
}

bool wifiServiceScanInProgress(void)

1. Exit this functionreturn scan_in_progress;

bool wifiServiceScanInProgress(void)
{
    return scan_in_progress;
}

size_t wifiServiceScanCount(void)

1. Exit this functionreturn scan_entry_count;

size_t wifiServiceScanCount(void)
{
    return scan_entry_count;
}

const wifi_scan_entry_t *wifiServiceScanEntries(void)

1. Exit this functionreturn scan_entries;

const wifi_scan_entry_t *wifiServiceScanEntries(void)
{
    return scan_entries;
}

bool wifiServiceConnect(const char *ssid, const char *password)

Calls into this documentation:

1. Decisionssid == NULL || password == NULL || ssid[0] == '\0' || !wifiServiceStart()
   True

   1. Exit this functionreturn false;

   False

   Continue after this decision.

2. Executewifi_config_t configuration = {0};
3. Executestrncpy((char *)configuration.sta.ssid, ssid, sizeof(configuration.sta.ssid) - 1U);
4. Executestrncpy((char *)configuration.sta.password, password, sizeof(configuration.sta.password) - 1U);
5. Executeconst esp_err_t config_result = esp_wifi_set_config(WIFI_IF_STA, &configuration);
6. Decisionconfig_result != ESP_OK
   True

   1. 1. Executelast_error = esp_err_to_name(config_result);
      2. Exit this functionreturn false;

   False

   Continue after this decision.

7. Execute(void)esp_wifi_disconnect();
8. Executeconst esp_err_t connect_result = esp_wifi_connect();
9. Decisionconnect_result != ESP_OK
   True

   1. 1. Executelast_error = esp_err_to_name(connect_result);
      2. Exit this functionreturn false;

   False

   Continue after this decision.

10. Executeconnection_state = WIFI_CONNECTION_CONNECTING;
11. Executelast_error = "";
12. Exit this functionreturn true;

bool wifiServiceConnect(const char *ssid, const char *password)
{
    if (ssid == NULL || password == NULL || ssid[0] == '\0' || !wifiServiceStart()) return false;

    wifi_config_t configuration = {0};
    strncpy((char *)configuration.sta.ssid, ssid, sizeof(configuration.sta.ssid) - 1U);
    strncpy((char *)configuration.sta.password, password, sizeof(configuration.sta.password) - 1U);
    const esp_err_t config_result = esp_wifi_set_config(WIFI_IF_STA, &configuration);
    if (config_result != ESP_OK) {
        last_error = esp_err_to_name(config_result);
        return false;
    }

    (void)esp_wifi_disconnect();
    const esp_err_t connect_result = esp_wifi_connect();
    if (connect_result != ESP_OK) {
        last_error = esp_err_to_name(connect_result);
        return false;
    }
    connection_state = WIFI_CONNECTION_CONNECTING;
    last_error = "";
    return true;
}

wifi_connection_state_t wifiServiceConnectionState(void)

1. Exit this functionreturn connection_state;

wifi_connection_state_t wifiServiceConnectionState(void)
{
    return connection_state;
}

void wifiServiceRelease(void)

1. Decisionradio_started
   True

   1. Execute(void)esp_wifi_stop();

   False

   Continue after this decision.

2. Execute(void)esp_event_handler_instance_unregister(WIFI_EVENT, WIFI_EVENT_SCAN_DONE, scan_event_handler);
3. Execute(void)esp_event_handler_instance_unregister(WIFI_EVENT, WIFI_EVENT_STA_CONNECTED, connected_event_handler);
4. Execute(void)esp_event_handler_instance_unregister(WIFI_EVENT, WIFI_EVENT_STA_DISCONNECTED, disconnected_event_handler);
5. Execute(void)esp_event_handler_instance_unregister(IP_EVENT, IP_EVENT_STA_GOT_IP, got_ip_event_handler);
6. Decisionservice_state == WIFI_SERVICE_READY
   True

   1. Execute(void)esp_wifi_deinit();

   False

   Continue after this decision.

7. Decisionstation_interface != NULL
   True

   1. 1. Executeesp_netif_destroy_default_wifi(station_interface);
      2. Executestation_interface = NULL;

   False

   Continue after this decision.

8. Executeservice_state = WIFI_SERVICE_IDLE;
9. Executeradio_started = false;
10. Executescan_in_progress = false;
11. Executescan_done = false;
12. Executescan_entry_count = 0U;
13. Executeconnection_state = WIFI_CONNECTION_DISCONNECTED;
14. Executelast_error = "";

void wifiServiceRelease(void)
{
    if (radio_started) (void)esp_wifi_stop();
    (void)esp_event_handler_instance_unregister(WIFI_EVENT, WIFI_EVENT_SCAN_DONE,
                                                scan_event_handler);
    (void)esp_event_handler_instance_unregister(WIFI_EVENT, WIFI_EVENT_STA_CONNECTED,
                                                connected_event_handler);
    (void)esp_event_handler_instance_unregister(WIFI_EVENT, WIFI_EVENT_STA_DISCONNECTED,
                                                disconnected_event_handler);
    (void)esp_event_handler_instance_unregister(IP_EVENT, IP_EVENT_STA_GOT_IP,
                                                got_ip_event_handler);
    if (service_state == WIFI_SERVICE_READY) (void)esp_wifi_deinit();
    if (station_interface != NULL) {
        esp_netif_destroy_default_wifi(station_interface);
        station_interface = NULL;
    }
    service_state = WIFI_SERVICE_IDLE;
    radio_started = false;
    scan_in_progress = false;
    scan_done = false;
    scan_entry_count = 0U;
    connection_state = WIFI_CONNECTION_DISCONNECTED;
    last_error = "";
}

wifi_service_state_t wifiServiceState(void)

1. Exit this functionreturn service_state;

wifi_service_state_t wifiServiceState(void)
{
    return service_state;
}

bool wifiServiceRadioStarted(void)

1. Exit this functionreturn radio_started;

bool wifiServiceRadioStarted(void)
{
    return radio_started;
}

const char *wifiServiceError(void)

1. Exit this functionreturn last_error;

const char *wifiServiceError(void)
{
    return last_error;
}