Usando WiFi - pensactius/Tutoriales GitHub Wiki

(Extraído de dronebotworkshop.com)

Ahora que ya sabemos lo básico para trabajar, vamos a realizar algunos experimentos más interesantes. Cuando instalas las placas ESP32 en el IDE de Arduino se instalan también una serie de ejemplos que ilustran cómo usar diferentes características de la ESP32.

Usaremos algunos de estos ejemplos, comenzando por los que usan la WiFi.

WiFi con ESP32

Tanto el chip ESP32 como el ESP8266 soportan WiFi en la banda de 2.4 GHz. Soporta protocolos 802.11 b/g/n con una velocidad máxima de transferencia de 150 Mbps.

El dispositivo puede ajustar la potencia de transmisión hasta 20.5 dBm, al usar menos potencia consumirá menos ya que la WiFi puede consumir bastante corriente.

Modos WiFi

El ESP32 puede trabajar en diferentes modos WiFi.

Modo Estación - Station (STA) Mode

En el modo STA, el ESP32 actúa como una estación WiFi o cliente como se ilustra a continuación:

ESP32 STA Mode

En este modo el ESP32 necesita saber el SSID (nombre de la red WiFi) y la contraseña para acceder a la red WiFi.

El router asigna una dirección de red IP al ESP32 mediante el protocolo DHCP interno del router. Entonces podremos acceder al ESP32 mediante esa IP asignada. También es posible asignarle una IP fija, lo que puede ser útil si lo estamos usando como servidor web.

Punto de Acceso - Soft Access Point (AP) Mode

En el modo AP o Soft Access Point, el ESP32 provee de conexión WiFi a los dispositivos externos. Estos dispositivos pueden ser ordenadores, móviles, tablets o incluso otros ESP32 configurados en modo STA.

En modo AP el ESP32 puede soportar hasta un máximo de cinco dispositivos externos. Por defecto la IP que tendrá será 192.168.4.1 y proveerá de servicios DHCP a los dispositivos externos conectados. Esta IP por defecto se puede cambiar en caso de provocar colisión con dispositivos existentes.

Esto permite al ESP32 crear su propia red IP, independiente de cualquier red WiFi. Puedes hacer más segura esta red escogiendo un nombre SSID y una contraseña.

Escaneo de redes WiFi

El primer ejemplo que vamos a ver es el WiFi Scanner. Como su nombre indica, este programa escanea las redes WiFi locales. Después muestra los resultados por el monitor serie. Los resultados incluyen el SSID (nombre), intensidad de la señal en dBm y un indicador si la red está protegida.

Puedes encontrar este ejemplo en

Archivo/Ejemplos/Ejemplos para ESP32 Dev Module\WiFi\WiFi Scan

/*
 *  This sketch demonstrates how to scan WiFi networks.
 *  The API is almost the same as with the WiFi Shield library,
 *  the most obvious difference being the different file you need to include:
 */
#include "WiFi.h"

void setup()
{
    Serial.begin(115200);

    // Set WiFi to station mode and disconnect from an AP if it was previously connected
    WiFi.mode(WIFI_STA);
    WiFi.disconnect();
    delay(100);

    Serial.println("Setup done");
}

