ESP IDF: Station + soft-AP (WIFI_MODE_APSTA) There is no working example - why? Where is?

[ryanf55]

In follow up to my previous post, adding in a few time delays between tearing down AP and starting STA helped. Also, I turned off nvs_flash for WiFi as I think that was causing the corruption when starting in STA mode.

Here's my menuconfig changes.

[OFF ] Wi-Fi -> WiFi NVS flash
[OFF] Phy ->Store phy calibration data in NVS

I was seeing brownouts earlier in the transition and increased
[2.7v] * ESP32-specific -> Brownout Voltage Level

For debugging
[On] WiFi -> Enable Wifi debug Log
[Verbose] WiFi -> WiFi debug log level

If anyone has seen similar issues when trying to use both WiFi modes, please share if you had any better resolutions.

[mcmega]

This works well for string parameters.

Code: Select all

strncpy((char *)ap_config.ap.password, configDev.apPSK, strlen(configDev.apPSK));

Tell me, how to properly set the WiFi channel in the Access Point mode?

[ESP_Sprite]

This works well for string parameters.

Code: Select all

strncpy((char *)ap_config.ap.password, configDev.apPSK, strlen(configDev.apPSK));

That is... I don't think you understand what that does exactly and why one would use strncpy. Str[n]cpy already stops copies as much bytes as are in configDev.aPSK; to specifically set it as a limit with the strlen parameter does nothing useful. In contrast, if configDev.apPSK is too large, you can overwrite the memory of ap_config and corrupt stuff and make your app crash and your strncpy will do nothing to stop it. Correct method is:

Code: Select all

strncpy((char *)ap_config.ap.password, configDev.apPSK, sizeof(ap_config.ap.password));

This will copy bytes up to either the length of configDev.apPSK or until it doesn't fit into ap_config.ap.password anymore, whichever happens earlier.

Wrt your question: as the docs indicate, the ap_config.ap struct has a channel member, so it would be

Code: Select all

ap_config.ap.channel=4;

[pranjal.jamdade]

Hello,
Did any one find a proper solution for accessing both AP and STA mode ? Once AP mode is getting after receving SSID+PASS , i am facing issue for station mode.
If any one could suggest please help me out.

Thanks in advance

[Ritesh]

Hello,
Did any one find a proper solution for accessing both AP and STA mode ? Once AP mode is getting after receving SSID+PASS , i am facing issue for station mode.
If any one could suggest please help me out.

Thanks in advance

Is your issue has been resolved or still looking for solution?

[pranjal.jamdade]

Hello ,

Still Looking for Proper Solution for it.


Thanks & Regards
Pranjal

[Ritesh]

Hello ,

Still Looking for Proper Solution for it.


Thanks & Regards
Pranjal

Any luck for working or still looking for solution. Let me know if need any help from my side.

[monkeyinapocket]

Hi,

i'm also looking for a good solution, it would be great if you could just stop "offering your help" and provide a simple example instead because you said it would work....

With the current exmaples it is/was not possible for me to provide a SoftAP (that worked) and also to connect to a available WiFi.

It would be awesome if you could just share your proposed working snippets.

Thanks in advance.

Best Thomas

[Ritesh]

Hi,

i'm also looking for a good solution, it would be great if you could just stop "offering your help" and provide a simple example instead because you said it would work....

With the current exmaples it is/was not possible for me to provide a SoftAP (that worked) and also to connect to a available WiFi.

It would be awesome if you could just share your proposed working snippets.

Thanks in advance.

Best Thomas

Hello

Can you please share me example which you are trying and facing issues at your end?

so that i will look it at my end and help for the same.

[monkeyinapocket]

Sorry, it took me some time to prepare the example. The following code snipped should be able to create an AP an also connect to a available WiFi - it would be great if you can tell me, what i'm doing wrong.

Thanks in advance,

Best Monkeyinapocket

Code: Select all

#include <cstring>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/event_groups.h"

#include "esp_system.h"
#include "esp_wifi.h"
#include "esp_event.h"
#include "esp_log.h"
#include "nvs_flash.h"

#include "lwip/err.h"
#include "lwip/sys.h"

#define WIFI_CONNECTED_BIT BIT0
#define WIFI_FAIL_BIT      BIT1

static const char *TAG = "test";
static EventGroupHandle_t s_wifi_event_group;
static wifi_config_t wifi_config;

static void wifi_event_handler(void* arg, esp_event_base_t event_base,
                               int32_t event_id, void* event_data)
{
    if (event_id == WIFI_EVENT_AP_STACONNECTED) {
        wifi_event_ap_staconnected_t* event = (wifi_event_ap_staconnected_t*) event_data;

    } else if (event_id == WIFI_EVENT_AP_STADISCONNECTED) {
        wifi_event_ap_stadisconnected_t* event = (wifi_event_ap_stadisconnected_t*) event_data;
    }
}

