#include 
#include 

const char* ssid = "TU_WIFI";
const char* password = "TU_PASSWORD";

WebServer server(80);

void setup() {
  Serial.begin(115200);
  
  // Conectar a WiFi
  WiFi.begin(ssid, password);
  Serial.print("Conectando a WiFi");
  
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  
  Serial.println();
  Serial.print("IP: ");
  Serial.println(WiFi.localIP());
  
  // Configurar ruta web
  server.on("/", []() {
    server.send(200, "text/html", 
      "
ESP32 Web Server
"
      "
Funcionando desde Arduino IDE
");
  });
  
  server.begin();
  Serial.println("Servidor iniciado");
}

void loop() {
  server.handleClient();
}

; platformio.ini
[env:esp32dev]
platform = espressif32
board = esp32dev
framework = arduino
monitor_speed = 115200
lib_deps = 
    ESP Async WebServer

; main.cpp
#include 
#include 
#include 

const char* ssid = "TU_WIFI";
const char* password = "TU_PASSWORD";

AsyncWebServer server(80);

void setup() {
    Serial.begin(115200);
    
    // Configuración WiFi con mejor gestión de errores
    WiFi.mode(WIFI_STA);
    WiFi.begin(ssid, password);
    
    Serial.printf("Conectando a %s", ssid);
    while (WiFi.status() != WL_CONNECTED) {
        delay(500);
        Serial.print(".");
    }
    
    Serial.printf("\nConectado! IP: %s\n", WiFi.localIP().toString().c_str());
    
    // Servidor asíncrono más eficiente
    server.on("/", HTTP_GET, [](AsyncWebServerRequest *request) {
        request->send(200, "text/html", 
            ""
            ""
            "
PlatformIO ESP32
"
            "
Servidor asíncrono optimizado
");
    });
    
    server.begin();
    Serial.println("Servidor HTTP iniciado");
}

void loop() {
    // El servidor asíncrono no necesita handleClient()
    delay(1000);
}

#include 
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_wifi.h"
#include "esp_event.h"
#include "esp_log.h"
#include "esp_http_server.h"
#include "nvs_flash.h"

#define WIFI_SSID "TU_WIFI"
#define WIFI_PASS "TU_PASSWORD"

static const char *TAG = "ESP32_Server";

// Handler para la página principal
esp_err_t root_handler(httpd_req_t *req) {
    const char* response = 
        ""
        ""
        "
ESP-IDF Native
"
        "
Máximo control y optimización
";
    
    httpd_resp_send(req, response, HTTPD_RESP_USE_STRLEN);
    return ESP_OK;
}

// Configuración del servidor
httpd_handle_t start_webserver(void) {
    httpd_config_t config = HTTPD_DEFAULT_CONFIG();
    httpd_handle_t server = NULL;
    
    if (httpd_start(&server, &config) == ESP_OK) {
        httpd_uri_t root = {
            .uri = "/",
            .method = HTTP_GET,
            .handler = root_handler,
            .user_ctx = NULL
        };
        httpd_register_uri_handler(server, &root);
    }
    return server;
}

// Event handler para WiFi
static void wifi_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 == 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, "IP obtenida:" IPSTR, IP2STR(&event->ip_info.ip));
        start_webserver();
    }
}

void app_main(void) {
    // Inicialización 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);
    
    // Inicialización WiFi con control completo
    ESP_ERROR_CHECK(esp_netif_init());
    ESP_ERROR_CHECK(esp_event_loop_create_default());
    esp_netif_create_default_wifi_sta();
    
    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));
    ESP_ERROR_CHECK(esp_event_handler_register(IP_EVENT, IP_EVENT_STA_GOT_IP, 
                                             &wifi_event_handler, NULL));
    
    wifi_config_t wifi_config = {
        .sta = {
            .ssid = WIFI_SSID,
            .password = WIFI_PASS,
        },
    };
    
    ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA));
    ESP_ERROR_CHECK(esp_wifi_set_config(ESP_IF_WIFI_STA, &wifi_config));
    ESP_ERROR_CHECK(esp_wifi_start());
    
    ESP_LOGI(TAG, "Conectando a %s", WIFI_SSID);
}