void loop()
{
    Serial.println("scan start");

    // WiFi.scanNetworks will return the number of networks found
    int n = WiFi.scanNetworks();
    Serial.println("scan done");
    if (n == 0) {
        Serial.println("no networks found");
    } else {
        Serial.print(n);
        Serial.println(" networks found");
        for (int i = 0; i < n; ++i) {
            // Print SSID and RSSI for each network found
            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("");

    // Wait a bit before scanning again
    delay(5000);
}

El código utiliza la librería WiFi y es bastante fácil de entender. El comando WiFi.scanNetworks escanea las redes disponibles y las guarda en un array. Este array es recorrido para producir los resultados.

Carga el código a la placa ESP32, recuerda pulsar BOOT si fuera necesario. Abre el monitor serie (asegurate de configurarlo a 115,200 baudios).

Al abrir el monitor serie por primera vez es posible que salga basura, esto es porque la señal serie no se ha sincronizado correctamente. Si pasa esto, simplemente pulsa el botón RESET (o EN) de la placa ESP32.

Deberías ver el escaneo de las redes WiFi disponibles en tu localización.

Punto de Acceso WiFi

El siguiente ejemplo que veremos usa el ESP32 como Punto de Acceso (Access Point o AP). Encontrarás este ejemplo en el submenu WiFi. Se llama WiFiAccessPoint.

Este programa establece el ESP32 en modo AP y crea un sencillo servidor web de una página. Ésta tiene dos enlaces que permitirán controlar el estado de un LED. En el ejemplo el LED está conectado al GPIO 2.

/*
  WiFiAccessPoint.ino creates a WiFi access point and provides a web server on it.

  Steps:
  1. Connect to the access point "yourAp"
  2. Point your web browser to http://192.168.4.1/H to turn the LED on or http://192.168.4.1/L to turn it off
     OR
     Run raw TCP "GET /H" and "GET /L" on PuTTY terminal with 192.168.4.1 as IP address and 80 as port

  Created for arduino-esp32 on 04 July, 2018
  by Elochukwu Ifediora (fedy0)
*/

#include <WiFi.h>
#include <WiFiClient.h>
#include <WiFiAP.h>

#define LED_BUILTIN 2   // Set the GPIO pin where you connected your test LED or comment this line out if your dev board has a built-in LED

// Set these to your desired credentials.
const char *ssid = "yourAP";
const char *password = "yourPassword";

WiFiServer server(80);


void setup() {
  pinMode(LED_BUILTIN, OUTPUT);

  Serial.begin(115200);
  Serial.println();
  Serial.println("Configuring access point...");

  // You can remove the password parameter if you want the AP to be open.
  WiFi.softAP(ssid, password);
  IPAddress myIP = WiFi.softAPIP();
  Serial.print("AP IP address: ");
  Serial.println(myIP);
  server.begin();

  Serial.println("Server started");
}

void loop() {
  WiFiClient client = server.available();   // listen for incoming clients

  if (client) {                             // if you get a client,
    Serial.println("New Client.");           // print a message out the serial port
    String currentLine = "";                // make a String to hold incoming data from the client
    while (client.connected()) {            // loop while the client's connected
      if (client.available()) {             // if there's bytes to read from the client,
        char c = client.read();             // read a byte, then
        Serial.write(c);                    // print it out the serial monitor
        if (c == '\n') {                    // if the byte is a newline character

          // if the current line is blank, you got two newline characters in a row.
          // that's the end of the client HTTP request, so send a response:
          if (currentLine.length() == 0) {
            // HTTP headers always start with a response code (e.g. HTTP/1.1 200 OK)
            // and a content-type so the client knows what's coming, then a blank line:
            client.println("HTTP/1.1 200 OK");
            client.println("Content-type:text/html");
            client.println();

            // the content of the HTTP response follows the header:
            client.print("Click <a href=\"/H\">here</a> to turn ON the LED.<br>");
            client.print("Click <a href=\"/L\">here</a> to turn OFF the LED.<br>");

            // The HTTP response ends with another blank line:
            client.println();
            // break out of the while loop:
            break;
          } else {    // if you got a newline, then clear currentLine:
            currentLine = "";
          }
        } else if (c != '\r') {  // if you got anything else but a carriage return character,
          currentLine += c;      // add it to the end of the currentLine
        }

        // Check to see if the client request was "GET /H" or "GET /L":
        if (currentLine.endsWith("GET /H")) {
          digitalWrite(LED_BUILTIN, HIGH);               // GET /H turns the LED on
        }
        if (currentLine.endsWith("GET /L")) {
          digitalWrite(LED_BUILTIN, LOW);                // GET /L turns the LED off
        }
      }
    }
    // close the connection:
    client.stop();
    Serial.println("Client Disconnected.");
  }
}

Por defecto el SSID del punto de acceso creado es "yourAP", esta el la red WiFi que deberás buscar pra conectarte a ella. El password es "yourPassword". Puedes modiifcar ambos si lo prefieres.

Por defecto la IP asignada al servidor web será 192.168.4.1. Es importante conocer esta IP para poder navegar a la web creada.

Después de cargar el programa al ESP32 pulsa el botón de reset. Podrás ver cierta información de las peticiones a la web generada mediante el monitor serie.

Monitorizando el estado del AP creado

Ahora utiliza un dispositivo como un ordenador, tableta o movil y escanea las redes Wifi disponibles. Deberías encontrar una llamada "yourAP". Conecta a esa red, usando la contraseña "yourPassword".

Conectando al punto de acceso

Una vez establecida la conexión, abre un navegador web y navega a la dirección 192.168.4.1. Deberías ver una página web muy simple con dos enlaces, uno para encender el LED y otro para apagarlo.

Haz clic en los enlaces y observa como el LED conectado al GPIO 2 va cambiando de estdo

Web simple para controlar un LED

⚠️ **GitHub.com Fallback** ⚠️