Categoría: Ejemplos básicos - módulos

  • 2.3 Wifi-Conectando ESP8266 - ESP01 Esquemático

    Un ESP01 que es el más pequeño de los diferentes módulos ESP8266, requiere añadir algunos componentes para conectarse y programar u operar el módulo.

    Esquemático con ESP01

    Al módulo se añade: una fuente de alimentación a 3.3V, un módulo de conexión USB-TTL para conectar a una computadora y unas botoneras para controlar el modo de operación y reinicio reset).

    La alimentación del circuito presentada en el esquema, sigue las indicaciones de la sección: Fuente de alimentación 3.3VDC. modulo wifi

    El control de modo de "operación/Programación" y "reset" se implementa con  botoneras.

    El modo predeterminado de inicio es "operación" por medio de GPIO0 a estado HIGH (+VCC ) con una resistencia (pullup), al presionar la botonera se cambia el estado a LOW (GND).

    Para programar se presiona la botonera "programar" y luego se añade un pulso a "reset", el módulo queda  listo para "subir" instrucciones desde IDE Arduino.

    diagrama circuito

    En la versión ESP-01 el LED interno se encuentra conectado al pin de TX usado para la comunicación Serial. Usar mensajes por puerto serial causaría un conflicto en el modo de operación con el parpadeo de led, asunto a tomar encuentra en las instrucciones.

    Una forma de implementación funcional, es no usar los mensajes por puerto serial. Otra forma es cambiar el LED a otro pin y configurarlo como salida, ej: GPIO2. El nuevo pin permite conectar Tx y Rx y observar los mensajes del proceso de conexión. Adicionalmente GPIO2 es el led interno de otros modelos de ESP8266.

    En caso de usar los componentes junto a un protoboard se muestra también el diagrama de conexión como referencia

    diagrama protoboard

    la programación del módulo se realiza en la siguiente sección.

  • ESP07 IR Emisor

    El circuito permite la emisión de una señal infraroja semejante a un control remoto usando el módulo ESP07-ESP8266. El código infrarojo emitido corresponde al obtenido en el ejemplo del receptor infrarojo.

    Com emisor se usa un LED IR, complementado con un transistor para aumentar la cantidad de corriente. El el puerto GPIO05 no es suficiente para obtener distancias de transmisión de la señal muy lejanas.

    El esquemático muestra lo sencillo de la conexión del emisor infrarojo:

    Protoboard

    Como referencia de la conexiones en también se adjunta la conexión usando un protoboard.

    Instrucciones

    Se usan las librerias Arduino IRremoteESP8266 como base para un dispositivo de control remoto con Home Assistant.

    El pin del emisor infrarojo se lo toma de la hoja de datos para el ESP8266 donde se indica usar el pin 5 para receptor y el 14 para emisor. Sección 4.4.Interfaces, página 12.

    https://www.mikrocontroller.net/attachment/338570/Ai-thinker_ESP-07_WIFI_Module-EN.pdf

    4.8. IR Remote Control pag 16

    https://www.espressif.com/sites/default/files/documentation/0a-esp8266ex_datasheet_en.pdf

    #include <IRremoteESP8266.h>
    #include <IRsend.h>
    #include <IRrecv.h>
    
    #define LED_pin 2
    #define IR_LED 14
    IRsend irsend(IR_LED);  // configura emisor
    uint32_t enciendeapaga = 0xFF5AA5; // código de control
    
    void setup() {
        Serial.begin(115200);
        pinMode(LED_pin, OUTPUT);
        
        irsend.begin();
    }
    
    void loop() {
        Serial.println("Enciende/Apaga control remoto Avanti");
        // Parpadeo LED interno
        digitalWrite(LED_pin, LOW);
        delay(1000); // Esperar un segundo
        digitalWrite(LED_pin, HIGH);
        delay(1000); // Esperar un segundo
      
        irsend.sendNEC(enciendeapaga ,32);
        delay(4000);// tiempo antes de apagar dispositivo
    }
    

    Las pruebas de funcionamiento se realizan de dos formas:

    1. Usando una cámara digital del móvil celular, para verificar que el LED IR parpadea, se puede ver en la pantalla que el LED enciente.

    2. apuntando el led al dispositivo que activa el control remoto y usado en el ejemplo del receptor.

    El siguiente paso es integrar el receptor y el emisor para el control mediante el servidor MQTT-Mosquitto.

  • ESP07 IR detector/demodulador

    El ejemplo realiza la detección de señal de un control remoto infrarojo con el módulo ESP07-ESP8266 y muestra el resultado Hexadecimal en el Monitor Serial.

    Cada tecla del control remoto genera un código único que es detectado con el sensor.

    Para el ejemplo se usa un HX1838, sin embargo también funciona  un TSOP382.., TSOP384, o alguna versión que incluya el circuito de demodulación.

    La versión del sensor infrarojo con detección y demodulación simplifica el circuito a un pin digital configurado como entrada en el módulo a usar, además de Vcc y Gnd.

    El esquemático muestra lo sencillo de la conexión del sensor infrarojo para su lectura.

    Protoboard

    Como referencia de la conexiones en también se adjunta la conexión usando un protoboard.

    Lectura de datos

    Para un control remoto dado, por ejemplo el básico para arduino, se obtienen los diferentes códigos en Hexadecimal de las teclas presionadas usando el monitor serial.

    FF5AA5
    FF5AA5
    

    Si usa un ESP07 en versión 8285, puede ser necesario configurar los baudios a 74880 baudios, si los símbolos que llegan no son legibles.

    Instrucciones

    Se usan las librerias Arduino IRremoteESP8266 como base para un dispositivo de control remoto con Home Assistant.

    /* IRremoteESP8266: Demo Receptor Infrarojo
     * Debe usar un sensor detector/demodulador conectado al Receptor_Pin.
     *  Based on Mark Szabo's Version 0.2 June, 2017 and
     *  Ken Shirriff's IrsendDemo Version 0.1 July, 2009
     *  https://github.com/markszabo/IRremoteESP8266
     */
    
    #include <IRremoteESP8266.h>
    #include <IRrecv.h>
    #include <IRutils.h>
    
    // Sensor IR en GPIO05
    const uint16_t Receptor_Pin = 5;
    
    IRrecv irrecv(Receptor_Pin);
    decode_results lectura;
    
    void setup() {
        Serial.begin(74880);//74880, 115200
        while (!Serial){delay(50);}
        
        // Inicia receptor
        irrecv.enableIRIn();
        
        Serial.println("\n Demo: Receptor de IR en espera de mensaje");
    }
    
    void loop() {
        if (irrecv.decode(&lectura)) {
            // print() & println() no maneja enteros largos(uint64_t)
            serialPrintUint64(lectura.value, HEX);
            Serial.println("");
            
            // Prepara próximo valor
            irrecv.resume();
        }
        delay(100);
    }
    

    Con los cógidos obtenidos, el siguiente paso consiste en generar los códigos usando un LED IR para activar el dispositivo o equipo que se controlaba con el control remoto. Observe y seleccione un código del ejercicio realizado con el control remoto que haya seleccionado, el dato sirve para el próximo ejemplo como IR_Emisor.

    Referencia:
    https://learn.sparkfun.com/tutorials/ir-communication/all#hardware-hookup
    https://github.com/markszabo/IRremoteESP8266


    Decodificando

    Una versión para obtener más detalles de los códigos la presenta en el ejemplo version 2 de Mark Sabo en:

    https://github.com/markszabo/IRremoteESP8266/blob/master/examples/IRrecvDumpV2/IRrecvDumpV2.ino

    Solo se requiere hacer el ajuste en el pin de sensor al GIPO05, con lo que se obtiene para el ejemplo anterior:

    Timestamp : 000446.026
    Encoding  : NEC
    Code      : FF5AA5 (32 bits)
    Library   : v2.6.0
    
    Raw Timing[71]:
       +  9024, -  4556,    +   548, -   594,    +   546, -   568,    +   544, -   594, 
       +   548, -   592,    +   548, -   568,    +   546, -   594,    +   548, -   592, 
       +   548, -   566,    +   546, -  1738,    +   548, -  1710,    +   550, -  1710, 
       +   544, -  1740,    +   548, -  1712,    +   546, -  1712,    +   546, -  1740, 
       +   546, -  1712,    +   548, -   592,    +   548, -  1710,    +   548, -   592, 
       +   548, -  1710,    +   548, -  1712,    +   546, -   594,    +   548, -  1712, 
       +   544, -   596,    +   548, -  1712,    +   546, -   596,    +   548, -  1710, 
       +   546, -   594,    +   548, -   594,    +   548, -  1712,    +   548, -   592, 
       +   548, -  1710,    +   548, - 40334,    +  9024, -  2294,    +   550
    
    uint16_t rawData[71] = {9024, 4556,  548, 594,  546, 568,  544, 594,  548, 592,  548, 568,  546, 594,  548, 592,  548, 566,  546, 1738,  548, 1710,  550, 1710,  544, 1740,  548, 1712,  546, 1712,  546, 1740,  546, 1712,  548, 592,  548, 1710,  548, 592,  548, 1710,  548, 1712,  546, 594,  548, 1712,  544, 596,  548, 1712,  546, 596,  548, 1710,  546, 594,  548, 594,  548, 1712,  548, 592,  548, 1710,  548, 40334,  9024, 2294,  550};  // NEC FF5AA5
    uint32_t address = 0x0;
    uint32_t command = 0x5A;
    uint64_t data = 0xFF5AA5;
    

    La información de Code, "32 bits" Es necesaria si requiere reproducir la instrucción on irsend.sendNEC(codigo,32).

    En el caso de usar otro control remoto se debe disponer del número de bits.

  • ESP32 Bluetooth - Serial

    Se puede realizar una comunicación Serial por medio de Bluetooth con la libreria básica de ESP32 para arduino.

    En un ejercicio básico par controlar los estados de un LED es enviar un mensaje de '1'  para encender el Led incorporado del módulo y un mensaje  de '0' para apagar el Led.

    Por un lado se usa un módulo ESP32, y por el otro un móvil/tablet con una aplicación básica de terminal serial, para tener resultados semejantes al mostrado.

    Las instrucciones usadas son:

    // Controlador Binario LED
    // ESP32-Serial Bluetooth
    
    #include <BluetoothSerial.h>
    
    BluetoothSerial ESP_BT;
    
    int mensaje;
    
    // LED monitor interno
    // ESP01-pin=1, ESP07-pin=2; ESP32-pin=5
    const PROGMEM uint8_t LED_pin = 5; 
    
    void setup() {
      Serial.begin(115200);
      ESP_BT.begin("ESP32_LED");
      Serial.println("Listo dispositivo Bluetooth");
      pinMode (LED_pin, OUTPUT);
    }
    
    void loop() {
      
      if (ESP_BT.available()){
        // mensaje recibido
        mensaje = ESP_BT.read(); 
        Serial.print("Recibido:"); 
        Serial.println(mensaje);
    
        if (mensaje == 49){
            digitalWrite(LED_pin, HIGH);
            ESP_BT.println("LED Encendido");
            }
            
        if (mensaje == 48){
            digitalWrite(LED_pin, LOW);
            ESP_BT.println("LED Apagado");
            }
      }
      delay(20);
    }

    Referencia:

    https://github.com/espressif/arduino-esp32/tree/master/libraries/BluetoothSerial

    https://create.arduino.cc/projecthub/mayooghgirish/arduino-bluetooth-basic-tutorial-d8b737

  • ESP32 SmartConfig-App

    Para la configuración inicial de los dispositivos requiere una aplicación en un dispositivo tablet o móvil para configurar la conexión a la red WiFi con los datos de SSID y Password.

    El concepto presentado por espressif con documentación actualizada al 2018.06.08 se encuentra en:

    https://www.espressif.com/en/products/software/esp-touch/overview

    https://www.espressif.com/sites/default/files/faq/screen_shot_2016-04-27_at_1.30.27_pm_0.png
    Figura: Espressif https://www.espressif.com/sites/default/files/faq/screen_shot_2016-04-27_at_1.30.27_pm_0.png

    La implementación de la aplicación que se usó para probar el ejercicio se encuentra en Google Play. Revisar el desarro de la aplicación realizará como otro tema.

    https://play.google.com/store/apps/details?id=com.cmmakerclub.iot.esptouch

    El procedimiento de conexión tiene dos partes:

    1. Modo configuración de WiFi, usando la aplición SmartConfig
    2. Modo normal de conexión WiFi, con los datos WiFi ya configurados

    Para seleccionar los modos se usa una botonera "Configuración"  en un pin digital disponible con funcion y circuito semejante a RESET, en el ejemplo se usa GPIO14.

    Modo configuración de WiFi

    Para iniciar el modo configuración de la red se deben usar las botoneras "Configuración" y "RESET" con la secuencia:

    1. pulsar Botonena GPIO14 y mantener pulsada
    2. Luego pulsar y soltar reset
    3. Mantener pulsado GPIO14 por 5 segundos después y soltar
    4. Usar el móvil/tableta con la aplicación SmartConfig para configurar
    5. Escribir SSID y password en móvil/tablet y "confirmar"
    6. Esperar confirmación y estará conectado.

    Modo normal de conexión WiFi

    Es el modo predeterminado de operación, no requiere presionar el botón de "Configuración". Arranca con los valores almacenados de SSID y PASSWORD.

    Monitor Serial

    Los resultados del proceso de configuración y conexión a WiFi se muestran a continuación. Para fines de muestra, se ha demorado la activación con el móvil/tablet, note que la conexión a WiFI se realiza casi inmediatamente (tres puntos ...)

    ....ets Jun  8 2016 00:22:57
    
    rst:0x1 (POWERON_RESET),boot:0x13 (SPI_FAST_FLASH_BOOT)
    ets Jun  8 2016 00:22:57
    
    rst:0x10 (RTCWDT_RTC_RESET),boot:0x13 (SPI_FAST_FLASH_BOOT)
    configsip: 0, SPIWP:0xee
    clk_drv:0x00,q_drv:0x00,d_drv:0x00,cs0_drv:0x00,hd_drv:0x00,wp_drv:0x00
    mode:DIO, clock div:1
    load:0x3fff0018,len:4
    load:0x3fff001c,len:1100
    load:0x40078000,len:10088
    load:0x40080400,len:6380
    entry 0x400806a4
    configurando WiFi
    Esperando conexión SmartConfig móvil/tablet
    ........................................
     Esperando conexión SmartConfig móvil/tablet
    ...............
     Finalizado SmartConfig.
    
     Conectando a WiFi
    ...
     WiFi conectado , Dirección IP: iotirni19 , 192.168.10.102
    conectado a:
    iotirni19 , 192.168.10.102 , -56
    conectado a:
    iotirni19 , 192.168.10.102 , -53
    conectado a:
    iotirni19 , 192.168.10.102 , -54
    conectado a:
    iotirni19 , 192.168.10.102 , -55
    conectado a:
    iotirni19 , 192.168.10.102 , -55
    conectado a:
    iotirni19 , 192.168.10.102 , -55
    

    Instrucciones Arduino

    Las instrucciones se han dividido por bloques: configura_wifi() y conecta_wifi(). En ambas funciones se presentan mensajes y parpadeos de led.

    Configura_wifi() espera a que se obtenga un valor afirmativo para WiFi.smartConfigDone() y finalizar.

    Conecta_wifi() es muy semejante a la función inicia_wifi() usada en los primeros ejemplos que usaba variables para SSID y Password()

    /* ESP32 Smart Config de Espressif
    modificado a partir de:
    https://www.espressif.com/en/products/software/esp-touch/overview
    Usa el GPIO14 en estado LOW para entrar en modo configuración.
    Usar BOTONERA "CONFIGURACION" en pin14, con pullup (HIGH)
    Para configurar:
    1. pulsar Botonena GPIO14 y mantener pulsada
    2. Luego pulsar y soltar reset
    3. Mantener pulsado GPIO14 por 5 segundos después y soltar
    4. Usar el móvil/tableta con la aplicación SmartConfig para configurar
    5. Escribir SSID y password en móvil/tablet y "confirmar"
    6. Esperar confirmación y estará conectado.
    */
    #include <WiFi.h>
    
    // PIN configuración
    const PROGMEM uint8_t CONFIG_pin = 14; 
    
    // LED monitor interno
    //ESP01-pin=1, ESP07-pin=2; ESP32-pin=5
    const PROGMEM uint8_t LED_pin = 5; 
    
    void setup() {
        Serial.begin(115200);
    
        // PIN configuración
        pinMode(CONFIG_pin, INPUT);
        
        // LED monitor
        pinMode(LED_pin, OUTPUT);
        
        // Revisa si entra a modo configuración
        if (digitalRead(CONFIG_pin)==LOW){
            Serial.println("configurando WiFi");
            // configura con SmartConfig
            configura_wifi();
        }
        // Modo conexión a Router
        conecta_wifi();
    
    }
    void loop() {
        // Ejemplo de tarea a realizar.
        Serial.println("conectado a:");
        Serial.print(WiFi.SSID());
        Serial.print(" , ");
        Serial.print(WiFi.localIP());
        Serial.print(" , ");
        Serial.println(WiFi.RSSI());
        // LED interno enciende en LOW
        digitalWrite(LED_pin, HIGH);
        delay(100);
        digitalWrite(LED_pin, LOW);
        delay(100);
        digitalWrite(LED_pin, HIGH);
        delay(100);
        digitalWrite(LED_pin, LOW);
        delay(250);
        // termina ejemplo
        delay(1000);
    }
    
    void configura_wifi(){
        // inicia en modo estación
        WiFi.mode(WIFI_AP_STA);
        WiFi.beginSmartConfig();
        int cuenta = 0;
        // Espera por un paquete Smartconfig del móvil/tablet
        Serial.println("Esperando conexión SmartConfig móvil/tablet");
        while (!WiFi.smartConfigDone()) {
            delay(500);
            Serial.print(".");
            cuenta = cuenta+1;
            if (cuenta>=40){
                Serial.println("\n Esperando conexión SmartConfig móvil/tablet");
                cuenta = 0;}
            // LED interno enciende en LOW
            digitalWrite(LED_pin, HIGH);
            delay(50);
            digitalWrite(LED_pin, LOW);
            delay(50);
            }
        Serial.println("\n Finalizado SmartConfig.");
        }
    
    void conecta_wifi() {
        // conexion WiFi
        Serial.println("\n Conectando a WiFi");
        
        WiFi.begin();//ssid, password);
        int cuenta = 0;
        while (WiFi.status() != WL_CONNECTED){
            Serial.print(".");
            cuenta = cuenta+1;
            if (cuenta>=40){
                Serial.println();
                cuenta = 0;}
            // LED interno enciende en LOW
            digitalWrite(LED_pin, LOW);
            delay(250);
            digitalWrite(LED_pin, HIGH);
            delay(250);
            }
        Serial.print("\n WiFi conectado , Dirección IP: ");
        Serial.print(WiFi.SSID());
        Serial.print(" , ");
        Serial.println(WiFi.localIP());
        delay(10);
    }
    

    Por desarrollar:
    Personalizar la aplicación del móvil/tableta a partir del código básico de espressif.

    Referencias:
    https://www.espressif.com/en/products/software/esp-touch/overview

    https://www.espressif.com/sites/default/files/documentation/esp-touch_user_guide_en.pdf

  • ESP32 BuscarRedes

    Búsqueda de redes cercanas y sus respectivas potencias, la red marcada con rojo es el ESP32  revisado desde una laptop.

    Busca redes WiFi cercanas
    Busqueda completada 
    29 redes encontradas
    1: ESP_0A797B (-46) 
    2: GUAIFAI (-62)*
    3: Red Oculta
    ...
    

    Instrucciones

    Usando la libreria WiFi.h

    /* Redes disponibles
     *  Realiza una búsqueda de redes Wifi cercanas
     */
    #include <WiFi.h>
    
    void setup()
    {
        Serial.begin(115200);
    
        // Si estaba conectada como estación, se desconecta.
        WiFi.mode(WIFI_STA);
        WiFi.disconnect();
        delay(100);
    
        Serial.println("Configuración completada.");
    }
    
    void loop()
    {
        Serial.println("Busca redes WiFi cercanas");
    
        //determina el número de redes cercanas
        int n = WiFi.scanNetworks();
        Serial.println("Busqueda completada ");
        
        if (n == 0) {
            Serial.println("NO se encontraron redes.");
        } else {
            Serial.print(n);
            Serial.println(" redes encontradas");
            for (int i = 0; i < n; ++i) {
                // Muestra el SSID y RSSI de cada red encontrada
                Serial.print(i + 1);
                Serial.print(": ");
                Serial.print(WiFi.SSID(i));
                Serial.print(" (");
                Serial.print(WiFi.RSSI(i));
                Serial.print(")");
                Serial.println((WiFi.encryptionType(i) == WIFI_AUTH_OPEN)?" ":"*");
                delay(10);
            }
        }
        Serial.println("");
    
        // Espera antes de la próxima búsqueda...
        delay(5000);
    }
    

    Referencia: https://github.com/espressif/arduino-esp32/blob/master/libraries/WiFi/examples/WiFiScan/WiFiScan.ino

  • ESP32 SoftAP

    Para crear un Access Point se usa de la libreria la intrucción WIFI.softAP()

    Como base se tiene el ejercicio de una página web para encender o apagar el LED incorporado.

    En ésta ocasión no es necesario conectarse a un router, el AP aparece en la lista de dispositivos circundantes. Se selecciona y se ingresa con el nombre de red y la contraseña.

    /* ESP32 Soft AP con web server para encender LED_Pin
    forma básica con la función inicia_wifi
    Referencia: https://www.arduino.cc/en/Tutorial/WiFiWebServer  
    */
    #include <WiFi.h>
    
    const char* ssid     = "iotirni19_AP";
    const char* password = "xxxxx";
    
    // puerto de servidor web 80
    const PROGMEM uint8_t puertoweb = 80;
    WiFiServer server(puertoweb);
    
    // LED monitor interno
    //ESP01-pin=1, ESP07-pin=2; ESP32-pin=5
    const PROGMEM uint8_t LED_pin = 5; 
    int LED_estado = 0;
    
    void setup()
    {
        // Conexion serial
        Serial.begin(115200);
        Serial.setTimeout(500);
        // espera inicializar serial
        while(!Serial) { }
    
        // LED monitor
        pinMode(LED_pin, OUTPUT);
        delay(10);
    
        // Convertir en AP
        WiFi.softAP(ssid, password);
        //inicia_wifi(); // no se conecta a un router
        server.begin();
    }
    
    void loop(){
        WiFiClient client = server.available();
        if (client){
            String linea = "";
            Serial.println();
            Serial.println("Nuevo cliente.");
            while (client.connected()) {
                if (client.available()) {
                    char c = client.read();
                    Serial.write(c);
                    if (c == '\n') {
                        // Si recibe fin de linea y la linea es vacia,
                        // la peticion http finalizó, se responde:
                        if (linea.length() == 0) {
                            // HTTP headers inician con ésta secuencia:
                            client.println("HTTP/1.1 200 OK");
                            client.println("Content-type:text/html");
                            client.println();
                            // contenido despues de headers
                            client.print("LED estado: ");
                            client.print(String(LED_estado)+"
    ");
                            client.print("Click <a href=\"/H\">ENCIENDE LED</a><br>");
                            client.print("Click <a href=\"/L\">   APAGA LED</a><br>");
                            // finaliza contenido:
                            client.println();
                            // sale del lazo:
                            break;
                        } else {
                            linea = "";
                        }
                    } else if (c != '\r') {
                        linea = linea + c;
                    }
                // Revisa click del cliente "GET /H" or "GET /L":
                if (linea.endsWith("GET /H")) {
                    digitalWrite(LED_pin, HIGH);
                    LED_estado = 1;
                }
                if (linea.endsWith("GET /L")) {
                    digitalWrite(LED_pin, LOW);
                    LED_estado = 0;
                }
            }
        }
        delay(1); // espera que browser procese
        client.stop(); // cierra conexión:
        Serial.println("Cliente desconectado.");
        }
    }
    
  • ESP32 WebServer Blink

    Enciender y Apagar elLED incorporado (Pin 5) en el módulo ESP32 desde una página web.

    https://learn.sparkfun.com/tutorials/esp32-thing-hookup-guide

    El módulo se configura como un Web Server para responder a las petición desde un browser. La dirección mostrada en la figura es un ejemplo.

    La librería  básica usada es WiFi.h con los valores de SSID y Password para acceder a la red existente, valores que se deben actualizar de acuerdo a la configuración de su red. El router asigna una dirección IP de forma automática, y su valor se muestra en el monitor serial, dirección usada en un brower para observar el resultado.

    Monitor Serial

    ets Jun 8 2016 00:22:57
    
    rst:0x10 (RTCWDT_RTC_RESET),boot:0x13 (SPI_FAST_FLASH_BOOT)
    configsip: 0, SPIWP:0xee
    clk_drv:0x00,q_drv:0x00,d_drv:0x00,cs0_drv:0x00,hd_drv:0x00,wp_drv:0x00
    mode:DIO, clock div:1
    load:0x3fff0018,len:4
    load:0x3fff001c,len:1100
    load:0x40078000,len:10088
    load:0x40080400,len:6380
    entry 0x400806a4
    
    Conectando a RedWifi
    ..
    WiFi conectado 
    Dirección IP: 192.168.10.104

    Para simplificar las instrucciones, la sección de conexión a la red WiFi se realiza en la función inicia_wifi().

    Instrucciones:

    Para iniciar el modo servidor web se requiere WifiServer server(puertoweb), el puerto web es el 80.

    En el programa se revisa el estado del cliente (client): conectado, disponible, leyendo cada caracter enviado por el browser e interpretando las instrucciones por cada fin de línea ('\n').

    Si la línea recibida finaliza con "GET /H" o "GET /L" se realiza el cambio de estado del LED.

    Al final se cierra la conexión, y se continua monitoreando el estado del cliente.

    /* ESP32 web server para encender LED_Pin
    forma básica con la función inicia_wifi
    Referencia: https://www.arduino.cc/en/Tutorial/WiFiWebServer  
    */
    #include <WiFi.h>
    
    const char* ssid     = "";
    const char* password = "";
    
    // puerto de servidor web 80
    const PROGMEM uint8_t puertoweb = 80;
    WiFiServer server(puertoweb);
    
    
    // LED monitor interno
    //ESP01-pin=1, ESP07-pin=2; ESP32-pin=5
    const PROGMEM uint8_t LED_pin = 5; 
    
    void setup()
    {
        // Conexion serial
        Serial.begin(115200);
        Serial.setTimeout(500);
        // espera inicializar serial
        while(!Serial) { }
    
        // LED monitor
        pinMode(LED_pin, OUTPUT);
        delay(10);
    
        inicia_wifi();
        server.begin();
    }
    
    void loop(){
        WiFiClient client = server.available();
        if (client){
            String linea = "";
            Serial.println();
            Serial.println("Nuevo cliente.");
            while (client.connected()) {
                if (client.available()) {
                    char c = client.read();
                    Serial.write(c);
                    if (c == '\n') {
                        // Si recibe fin de linea y la linea es vacia,
                        // la peticion http finalizó, se responde:
                        if (linea.length() == 0) {
                            // HTTP headers inician con ésta secuencia:
                            client.println("HTTP/1.1 200 OK");
                            client.println("Content-type:text/html");
                            client.println();
                            // contenido despues de headers
                            client.print("Click <a href="\"/H\"">ENCIENDE LED</a>
    ");
                            client.print("Click <a href="\"/L\"">   APAGA LED</a>
    ");
                            // finaliza contenido:
                            client.println();
                            // sale del lazo:
                            break;
                        } else {
                            linea = "";
                        }
                    } else if (c != '\r') {
                        linea = linea + c;
                    }
                // Revisa click del cliente "GET /H" or "GET /L":
                if (linea.endsWith("GET /H")) {
                    digitalWrite(LED_pin, HIGH);
                }
                if (linea.endsWith("GET /L")) {
                    digitalWrite(LED_pin, LOW);
                }
            }
        }
        delay(1); // espera que browser procese
        client.stop(); // cierra conexión:
        Serial.println("Cliente desconectado.");
        }
    }
    
    void inicia_wifi() {
        // conexion WiFi
        Serial.print("\n Conectando a ");
        Serial.println(ssid);
        WiFi.begin(ssid, password);
        int cuenta = 0;
        while (WiFi.status() != WL_CONNECTED){
            Serial.print(".");
            cuenta = cuenta+1;
            if (cuenta>=40){
                Serial.println();
                cuenta = 0;}
            // LED interno enciende en LOW
            digitalWrite(LED_pin, LOW);
            delay(250);
            digitalWrite(LED_pin, HIGH);
            delay(250);
            }
        Serial.print("\n WiFi conectado \n Dirección IP: ");
        Serial.println(WiFi.localIP());
        delay(10);
    }
    

    Puntos por desarrollar

    • Añadir en la pagina el estado del LED. Sugerencia: aumentar una variable de estado para el led y usarla en la página html.
    • Conectar a un servidor MQTT e iniciar el estado del LED con el correspondiente en el Estado MQTT.

    Referencia: https://www.arduino.cc/en/Tutorial/WiFiWebServer