example of HTTP server in AP mode?

[marchingband]

Can anyone direct me to a working example of a simple HTTP server, which uses AP mode?
It seems like a powerful feature of ESP32 but I havn't been able to locate a working example yet.
I would like to be able to connect to the ESP32 network on another device, open a web browser, navigate to some address, and have ESP32 serve a webpage from its flash memory.

[karlo.verde.13]

Hey there!

This link shows a tutorial about what you are looking for: http://www.lucadentella.it/en/2018/01/2 ... ta-softap/. Nevertheless, this example uses the Netconn API.

If you want to use the esp_http_server.h component, there is no example implemented with SoftAp, yet.

[bluesensing]

i am also very keen on such an working example. reading html from a sdcard

regards from berlin
gerhard

[karlo.verde.13]

Hey there!

Since there is no example of what you are looking for, I decided to create one.

NOTES

• Some header files are unnecessary.
• This example also includes IP configuration.
• The URI handler has minimal code in this example but you can define it as you wish.
• If you have an Android device, I recommend that you use this app: https://play.google.com/store/apps/deta ... tprequests.

Code: [Select all] [Expand/Collapse]

1. #include "string.h"
2.  
3. #include "freertos/FreeRTOS.h"
4. #include "freertos/task.h"
5. #include "freertos/event_groups.h"
6. #include "esp_wifi.h"
7. #include "esp_system.h"
8. #include "esp_event.h"
9. #include "esp_event_loop.h"
10. #include "esp_log.h"
11. #include "nvs_flash.h"
12. #include "esp_http_server.h"
13.  
14. #define SOFT_AP_SSID "ESP32 SoftAP"
15. #define SOFT_AP_PASSWORD "Password"
16.  
17. #define SOFT_AP_IP_ADDRESS_1 192
18. #define SOFT_AP_IP_ADDRESS_2 168
19. #define SOFT_AP_IP_ADDRESS_3 5
20. #define SOFT_AP_IP_ADDRESS_4 18
21.  
22. #define SOFT_AP_GW_ADDRESS_1 192
23. #define SOFT_AP_GW_ADDRESS_2 168
24. #define SOFT_AP_GW_ADDRESS_3 5
25. #define SOFT_AP_GW_ADDRESS_4 20
26.  
27. #define SOFT_AP_NM_ADDRESS_1 255
28. #define SOFT_AP_NM_ADDRESS_2 255
29. #define SOFT_AP_NM_ADDRESS_3 255
30. #define SOFT_AP_NM_ADDRESS_4 0
31.  
32. #define SERVER_PORT 3500
33. #define HTTP_METHOD HTTP_POST
34. #define URI_STRING "/test"
35.  
36. static httpd_handle_t httpServerInstance = NULL;
37.  
38. static esp_err_t methodHandler(httpd_req_t* httpRequest){
39.     ESP_LOGI("HANDLER","This is the handler for the <%s> URI", httpRequest->uri);
40.     return ESP_OK;
41. }
42.  
43. static httpd_uri_t testUri = {
44.     .uri       = URI_STRING,
45.     .method    = HTTP_METHOD,
46.     .handler   = methodHandler,
47.     .user_ctx  = NULL,
48. };
49.  
50. static void startHttpServer(void){
51.     httpd_config_t httpServerConfiguration = HTTPD_DEFAULT_CONFIG();
52.     httpServerConfiguration.server_port = SERVER_PORT;
53.     if(httpd_start(&httpServerInstance, &httpServerConfiguration) == ESP_OK){
54.         ESP_ERROR_CHECK(httpd_register_uri_handler(httpServerInstance, &testUri));
55.     }
56. }
57.  
58. static void stopHttpServer(void){
59.     if(httpServerInstance != NULL){
60.         ESP_ERROR_CHECK(httpd_stop(httpServerInstance));
61.     }
62. }
63.  
64. static esp_err_t wifiEventHandler(void* userParameter, system_event_t *event) {
65.     switch(event->event_id){
66.     case SYSTEM_EVENT_AP_STACONNECTED:
67.         startHttpServer();
68.         break;
69.     case SYSTEM_EVENT_AP_STADISCONNECTED:
70.         stopHttpServer();
71.         break;
72.     default:
73.         break;
74.     }
75.     return ESP_OK;
76. }
77.  
78. static void launchSoftAp(){
79.     ESP_ERROR_CHECK(nvs_flash_init());
80.     tcpip_adapter_init();
81.     ESP_ERROR_CHECK(tcpip_adapter_dhcps_stop(TCPIP_ADAPTER_IF_AP));
82.     tcpip_adapter_ip_info_t ipAddressInfo;
83.     memset(&ipAddressInfo, 0, sizeof(ipAddressInfo));
84.     IP4_ADDR(
85.         &ipAddressInfo.ip,
86.         SOFT_AP_IP_ADDRESS_1,
87.         SOFT_AP_IP_ADDRESS_2,
88.         SOFT_AP_IP_ADDRESS_3,
89.         SOFT_AP_IP_ADDRESS_4);
90.     IP4_ADDR(
91.         &ipAddressInfo.gw,
92.         SOFT_AP_GW_ADDRESS_1,
93.         SOFT_AP_GW_ADDRESS_2,
94.         SOFT_AP_GW_ADDRESS_3,
95.         SOFT_AP_GW_ADDRESS_4);
96.     IP4_ADDR(
97.         &ipAddressInfo.netmask,
98.         SOFT_AP_NM_ADDRESS_1,
99.         SOFT_AP_NM_ADDRESS_2,
100.         SOFT_AP_NM_ADDRESS_3,
101.         SOFT_AP_NM_ADDRESS_4);
102.     ESP_ERROR_CHECK(tcpip_adapter_set_ip_info(TCPIP_ADAPTER_IF_AP, &ipAddressInfo));
103.     ESP_ERROR_CHECK(tcpip_adapter_dhcps_start(TCPIP_ADAPTER_IF_AP));
104.     ESP_ERROR_CHECK(esp_event_loop_init(wifiEventHandler, NULL));
105.     wifi_init_config_t wifiConfiguration = WIFI_INIT_CONFIG_DEFAULT();
106.     ESP_ERROR_CHECK(esp_wifi_init(&wifiConfiguration));
107.     ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_AP));
108.     wifi_config_t apConfiguration = {
109.         .ap = {
110.             .ssid = SOFT_AP_SSID,
111.             .password = SOFT_AP_PASSWORD,
112.             .ssid_len = 0,
113.             //.channel = default,
114.             .authmode = WIFI_AUTH_WPA2_PSK,
115.             .ssid_hidden = 0,
116.             .max_connection = 1,
117.             .beacon_interval = 150,
118.         },
119.     };
120.     ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_AP, &apConfiguration));
121.     ESP_ERROR_CHECK(esp_wifi_set_storage(WIFI_STORAGE_RAM));
122.     ESP_ERROR_CHECK(esp_wifi_start());
123. }
124.  
125. void app_main(void){
126.     launchSoftAp();
127.     while(1) vTaskDelay(10);
128. }