void wifi_init_softap(void)
{
    esp_netif_create_default_wifi_ap();

    wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
    ESP_ERROR_CHECK(esp_wifi_init(&cfg));

    ESP_ERROR_CHECK(esp_event_handler_instance_register(WIFI_EVENT,
                                                        ESP_EVENT_ANY_ID,
                                                        &wifi_event_handler,
                                                        NULL,
                                                        NULL));

    const char* ssid = "ESPTest";
    const char* pw = "testtest";
    std::strcpy(reinterpret_cast<char *>(wifi_config.ap.ssid), ssid);
    std::strcpy(reinterpret_cast<char *>(wifi_config.ap.password), pw);
    wifi_config.ap.ssid_len = static_cast<uint8_t>(strlen(ssid));
    wifi_config.ap.channel = 1;
    wifi_config.ap.max_connection = 1;
    wifi_config.ap.authmode = WIFI_AUTH_WPA_WPA2_PSK;

    if (strlen(pw) == 0) {
        wifi_config.ap.authmode = WIFI_AUTH_OPEN;
    }

    ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_APSTA));
    ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_AP, &wifi_config));
    ESP_ERROR_CHECK(esp_wifi_start());
}

static int s_retry_num = 0;
static int maxRetry = 5;
static void sta_event_handler(void* arg, esp_event_base_t event_base,
                          int32_t event_id, void* event_data)
{
    if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_START) {
        esp_wifi_connect();
    } else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_DISCONNECTED) {
        if (s_retry_num < maxRetry) {
            esp_wifi_connect();
            s_retry_num++;
            ESP_LOGI(TAG, "retry to connect to the AP");
        } else {
            xEventGroupSetBits(s_wifi_event_group, WIFI_FAIL_BIT);
        }
        ESP_LOGI(TAG,"connect to the AP fail");
    } else if (event_base == IP_EVENT && event_id == IP_EVENT_STA_GOT_IP) {
        ip_event_got_ip_t* event = (ip_event_got_ip_t*) event_data;
        ESP_LOGI(TAG, "got ip:" IPSTR, IP2STR(&event->ip_info.ip));
        s_retry_num = 0;
        xEventGroupSetBits(s_wifi_event_group, WIFI_CONNECTED_BIT);
    }
}

void wifi_init_sta(void)
{
    s_wifi_event_group = xEventGroupCreate();
    esp_netif_create_default_wifi_sta();

    wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
    ESP_ERROR_CHECK(esp_wifi_init(&cfg));

    esp_event_handler_instance_t instance_any_id;
    esp_event_handler_instance_t instance_got_ip;
    ESP_ERROR_CHECK(esp_event_handler_instance_register(WIFI_EVENT,
                                                        ESP_EVENT_ANY_ID,
                                                        &sta_event_handler,
                                                        NULL,
                                                        &instance_any_id));
    ESP_ERROR_CHECK(esp_event_handler_instance_register(IP_EVENT,
                                                        IP_EVENT_STA_GOT_IP,
                                                        &sta_event_handler,
                                                        NULL,
                                                        &instance_got_ip));

    const char* ssid = "TestSSID";
    const char* pw = "testtest";
    std::strcpy(reinterpret_cast<char *>(wifi_config.sta.ssid), ssid);
    std::strcpy(reinterpret_cast<char *>(wifi_config.sta.password), pw);
    wifi_config.sta.threshold.authmode = WIFI_AUTH_WPA2_PSK;
    wifi_config.sta.channel = 2;
    wifi_config.sta.pmf_cfg.capable = true;
    wifi_config.sta.pmf_cfg.required = false;

    ESP_LOGI(TAG, "Test -> %s %s.", wifi_config.sta.ssid, wifi_config.sta.password);

    ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA, &wifi_config) );
    //ESP_ERROR_CHECK(esp_wifi_start());

    ESP_LOGI(TAG, "wifi_init_sta finished.");

    /* Waiting until either the connection is established (WIFI_CONNECTED_BIT) or connection failed for the maximum
     * number of re-tries (WIFI_FAIL_BIT). The bits are set by event_handler() (see above) */
    EventBits_t bits = xEventGroupWaitBits(s_wifi_event_group,
                                           WIFI_CONNECTED_BIT | WIFI_FAIL_BIT,
                                           pdFALSE,
                                           pdFALSE,
                                           portMAX_DELAY);

    /* xEventGroupWaitBits() returns the bits before the call returned, hence we can test which event actually
     * happened. */
    if (bits & WIFI_CONNECTED_BIT) {
        ESP_LOGI(TAG, "connected to ap");
    } else if (bits & WIFI_FAIL_BIT) {
        ESP_LOGI(TAG, "Failed to connect");
    } else {
        ESP_LOGE(TAG, "UNEXPECTED EVENT");
    }

    /* The event will not be processed after unregister */
    ESP_ERROR_CHECK(esp_event_handler_instance_unregister(IP_EVENT, IP_EVENT_STA_GOT_IP, instance_got_ip));
    ESP_ERROR_CHECK(esp_event_handler_instance_unregister(WIFI_EVENT, ESP_EVENT_ANY_ID, instance_any_id));
    vEventGroupDelete(s_wifi_event_group);
}

extern "C" void app_main(void)
{
    //Initialize NVS
    esp_err_t ret = nvs_flash_init();
    if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {
        ESP_ERROR_CHECK(nvs_flash_erase());
        ret = nvs_flash_init();
    }
    ESP_ERROR_CHECK(ret);

    ESP_ERROR_CHECK(esp_netif_init());
    ESP_ERROR_CHECK(esp_event_loop_create_default());

   wifi_init_softap();

   vTaskDelay(10000);

   wifi_init_sta();
}