EL ESP8266 es un chip que gracias a la comunidad, sus características y un gran precio ha logrado convertirse en uno de los adaptadores Wifi más populares, y es que este chip alberga gran potencia en un pequeño tamaño.

¿Qué es el ESP8266?

-Soporta el protocolo 802.11 b/g/n
-Capacidad para Wi-Fi Direct (P2P), Soft-AP
-Tiene integrado el stack del protocolo TCP/IP
-Tiene un núcleo Diamond Standard Core (LX3) hecho por Tensilica
-Su núcleo de arquitectura RISC 32bits corre a 80Mhz
-64KBytes de RAM de instrucciones
-96KBytes de RAM de datos
-Tiene GPIOs, I2C, ADC, SPI, PWM, y más: http://www.esp8266.com/wiki/doku.php?id=feature_set.
-Los módulos cuentan con una memoria flash SPI Winbond W25Q40BVNIG
-Los ESP8266 son fabricados por Espressif
-Los módulos que usan este chip son de varios fabricantes y vienen en diferentes formatos.

Módulos con ESP8266

El ESP8266 está incluido en una gran variedad de módulos de diferentes formas y formatos.

En este tutorial básico vamos a trabajar con el ESP-01, uno de los más conocidos, este módulo cuenta con los componentes necesarios para que solamente alimentes el módulo y lo empieces a utilizar.

Firmware para el ESP8266

El ESP-01 viene inicialmente con el “firmware AT”, con el cual puedes usarlo como un adaptador wifi-serial, usando un microcontrolador externo como un Arduino para controlarlo y comunicarse con la red inalámbrica.

Como cualquier microcontrolador se puede cambiar el firmware del ESP8266 y usar cualquiera de los disponibles, entre los más destacables están, uLUA, microPython, y hasta programas hechos en Arduino.

Conexiones del ESP-1

La conexión es bien sencilla solamente se necesita alimentar el módulo, conectar el pin Rx y Tx serial, y conectar el pin CH_PD a 3.3 para activar el chip.

Tomar en cuenta lo siguiente al usar el módulo:

-El ESP8266 se alimenta con 3.3V, ¡no usar 5V!
-El ESP8266 NO tiene entradas tolerantes a 5V, así que necesitas convertir el nivel de las entradas si quieres comunicarte con dispositivos de 5V
-Durante los periodos de comunicación inalámbrica el ESP8266 puede necesitar hasta 250mA, por lo que sin una buena fuente de alimentación el ESP8266 se puede resetear. Si este es el caso utilizar un capacitor en las entradas de alimentación o una fuente de mayor potencia.

Usando el Firmware AT

El firmware AT que viene por defecto en el ESP-01 es el ai-thinker V0.9.2.4. 

Utilización de los comandos:

Por defecto se utiliza un baud rate de 9600.

Después de cada comando, el ESP8266 espera los caracteres especiales de nueva linea <CR><LF> para ejecutar el comando.

Lista de comandos:

Para la lista completa de comandos visita: at_commands

Pruebas básicas con Arduino

Vamos a realizar unas pruebas en las que el módulo estará conectado a un puerto serial por software del Arduino, el puerto serial por hardware lo utilizaremos para comunicarnos con el Arduino via monitor serial.

Para esta prueba vamos a necesitar un módulo ESP-1, un protoboard, cables dupont, resistencias y un Arduino UNO r3.

Conectamos como se muestra en la imagen:

Ahora cargamos el siguiente código en el arduino.

#include <SoftwareSerial.h>
SoftwareSerial ESP(3, 2); // RX | TX

void setup()
  {  Serial.begin(9600);
     ESP.begin(9600);
  }

void loop()
  {
     // Repetir lo recibido por el ESP8266 hacia el monitor serial
     if (ESP.available())
         { char c = ESP.read() ;
           Serial.print(c);
         }

     // Repetir lo recibido por el monitor serial hacia el ESP8266
     if (Serial.available())
         {  char c = Serial.read();
            ESP.print(c);
         }
   }

Ahora vamos a abrir el monitor serial en el IDE del Arduino y configuramos los finales de linea a NL & CR, y el baud rate a 9600 como se muestra en la imagen:

Ahora para probar que todo funciona correctamente vamos a resetear el módulo, para esto conectamos el pin RST a tierra y luego lo desconectamos, cuando lo desconectemos lo siguiente debería aparecer.