GeSHi © Codebox Plus Extension

Hope it helps
Best regards
Verde

[marchingband]

Amazing. Thanks so much Verde!

[phatpaul]

Here's a http server working out of the box. Lot's of features and examples.
https://github.com/chmorgan/esphttpd-freertos

[marchingband]

unfortunately the suggestions above do not work for esp-idf version 4.
Is anyone able to suggest code to run a softAP http server in v4.1?
or perhaps able to port the code?

[stock86c]

hi
cant share the code, so i will just explain the concepts to get it to work. Literally just slapped these two examples together.
https://github.com/espressif/esp-idf/tr ... ted/softAP
https://github.com/espressif/esp-idf/tr ... ver/simple

as for the "ESP_ERROR_CHECK(example_connect());" in the main of simple httpserver, just replace this example_connect with the init_softAP function from the softAP example. Some points to note:
1.Try to put all the functions in one page. somehow the definitions in different pages seem to cause issues.
2. Use the default settings, the ssid and passwd. Dont do fancy stuffs yet.
3. after combining and compiling, try to solve the errors one by one.

hope it helps.

[Ashvajit Prasad]

Hi,
By building the above code for http in softAP mode, I am getting this error " C:/msys32/home/APRASAD/esp/esp-idf_1/esp-idf-template/main/main.c:105:21: error: implicit declaration of function 'esp_event_init' [-Werror=implicit-function-declaration]
ESP_ERROR_CHECK(esp_event_init(wifiEventHandler, NULL)); ".

