I'm doing project using ESP32 C3 is access point, config as Http Server. My laptop will access wifi from ESP32 and send data through HTTP POST.
But when I use Postmand to testing. The problem is "HTTP 404.0 - Not Found" although I register uri POST and GET at ESP32 code.
I tried at framework 4.4.6 and 5.1.2 but can't solve problem. Attachement file is problem from Postman
Code: Select all
/* Simple Access Point with HTTP Server Example
Wi-Fi SoftAP Example + Simple HTTPD Server Example
This example code is in the Public Domain (or CC0 licensed, at your option.)
Unless required by applicable law or agreed to in writing, this
software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
CONDITIONS OF ANY KIND, either express or implied.
*/
#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 "esp_netif.h"
#include "esp_eth.h"
#include "esp_mac.h"
#include "esp_tls_crypto.h"
#include <esp_http_server.h>
#include <string.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_system.h"
#include "lwip/err.h"
#include "lwip/sys.h"
#include "esp_wifi_types.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 "ESP32" //CONFIG_ESP_WIFI_SSID
#define EXAMPLE_ESP_WIFI_PASS "mypassword" //CONFIG_ESP_WIFI_PASSWORD
#define EXAMPLE_MAX_STA_CONN 5 //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, HTTPD_RESP_USE_STRLEN);
/* 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 PostMan"
};
/* 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(req, NULL, 0);
return ESP_OK;
}
static const httpd_uri_t echo = {
.uri = "/post",
.method = HTTP_POST,
.handler = echo_post_handler,
.user_ctx = "Hello Postman!"
};
/* 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;
}
static httpd_handle_t start_webserver(void)
{
httpd_handle_t server = NULL;
httpd_config_t config = HTTPD_DEFAULT_CONFIG();
config.server_port=3500;
config.lru_purge_enable = true;
// 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");
ESP_ERROR_CHECK(httpd_register_uri_handler(server, &hello));
ESP_ERROR_CHECK(httpd_register_uri_handler(server, &echo));
ESP_LOGI(TAG, "Registering URI OK");
//httpd_register_basic_auth(server);
return server;
}
ESP_LOGI(TAG, "Error starting server!");
return NULL;
}
static esp_err_t stop_webserver(httpd_handle_t server)
{
// Stop the httpd server
return 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");
if (stop_webserver(*server) == ESP_OK) {
*server = NULL;
} else {
ESP_LOGE(TAG, "Failed to stop http server");
}
}
}
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_create_default_wifi_ap();
ESP_LOGI(TAG, "Start Init Wifi");
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)
{
static httpd_handle_t server = NULL;
ESP_LOGI(TAG, "NVS init");
ESP_ERROR_CHECK(nvs_flash_init());
ESP_ERROR_CHECK(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_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();
if (server== NULL) {
ESP_LOGE(TAG, "Failed to start server. Restarting...");
//esp_restart();
}
}Code: Select all
I (0) cpu_start: App cpu up.
I (401) cpu_start: Pro cpu start user code
I (401) cpu_start: cpu freq: 160000000
I (401) cpu_start: Application information:
I (406) cpu_start: Project name: SmartDevice
I (411) cpu_start: App version: f716d5b9-dirty
I (417) cpu_start: Compile time: Dec 29 2023 00:38:32
I (423) cpu_start: ELF file SHA256: 958744a8d76203d4...
I (429) cpu_start: ESP-IDF: v4.4.6
I (433) cpu_start: Min chip rev: v0.0
I (438) cpu_start: Max chip rev: v3.99
I (443) cpu_start: Chip rev: v3.1
I (448) heap_init: Initializing. RAM available for dynamic allocation:
I (455) heap_init: At 3FFAE6E0 len 00001920 (6 KiB): DRAM
I (461) heap_init: At 3FFB6D40 len 000292C0 (164 KiB): DRAM
I (467) heap_init: At 3FFE0440 len 00003AE0 (14 KiB): D/IRAM
I (474) heap_init: At 3FFE4350 len 0001BCB0 (111 KiB): D/IRAM
I (480) heap_init: At 40094E6C len 0000B194 (44 KiB): IRAM
I (488) spi_flash: detected chip: generic
I (491) spi_flash: flash io: dio
I (496) cpu_start: Starting scheduler on PRO CPU.
I (0) cpu_start: Starting scheduler on APP CPU.
I (506) wifi_AP_WEBserver: NVS init
I (556) wifi_AP_WEBserver: Eventloop create
I (556) wifi_AP_WEBserver: init softAP
I (556) wifi_AP_WEBserver: Start Init Wifi
I (566) wifi:wifi driver task: 3ffbf2d0, prio:23, stack:6656, core=0
I (566) system_api: Base MAC address is not set
I (566) system_api: read default base MAC address from EFUSE
I (596) wifi:wifi firmware version: 1ba8b6a
I (596) wifi:wifi certification version: v7.0
I (596) wifi:config NVS flash: enabled
I (596) wifi:config nano formating: disabled
I (596) wifi:Init data frame dynamic rx buffer num: 32
I (606) wifi:Init management frame dynamic rx buffer num: 32
I (606) wifi:Init management short buffer num: 32
I (616) wifi:Init dynamic tx buffer num: 32
I (616) wifi:Init static rx buffer size: 1600
I (626) wifi:Init static rx buffer num: 10
I (626) wifi:Init dynamic rx buffer num: 32
I (626) wifi_init: rx ba win: 6
I (636) wifi_init: tcpip mbox: 32
I (636) wifi_init: udp mbox: 6
I (636) wifi_init: tcp mbox: 6
I (646) wifi_init: tcp tx win: 5744
I (646) wifi_init: tcp rx win: 5744
I (656) wifi_init: tcp mss: 1440
I (656) wifi_init: WiFi IRAM OP enabled
I (666) wifi_init: WiFi RX IRAM OP enabled
I (1436) phy_init: phy_version 4771,450c73b,Aug 16 2023,11:03:10
I (1526) wifi:mode : softAP (fc:b4:67:56:d4:b5)
I (1526) wifi:Total power save buffer number: 16
I (1526) wifi:Init max length of beacon: 752/752
I (1526) wifi:Init max length of beacon: 752/752
I (1526) wifi_AP_WEBserver: wifi_init_softap finished. SSID:ESP32 password:mypassword
I (1536) wifi_AP_WEBserver: Starting server on port: '3500'
I (1546) wifi_AP_WEBserver: Registering URI handlers
I (1546) wifi_AP_WEBserver: Registering URI OK
I (52036) wifi:new:<1,1>, old:<1,1>, ap:<1,1>, sta:<255,255>, prof:1
I (52036) wifi:station: 9c:2f:9d:b8:da:8b join, AID=1, bgn, 40U
I (52056) wifi_AP_WEBserver: station 9c:2f:9d:b8:da:8b join, AID=1
I (52076) wifi:<ba-add>idx:2 (ifx:1, 9c:2f:9d:b8:da:8b), tid:0, ssn:3, winSize:64
I (52296) esp_netif_lwip: DHCP server assigned IP to a station, IP is: 192.168.4.2