bclose

ESP8266 como servidor web para manejar un LED

programando el procesador interno del ESP8266

Objetivos

 

 

    • Más sobre el módulo ESP8266 y WIFI.
    • Presentar la librería WIFI ESP8266 para IDE Arduino.
    • Mostrar ejemplos de tareas comunes con WIFI.
    • Activar un LED desde un navegador, mediante un servidor web en ESP8266
 

 

Material requerido.

ProtoboardUna Protoboard .
conexionesAlgunos cables de protoboard, preferiblemente Dupont macho/hembra.
Vista frontal Un módulo WIFI ESP8266
Vista frontal Un adaptador FTDI a USB.
Fuente para protoboard Una fuente de alimentación externa de 3.3V si fuera necesario

 

Empezando de nuevo con ESP8266

 

Vale, hemos ido pasando de considerar a este pequeño modulo, como un simple y barato shield WIFI para Arduino, a enterarnos de que dispone de un pequeño y competente procesador propio interno.

Por si fuera poco, resulta que hay unos señores que han desarrollado un pluggin para que podamos programarlo directamente desde el IDE Arduino como si fuera un Arduino normal, con el mismo modelo y las mismas instrucciones.

En las últimas sesiones hemos visto como instalar este pluggin y hasta hemos hecho un pequeño programa, el sencillo blinking LED, para que viéramos como acceder a ese procesador desde el IDE normal de Arduino.

¿Pero… sabéis que? Aún hay más. Porque naturalmente este modulito contiene todo el hardware y firmware necesarios para manejar el WIFI y para poder acceder al TCPIP interno, necesitamos una librería adecuada.

Y naturalmente, la gente que ha desarrollado el pluggin se han molestado en desarrollar esa librería y además de usar como base la librería WIFI de Arduino, de modo que se maneja prácticamente igual que la librería oficial y los ejemplos oficiales corren con un mínimo de modificación.

¿Qué os parece? Por el precio de una entrada de cine, tenemos procesador propio, stack TCPIP y acceso a todo ello mediante una librería igual a la oficial, que todo ello costaría 20€ de un Arduino y 65 de un shield WIFI oficial, o sea más de 80€. ¿Quién da más?

Es un buen momento para que cerréis la boca, para que no os entren moscas y poder entender porque este modulito está causando furor en los foros IOT.

Y ahora que ya hemos puesto las bases necesarias para trabajar con el ESP8266 desde el IDE Arduino, vamos a empezar a meternos en serio con él, viendo como accedemos a la WIFI directamente con su procesador interno.

 

Accediendo a la WIFI desde ESP8266

 

Vamos a ir viendo los procedimientos básicos para gestionar la conexión WIFI con la única y exclusiva ayuda de nuestro flamante modulito ESP8666.

Para ello, es imprescindible que tengáis disponible el pluggin para el IDE Arduino. Si no lo habéis instalado aun, podéis ver el procedimiento en la sesión previa, porque sin él no podréis programar los ejemplos que veremos en esta sesión.

Todos los programas que vamos a ver en esta sesión están basados en los ejemplos que acompañan el pluggin Arduino y nuestro único mérito, ha sido limpiar un poco, eliminando lo superfluo, y procurar presentarlos de un modo un poco más didáctico, siguiendo la tradición de ejemplos minimalistas para facilitar el arranque.

Y dicho esto, vamos a empezar viendo cómo hacemos para ver que WIFIs hay disponibles en tu zona

 

Listando las Wifi disponibles

 

El programa necesario, Prog_122_1 empieza incluyendo la librería imprescindible:

#include "ESP8266WiFi.h"

Ahora podemos empezar ya con el setup de nuestro programa:

void setup()
   {   Serial.begin(115200);
       WiFi.mode(WIFI_STA);
       WiFi.disconnect();
       delay(100);
       Serial.println("Configuracion completa");
   }                   }

Empezamos por establecer 115.200 como velocidad serie porque puede haber un flujo de datos importante.

 
  • No os preocupéis por esas historias de miedo de que es una velocidad alta. Va como una seda y funciona perfecto. 

Las siguientes dos líneas establecen el modo de conexión como estación (Station) y desconectan de cualquier conexión previa. La última línea envía un mensaje a la consola Arduino con toda normalidad.

Vamos a ver como escaneamos las redes. Empecemos encontrando el número de Redes disponibles:

  int n = WiFi.scanNetworks();
  if (n == 0)
            Serial.println("No encuentro redes disponibles");

En caso de haber encontrado redes, sacamos un mensajito indicando el numero de redes disponibles:

   Serial.print(n);
   Serial.println(" networks found");

Y pasmos directamente a enumerarlas:

  for (int i = 0; i < n; ++i)
     {  // Print SSID y RSSI para cada una
        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) == ENC_TYPE_NONE)?" ":"*");
        delay(10);
    }