make[1]: *** [/home/APRASAD/esp/esp-idf/make/component_wrapper.mk:292: main.o] Error 1
make: *** [C:\msys32\home\APRASAD\esp\esp-idf/make/project.mk:584: component-main-build] Error 2
I am not getting these error in my other codes.
What can I do to resolve this ?
I recently started working with esp so, I am not familiar with this.

[Palonso]

hi
cant share the code, so i will just explain the concepts to get it to work. Literally just slapped these two examples together.
https://github.com/espressif/esp-idf/tr ... ted/softAP
https://github.com/espressif/esp-idf/tr ... ver/simple

as for the "ESP_ERROR_CHECK(example_connect());" in the main of simple httpserver, just replace this example_connect with the init_softAP function from the softAP example. Some points to note:
1.Try to put all the functions in one page. somehow the definitions in different pages seem to cause issues.
2. Use the default settings, the ssid and passwd. Dont do fancy stuffs yet.
3. after combining and compiling, try to solve the errors one by one.

hope it helps.

Thanks, it did.

Here I'm leaving the example code I managed to make. Altough, I encourage everybody to follow the steps stock86c mentioned to truly understand the code (maybe you might end on a better code).

Code: Select all

#include <esp_wifi.h>
#include <esp_event.h>
#include <esp_log.h>
#include <esp_system.h>
#include <nvs_flash.h>
#include <sys/param.h>
#include "nvs_flash.h"
//#include "tcpip_adapter.h"
#include "esp_netif.h"
#include "esp_eth.h"
//#include "protocol_examples_common.h"

#include <esp_http_server.h>

#include <string.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.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"

/* The examples use WiFi configuration that you can set via project configuration menu.

   If you'd rather not, just change the below entries to strings with
   the config you want - ie #define EXAMPLE_WIFI_SSID "mywifissid"
*/
#define EXAMPLE_ESP_WIFI_SSID      CONFIG_ESP_WIFI_SSID
#define EXAMPLE_ESP_WIFI_PASS      CONFIG_ESP_WIFI_PASSWORD
#define EXAMPLE_MAX_STA_CONN       CONFIG_ESP_MAX_STA_CONN

/* A simple example that demonstrates how to create GET and POST
 * handlers for the web server.
 */

static const char *TAG = "wifi_AP_WEBserver";