Los primeros caracteres son parte de un mensaje del bootloader que no vamos a ver por el momento, se muestran así porque estan en otro baudrate. La siguiente linea que esta entre '[ ]' es el fabricante y la versión de los códigos AT que está cargada. Cuando el módulo transmita "ready" significa que esta listo para recibir comandos.

Probemos con el comando AT, este modo retorna "OK" si todo está en orden.

Ahora vamos a configurar el módulo para se conecte a una red wifi de nuestra casa y empieze a recibir datos:

El módulo solamente será cliente de una red inalámbrica existente por lo establecemos el modo del módulo a estación (cliente), enviamos el comando:

AT+CWMODE=1

Este comando nos retorna "OK" si todo esta correcto, o "no change" si el módulo ya se encontraba en ese modo. El modo se queda grabado aunque se desenergize el módulo.

Ahora vamos a ver las redes inalambricas disponibles enviando:

AT+CWLAP

Ese comando nos retorna una lista con: el tipo de codificación, el nombre de la red, intensidad de señal, dirección MAC del AP, de la siguiente manera.

+CWLAP:(4,"Naylamp",-55,"0a:18:d6:99:59:47",6)
+CWLAP:(2,"VecinoWifi",-78,"10:fe:ed:7a:a9:42",6)
+CWLAP:(3,"Anonymous-Pro",-92,"c4:17:fe:8a:2d:24",11)
OK

Ahora vamos a conectarnos a una de esas redes, para ello enviamos el siguiente comando con el nombre de red seguido por la contraseña, cada dato tipo String siempre va entre comillas:

AT+CWJAP="Naylamp","hail_hydra"

Si después de unos momentos nos responde con "OK" todo salio bien, sino revisa que hayas puesto bien el nombre y contraseña de la red.

Ahora vamos a iniciar un servidor en el módulo. Primero activamos el modo de multiconexión

AT+CIPMUX=1

Luego que nos responda "OK" iniciamos el servidor y le asignamos el número de servicio 1, este servidor correrá en el puerto 80. Este puerto es el mismo que usan los navegadores al solicitar una página web, por lo que podremos probarlo en el siguiente paso.

AT+CIPSERVER=1,80

Ahora vamos a obtener la dirección IP que tiene asignada el módulo en nuestra red local. Para esto usamos lo siguiente.

AT+CIFSR

El módulo nos responderá con una dirección IP. En mi caso fue la 192.168.88.15 si introducimos esta dirección IP en la barra URL de un navegador web como Google Chrome sucede el navegador le solicita la página web al módulo, para esto envia una serie de datos que vamos a poder ver desde el monitor serial, será algo como esto:

Link

+IPD,0,380:GET / HTTP/1.1
Host: 192.168.88.15
Connection: keep-alive
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/44.0.2403.155 Safari/537.36
Accept-Encoding: gzip, deflate, sdch
Accept-Language: es,en-US;q=0.8,en;q=0.6


OK
Link

En el navegador seguira esperando una respuesta (una página web) del módulo, pero como no esta programado para responder no cargará nada. En el monitor serial, el texto de arriba significa que se solicitó información (mediante el método http GET), la dirección a la que va dirigida, tipo de conexión, tipo de archivo que espera recibir, tipo de cliente (navegador) desde el cual se hizo la solicitud e idioma. 

Ahora intentemos en el navegador con la siguiente dirección, reemplazando 192.168.88.15 con la dirección que hayas obtenido antes.

192.168.88.15/hola_mundo

En el monitor serial obtendremos:

Link

+IPD,0,380:GET /Hola_mundo HTTP/1.1
Host: 192.168.88.15
Connection: keep-alive
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/44.0.2403.155 Safari/537.36
Accept-Encoding: gzip, deflate, sdch
Accept-Language: es,en-US;q=0.8,en;q=0.6


OK
Link

En el texto recibido de arriba fijate en la línea que contiene +IPD, en ahi se encuentra el texto que enviamos desde el navegador. Ahora podemos pasar información al módulo mediante el navegador web.

Controlando un led desde el navegador

Vamos a implementar un interpretador de comandos en el Arduino para controlar un LED desde el navegador.

Cargamos en el arduino el siguiente programa:

#include <SoftwareSerial.h>
 // arduino Rx (pin 2) ---- ESP8266 Tx
 // arduino Tx (pin 3) ---- ESP8266 Rx