La librería ya ha generado unos arrays con las características de cada una de las redes que ha encontrado y podemos imprimir los datos con un sencillo for.

Esta es la elegancia que nos gusta, si señor y además es la librería la que trabaja, no nosotros. EL resultado en mi zona es este:

Listado de redes wifi disponibles

 

Conectando a la WIFI

 

Ya sabemos cómo listar las Wifi. Ahora conectarnos a una es igual de sencillo mediante la librería. Empezamos incluyendo la librería y definiendo cosas: Prog_122_2

#include <ESP8266WiFi.h>

const char* ssid = "charly";     // Aqui van vuestros datos
const char* password = "contrase";

Necesitamos el nombre y la contraseña de acceso como es habitual, y para conectar podemos usar este código:

WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED)
   {   delay(500);
       Serial.print(".");
   }
Serial.println(WiFi.localIP());

El programa completo incluye algunas líneas que impriman los resultados y poco más:

Conectando a una WIFI

 

Montando un pequeño servidor Web

 

Con la librería, vienen varios ejemplos que os recomiendo que reviséis, porque incluyen ejemplos prácticos de cómo hacer cosas y siempre vienen bien para daros ideas y ver cómo hacer cosas concretas.

Un ejemplo que seguro que os va a gustar es el de un pequeño servidor web en el ESP8266 que nos permite encender y apagar un diodo LED conectado a su pin GPIO2. Prog_122_3

Empezamos cargando las librerías y claves de conexión

#include <ESP8266WiFi.h>

const char* ssid = "charly";
const char* password = "contrase";

Y ahora definimos una instancia del servidor:

WiFiServer server(80);

Pasamos ahora al setup, en el que definimos el GPIO02 como salida y nos conectamos a la WIFI como en los ejemplos anteriores:

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

      pinMode(2, OUTPUT);      // GPIO2
      digitalWrite(2, LOW);

      Serial.print("Connecting to ");
      Serial.println(ssid);
      WiFi.begin(ssid, password);

      while (WiFi.status() != WL_CONNECTED)
         {   delay(500);
             Serial.print(".");
         }
      Serial.println("WiFi connected");

      server.begin();                                // Iniciamos el servidor
      Serial.println("Server started");
      Serial.println(WiFi.localIP());      // Imprimimos la IP
   }

La única novedad es la instrucción que inicia el servidor. En el loop creamos el cliente y comprobamos si hay algo  disponible:

WiFiClient client = server.available();
if (!client)
     return;

Serial.println("new client");
while(!client.available())
      delay(1);

Ahora vamos a leer el mensaje del cliente a un String y vaciamos el cliente:

String req = client.readStringUntil('\r');
Serial.println(req);
client.flush();

EL programa busca el texto “/gpio/1” para encender el LED y lo apaga si encuentra “/gpio/0” y si no es nada de esto envía un mensaje de error.

int val;
if ( req.indexOf("/gpio/0") != -1)
     val = 0;
else if (req.indexOf("/gpio/1") != -1)
     val = 1;
else
   { Serial.println("invalid request");
     client.stop();
     return;
}

El resto del ejemplo simplemente escribe en el pin GPIO2, el valor correspondiente a val

digitalWrite(2, val);

Y el resto del programa envía la respuesta HTTP al navegador para indicar si el valor actual es HIGH o LOW:

String s = "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n<!DOCTYPE HTML>\r\n<html>\r\nGPIO is now ";
s += (val)?"high":"low";
s += "</html>\n";

client.print(s);                    // Enviar el resultado de val al cliente
delay(1);
Serial.println("Client disonnected");

Aquí os dejo un mini video con el resultado final

 

No deja de ser sorprendente que un pequeño chip, ridículamente barato, incluya procesador más WIFI completo y la posibilidad de usarse como una solución completa para pequeños proyectos. En realidad la limitación no viene de la capacidad del procesador o del WIFI del ESP8266, sino del escaso número de patas que este montaje particular permite acceder de o desde el exterior.

Solamente dos pines digitales GPI00 y GPIO2, pero veremos en más capítulos que hay otros modelos de encapsulado que nos ofrece un número superior de pines disponibles que podemos usar para proyectos más complejos.

Pero esto será tema de otras sesiones más adelante, donde veremos algunos de esos modelos y veremos cómo trabajar con ellos

 

Resumen de la sesión

 

 
    • Vimos el ESP8266 desde un nuevo punto de vista, como procesador.
    • Hemos visto como disponer del pluggin IDE para este módulo, bien como segunda instalación o bien instalándolo en nuestro IDE normal.
    • Presentamos la configuración básica del entorno para programa directamente el ESP8266.
    • Volcamos nuestro primer programa y probamos el simple Blink LED