//------------------------------------------------------------------------------
/* An HTTP GET handler */
static esp_err_t hello_get_handler(httpd_req_t *req)
{
    char*  buf;
    size_t buf_len;

    /* Get header value string length and allocate memory for length + 1,
     * extra byte for null termination */
    buf_len = httpd_req_get_hdr_value_len(req, "Host") + 1;
    if (buf_len > 1)
    {
        buf = malloc(buf_len);
        /* Copy null terminated value string into buffer */
        if (httpd_req_get_hdr_value_str(req, "Host", buf, buf_len) == ESP_OK)
        {
            ESP_LOGI(TAG, "Found header => Host: %s", buf);
        }
        free(buf);
    }

    buf_len = httpd_req_get_hdr_value_len(req, "Test-Header-2") + 1;
    if (buf_len > 1)
    {
        buf = malloc(buf_len);
        if (httpd_req_get_hdr_value_str(req, "Test-Header-2", buf, buf_len) == ESP_OK)
        {
            ESP_LOGI(TAG, "Found header => Test-Header-2: %s", buf);
        }
        free(buf);
    }

    buf_len = httpd_req_get_hdr_value_len(req, "Test-Header-1") + 1;
    if (buf_len > 1)
    {
        buf = malloc(buf_len);
        if (httpd_req_get_hdr_value_str(req, "Test-Header-1", buf, buf_len) == ESP_OK)
        {
            ESP_LOGI(TAG, "Found header => Test-Header-1: %s", buf);
        }
        free(buf);
    }

    /* Read URL query string length and allocate memory for length + 1,
     * extra byte for null termination */
    buf_len = httpd_req_get_url_query_len(req) + 1;
    if (buf_len > 1) {
        buf = malloc(buf_len);
        if (httpd_req_get_url_query_str(req, buf, buf_len) == ESP_OK)
        {
            ESP_LOGI(TAG, "Found URL query => %s", buf);
            char param[32];
            /* Get value of expected key from query string */
            if (httpd_query_key_value(buf, "query1", param, sizeof(param)) == ESP_OK)
            {
                ESP_LOGI(TAG, "Found URL query parameter => query1=%s", param);
            }
            if (httpd_query_key_value(buf, "query3", param, sizeof(param)) == ESP_OK)
            {
                ESP_LOGI(TAG, "Found URL query parameter => query3=%s", param);
            }
            if (httpd_query_key_value(buf, "query2", param, sizeof(param)) == ESP_OK)
            {
                ESP_LOGI(TAG, "Found URL query parameter => query2=%s", param);
            }
        }
        free(buf);
    }

    /* Set some custom headers */
    httpd_resp_set_hdr(req, "Custom-Header-1", "Custom-Value-1");
    httpd_resp_set_hdr(req, "Custom-Header-2", "Custom-Value-2");

    /* Send response with custom headers and body set as the
     * string passed in user context*/
    const char* resp_str = (const char*) req->user_ctx;
    httpd_resp_send(req, resp_str, strlen(resp_str));

    /* After sending the HTTP response the old HTTP request
     * headers are lost. Check if HTTP request headers can be read now. */
    if (httpd_req_get_hdr_value_len(req, "Host") == 0)
    {
        ESP_LOGI(TAG, "Request headers lost");
    }
    return ESP_OK;
}

static const httpd_uri_t hello = {
    .uri       = "/hello",
    .method    = HTTP_GET,
    .handler   = hello_get_handler,
    /* Let's pass response string in user
     * context to demonstrate it's usage */
    .user_ctx  = "Hello World!"
};

/* An HTTP POST handler */
static esp_err_t echo_post_handler(httpd_req_t *req)
{
    char buf[100];
    int ret, remaining = req->content_len;

    while (remaining > 0) {
        /* Read the data for the request */
        if ((ret = httpd_req_recv(req, buf,
                        MIN(remaining, sizeof(buf)))) <= 0) {
            if (ret == HTTPD_SOCK_ERR_TIMEOUT) {
                /* Retry receiving if timeout occurred */
                continue;
            }
            return ESP_FAIL;
        }

        /* Send back the same data */
        httpd_resp_send_chunk(req, buf, ret);
        remaining -= ret;

        /* Log data received */
        ESP_LOGI(TAG, "=========== RECEIVED DATA ==========");
        ESP_LOGI(TAG, "%.*s", ret, buf);
        ESP_LOGI(TAG, "====================================");
    }

    // End response
    httpd_resp_send_chunk(req, NULL, 0);
    return ESP_OK;
}

static const httpd_uri_t echo = {
    .uri       = "/echo",
    .method    = HTTP_POST,
    .handler   = echo_post_handler,
    .user_ctx  = NULL
};

/* This handler allows the custom error handling functionality to be
 * tested from client side. For that, when a PUT request 0 is sent to
 * URI /ctrl, the /hello and /echo URIs are unregistered and following
 * custom error handler http_404_error_handler() is registered.
 * Afterwards, when /hello or /echo is requested, this custom error
 * handler is invoked which, after sending an error message to client,
 * either closes the underlying socket (when requested URI is /echo)
 * or keeps it open (when requested URI is /hello). This allows the
 * client to infer if the custom error handler is functioning as expected
 * by observing the socket state.
 */