SoftwareSerial esp8266(3,2); 

void setup()
{
 Serial.begin(9600);  // monitor serial del arduino
 esp8266.begin(9600); // baud rate del ESP8255
 
 pinMode(13,OUTPUT);
 digitalWrite(13,LOW);
 
 sendData("AT+RST\r\n",2000);      // resetear módulo
 sendData("AT+CWMODE=1\r\n",1000); // configurar como cliente
 sendData("AT+CWJAP=\"SSID\",\"PASSWORD\"\r\n",8000); //SSID y contraseña para unirse a red 
 sendData("AT+CIFSR\r\n",1000);    // obtener dirección IP
 sendData("AT+CIPMUX=1\r\n",1000); // configurar para multiples conexiones
 sendData("AT+CIPSERVER=1,80\r\n",1000);         // servidor en el puerto 80
}

void loop()
{
 if(esp8266.available())   // revisar si hay mensaje del ESP8266
 {
 if(esp8266.find("+IPD,")) // revisar si el servidor recibio datos
 {
 delay(1500); // esperar que lleguen los datos hacia el buffer
 int conexionID = esp8266.read()-48; // obtener el ID de la conexión para poder responder
 esp8266.find("led="); // bucar el texto "led="
 int state = (esp8266.read()-48); // Obtener el estado del pin a mostrar
 digitalWrite(13, state); // Cambiar estado del pin

while(esp8266.available()){
 char c = esp8266.read();
 Serial.print(c);
 }
 
 //responder y cerrar la conexión para que el navegador no se quede cargando 
 // página web a enviar
 String webpage = "";
 if (state==1) webpage += "<h1>LED_13 = encendido!</h1>";
 else { webpage += "<h1>LED_13 = apagado!</h1>";}
 
 // comando para enviar página web
 String comandoWebpage = "AT+CIPSEND=";
 comandoWebpage+=conexionID;
 comandoWebpage+=",";
 comandoWebpage+=webpage.length();
 comandoWebpage+="\r\n";
 sendData(comandoWebpage,1000);
 sendData(webpage,1000);
 
 // comando para terminar conexión
 String comandoCerrar = "AT+CIPCLOSE=";
 comandoCerrar+=conexionID;
 comandoCerrar+="\r\n";
 sendData(comandoCerrar,3000);
 }
 }
}

/*
Enviar comando al esp8266 y verificar la respuesta del módulo, todo esto dentro del tiempo timeout
*/
void sendData(String comando, const int timeout)
{
 long int time = millis(); // medir el tiempo actual para verificar timeout
 
 esp8266.print(comando); // enviar el comando al ESP8266
 
 while( (time+timeout) > millis()) //mientras no haya timeout
 {
 while(esp8266.available()) //mientras haya datos por leer
 { 
 // Leer los datos disponibles
 char c = esp8266.read(); // leer el siguiente caracter
 Serial.print(c);
 }
 } 
 return;
}

Lo que hace el programa es automaticamente conectarse a una red inalambrica de nombre SSID y con contraseña PASSWORD. Luego incia un servidor en el puerto 80. Algo nuevo en este programa es que cuando recibe la solicitud del navegador el módulo le contesta con un pequeño mensaje que se visualiza como pagina web en el navegador, esto lo hace con la funcion AT+CIPSEND. 

Podemos verificar la ip asignada al módulo desde el monitor serial del arduino, en mi caso es el 192.168.88.41. Con esta dirección puedo controlar al LED 13 del arduino desde el navegador usando la subdirecciónes

192.168.88.41/led=0 para apagar el LED.

192.168.88.41/led=1 para encender el LED.

Con este tutorial hemos aprendido a usar el arduino en conjunto con el ESP-1 para hacer un pequeño y simple servidor embebido.

Este fue solo un ejemplo y hay muchas cosas por mejorar como: solo ejecutar comandos necesarios al inicio, algunos no necesitan ejecutarse cada vez que se inicia el módulo. Mejorar los tiempos de respuesta para que sea inmediato. También se puede añadir funciones adicionales como mostrar los estados de los pines o del ADC en la página web. Una interfaz con botones para controlar el arduino.

En este tutorial solo vimos conectividad wifi en una red local, pero con los mismos principios se puede conectar el módulo a internet y asi tener realmente un sistema con internet de las cosas.