esp_err_t http_404_error_handler(httpd_req_t *req, httpd_err_code_t err)
{
    if (strcmp("/hello", req->uri) == 0) {
        httpd_resp_send_err(req, HTTPD_404_NOT_FOUND, "/hello URI is not available");
        /* Return ESP_OK to keep underlying socket open */
        return ESP_OK;
    } else if (strcmp("/echo", req->uri) == 0) {
        httpd_resp_send_err(req, HTTPD_404_NOT_FOUND, "/echo URI is not available");
        /* Return ESP_FAIL to close underlying socket */
        return ESP_FAIL;
    }
    /* For any other URI send 404 and close socket */
    httpd_resp_send_err(req, HTTPD_404_NOT_FOUND, "Some 404 error message");
    return ESP_FAIL;
}

/* An HTTP PUT handler. This demonstrates realtime
 * registration and deregistration of URI handlers
 */
static esp_err_t ctrl_put_handler(httpd_req_t *req)
{
    char buf;
    int ret;

    if ((ret = httpd_req_recv(req, &buf, 1)) <= 0) {
        if (ret == HTTPD_SOCK_ERR_TIMEOUT) {
            httpd_resp_send_408(req);
        }
        return ESP_FAIL;
    }

    if (buf == '0') {
        /* URI handlers can be unregistered using the uri string */
        ESP_LOGI(TAG, "Unregistering /hello and /echo URIs");
        httpd_unregister_uri(req->handle, "/hello");
        httpd_unregister_uri(req->handle, "/echo");
        /* Register the custom error handler */
        httpd_register_err_handler(req->handle, HTTPD_404_NOT_FOUND, http_404_error_handler);
    }
    else {
        ESP_LOGI(TAG, "Registering /hello and /echo URIs");
        httpd_register_uri_handler(req->handle, &hello);
        httpd_register_uri_handler(req->handle, &echo);
        /* Unregister custom error handler */
        httpd_register_err_handler(req->handle, HTTPD_404_NOT_FOUND, NULL);
    }

    /* Respond with empty body */
    httpd_resp_send(req, NULL, 0);
    return ESP_OK;
}

static const httpd_uri_t ctrl = {
    .uri       = "/ctrl",
    .method    = HTTP_PUT,
    .handler   = ctrl_put_handler,
    .user_ctx  = NULL
};

static httpd_handle_t start_webserver(void)
{
    httpd_handle_t server = NULL;
    httpd_config_t config = HTTPD_DEFAULT_CONFIG();

    // Start the httpd server
    ESP_LOGI(TAG, "Starting server on port: '%d'", config.server_port);
    if (httpd_start(&server, &config) == ESP_OK) {
        // Set URI handlers
        ESP_LOGI(TAG, "Registering URI handlers");
        httpd_register_uri_handler(server, &hello);
        httpd_register_uri_handler(server, &echo);
        httpd_register_uri_handler(server, &ctrl);
        return server;
    }

    ESP_LOGI(TAG, "Error starting server!");
    return NULL;
}
/*
static void stop_webserver(httpd_handle_t server)
{
    // Stop the httpd server
    httpd_stop(server);
}
*/
/*
static void disconnect_handler(void* arg, esp_event_base_t event_base, int32_t event_id, void* event_data)
{
    httpd_handle_t* server = (httpd_handle_t*) arg;
    if (*server) {
        ESP_LOGI(TAG, "Stopping webserver");
        stop_webserver(*server);
        *server = NULL;
    }
}
*/
/*
static void connect_handler(void* arg, esp_event_base_t event_base, int32_t event_id, void* event_data)
{
    httpd_handle_t* server = (httpd_handle_t*) arg;
    if (*server == NULL) {
        ESP_LOGI(TAG, "Starting webserver");
        *server = start_webserver();
    }
}
*/
//------------------------------------------------------------------------------

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;
        ESP_LOGI(TAG, "station "MACSTR" join, AID=%d",
                 MAC2STR(event->mac), event->aid);
    } else if (event_id == WIFI_EVENT_AP_STADISCONNECTED) {
        wifi_event_ap_stadisconnected_t* event = (wifi_event_ap_stadisconnected_t*) event_data;
        ESP_LOGI(TAG, "station "MACSTR" leave, AID=%d",
                 MAC2STR(event->mac), event->aid);
    }
}

esp_err_t wifi_init_softap(void)
{
    //esp_netif_init();
    //ESP_ERROR_CHECK(esp_event_loop_create_default());
    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_register(WIFI_EVENT, ESP_EVENT_ANY_ID, &wifi_event_handler, NULL));

    wifi_config_t wifi_config = {
        .ap = {
            .ssid = EXAMPLE_ESP_WIFI_SSID,
            .ssid_len = strlen(EXAMPLE_ESP_WIFI_SSID),
            .password = EXAMPLE_ESP_WIFI_PASS,
            .max_connection = EXAMPLE_MAX_STA_CONN,
            .authmode = WIFI_AUTH_WPA_WPA2_PSK
        },
    };
    if (strlen(EXAMPLE_ESP_WIFI_PASS) == 0) {
        wifi_config.ap.authmode = WIFI_AUTH_OPEN;
    }

    ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_AP));
    ESP_ERROR_CHECK(esp_wifi_set_config(ESP_IF_WIFI_AP, &wifi_config));
    ESP_ERROR_CHECK(esp_wifi_start());

    ESP_LOGI(TAG, "wifi_init_softap finished. SSID:%s password:%s",
             EXAMPLE_ESP_WIFI_SSID, EXAMPLE_ESP_WIFI_PASS);
    return ESP_OK;
}
//------------------------------------------------------------------------------

void app_main(void)
{
    httpd_handle_t server = NULL;


    ESP_LOGI(TAG, "NVS init");
    ESP_ERROR_CHECK(nvs_flash_init());
    //tcpip_adapter_init();
    esp_netif_init();

    ESP_LOGI(TAG, "Eventloop create");
    ESP_ERROR_CHECK(esp_event_loop_create_default());

    /* This helper function configures Wi-Fi or Ethernet, as selected in menuconfig.
     * Read "Establishing Wi-Fi or Ethernet Connection" section in
     * examples/protocols/README.md for more information about this function.
     */
    //ESP_ERROR_CHECK(example_connect());
    ESP_LOGI(TAG, "init softAP");
    ESP_ERROR_CHECK(wifi_init_softap());

    /* Register event handlers to stop the server when Wi-Fi or Ethernet is disconnected,
     * and re-start it upon connection.
     */
#ifdef CONFIG_EXAMPLE_CONNECT_WIFI
    ESP_ERROR_CHECK(esp_event_handler_register(IP_EVENT, IP_EVENT_STA_GOT_IP, &connect_handler, &server));
    ESP_ERROR_CHECK(esp_event_handler_register(WIFI_EVENT, WIFI_EVENT_STA_DISCONNECTED, &disconnect_handler, &server));
#endif // CONFIG_EXAMPLE_CONNECT_WIFI
#ifdef CONFIG_EXAMPLE_CONNECT_ETHERNET
    ESP_ERROR_CHECK(esp_event_handler_register(IP_EVENT, IP_EVENT_ETH_GOT_IP, &connect_handler, &server));
    ESP_ERROR_CHECK(esp_event_handler_register(ETH_EVENT, ETHERNET_EVENT_DISCONNECTED, &disconnect_handler, &server));
#endif // CONFIG_EXAMPLE_CONNECT_ETHERNET

    /* Start the server for the first time */
    server = start_webserver();
}

A small detail, I commented some functions of the example codes told just to avoid warnings so this code might fail in certain conditions. Anyway they are still (commented) on the code, uncomment them if you have to.

Also, this code was compiled over the latest version, using the esp_netif library, so make sure to "update" your IDF or uncomment the tcpip_adapter library and fix what's necessary.