Después de trabajar el ESP8266 como servidor (Tutorial ESP8266: Parte I), usaremos el ESP8266 como cliente, de esta forma podremos conectarnos a un servidor y poder  enviar o pedir información.

Este tutorial está más orientado a un programador o desarrollador web, que a través de internet desea controlar o recibir datos de un hardware, en este caso Arduino, pero antes de continuar con este tutorial deben de revisa el Tutorial ESP8266 Parte I , en donde se explica sobre el Modulo ESP8266, los comandos AT y se implementa un ejemplo trabajando al ESP8266 como servidor.

Usar el ESP8266 como cliente significa que nuestro Arduino a través del ESP8266 debe de conectarse a un servidor por ejemplo www.google.com o www.naylamp.com , existen varias formas de comunicarse entre cliente servidor, nosotros nos comunicaremos por HTTP, que es la misma forma en la que se comunican los navegadores web (Chrome, mozilla, etc) con los servidores.

Envió de parámetro en un Dialogo HTTP

Cuando un navegador web (El cliente) quiere acceder a una página web (servidor) , envía una petición http (HTTP request) el servidor recibe la petición y le responde con la página web (HTTP response), El encargado de enviar e interpretar esto es el navegador web, el usuario solo escribe la URL y espera a que cargue la página, pero cuando trabajemos con Arduino tenemos que comunicarnos a través de peticiones http.

Existen dos formas fáciles de enviar datos junto con una petición HTTP,  estas son el método GET y POST, La diferencia principal entre estos dos métodos es que en el método GET se envían los datos en la URL, quedando visible para el usuario, mientras que en el método POST los datos quedan ocultos para el usuario. Ambos métodos son muy usados y casi siempre están implementados en las páginas webs que navegamos,  en el siguiente enlace se explica de forma resumida la diferencia de estos:

http://www.miguelmanchego.com/2010/diferencias-entre-envio-get-y-post/

Nosotros Trabajaremos con el Método GET y tomaremos como ejemplo el ejercicio que se explica en la siguiente link: http://aprende-web.net/php/php4_2.php , con la diferencia que no pasaremos variables de una página a otra, sino de nuestro Arduino a una pagina web.

Para enviar datos por el método GET si lo realizamos desde el navegador es simple, solo hay que escribir en la URL los datos que queremos enviar, seria de esta forma:

http://aprende-web.net/php/ejemplos/ej10destino.php?a=125&b=26

Como se observa al link se le agrega al final “?a=125&b=26” de esta forma indicamos que queremos enviar esos parámetros. Cuando al servidor le llega esta consulta, lee los dos datos (a=125 y b=26), y le responde con una página web que muestra los datos que ha recibido

Lo que hace la página es mostrarnos los datos que ha recibido.

El código de la página web es el siguiente:

Al abrir esta página se han pasado las siguientes variables:

 

Este código esta subido en un servidor, y es el servidor el que ejecuta el código PHP y realiza las acciones programadas que en este caso es una simple respuesta HTML en donde podemos ver los datos que ha recibidos.

En el  código de la página que está subida en el servidor  se puede programar para que se conecte a una base de datos y subir las variables, descargar información o haga cualquier otra acción, pero esto dependerá de su necesidad y de sus habilidades como desarrollador web.

Pueden usar esta misma página para desarrollar el tutorial o programar y subir su propia página a un servidor.

Ahora nosotros aremos lo mismo pero en lugar de hacerlo desde el navegador lo trabajaremos desde nuestro ESP8266.

1. Conexiones entre ESP8266 y Arduino:

Para conectar nuestro ESP8266 usaremos un protoboard para ayudarnos con el cableado, los nombres de los pines no están impresos en la PCB pero pueden revisarlos en la siguientes imagen: Pinout módulo ESP8266

ESP8266	Arduino
TX	D10
CH_PD	3V3
RST	No conectado
3.3V	3V3
GND	GND
GPIO2	No conectado
GPIO0	No conectado
RX	D11 (Usando resistencias)

El ESP8266 funciona con 3.3V, por eso en el pin TX del Arduino se recomienda usar resistencias para generar una caída de voltaje, el valor de las resistencias no necesariamente tienen que ser 1K y 2K, pueden usar las resistencias que tengan a la mano pero estas deben tener una relación de 1:2, al usar esas resistencias se forma una divisor de voltaje y el nivel de 5V del TX del Arduino se convierte en un nivel 3.3V. En el caso del RX no es necesario, puesto que el ESP8266 envía a ese pin niveles de 3.3V niveles que el Arduino los considera 1 lógicos.

2. Realizando consultas al servidor usando comandos AT:

Antes de implementar en nuestro Arduino el cliente web, primero revisaremos la secuencia de comandos AT que debemos ejecutar para realizar dicha acción.

Para poder enviar los comandos AT cargamos en nuestro Arduino el siguiente programa:

#include <SoftwareSerial.h>

SoftwareSerial SerialESP8266(10, 11); // RX, TX

void setup() { 
  Serial.begin(9600);
  SerialESP8266.begin(9600);
  //SerialESP8266.begin(115200); //
}

void loop() { 
  if (SerialESP8266.available()) {
    Serial.write(SerialESP8266.read());
  }
  if (Serial.available()) {
    SerialESP8266.write(Serial.read());
  }
}

Este programa solo es un repetidor serial todos los datos que envía el ESP8266 se transmiten a la PC y los que se envían desde la PC se envían al ESP8266

Después de cargar el programa, abrimos el monitor serial y verificamos que nuestro monitor serial esté a la velocidad de 9600 y tenga seleccionado la opción “ambos NL & CR”, seguidamente empezamos a enviar los comandos AT:

Test de comando AT

Enviamos:

AT

Recibimos:

OK

Si no recibimos una respuesta, puede ser que nuestro ESP8266 está configurado a una velocidad diferente a la programada: para esto debemos cambiar la siguiente línea de código y volver a cargar:

  SerialESP8266.begin(115200); 

Ahora nuevamente repetimos el comando y debemos de obtener la respuesta:

Cambiar la velocidad de transmisión serial

Si la velocidad de transmisión de su ESP8266 es de 115200 tenemos que cambiarla a una velocidad de 9600, esto porque en nuestro arduino trabajamos con SoftwareSerial, y con 115200 estaríamos en el límite de velocidad que soporta el SoftwareSerial y podrían perderse algunos caracteres.

Si su ESP8266 trabaja a la velocidad de 9600 ya no realizar este paso.

Para cambiar de velocidad usamos el siguiente comando AT:

Enviamos:

AT+UART_DEF=9600,8,1,0,0

Recibimos:

AT+UART_DEF=9600,8,1,0,0

OK

Donde 9600 es la velocidad, los demás datos son otras configuraciones de la comunicación.

Seguidamente de hacer esto no podremos enviar más comandos puesto que se ha cambiado a la nueva velocidad, tendremos que reprogramar nuestro arduino con la velocidad de 9600, para esto nuevamente cambiar la velocidad en la siguiente línea de código:

  SerialESP8266.begin(9600);

Después, de cargar ahora con la nueva velocidad, debemos de enviar AT y esperar a que nos responda con un OK, de esta forma confirmamos que la velocidad ha sido cambiada correctamente.

Todo el proceso que hemos hecho solo se hace una solo vez, posteriormente así se apague nuestro ESP8266 la velocidad configurada se mantendrá.

Configurado el Modo del Wifi:

Trabajaremos en modo estación, es decir nos conectaremos a una red ya existente:

Enviamos:

AT+CWMODE=1

Recibimos:

AT+CWMODE=1

OK

Conectarse a una red Wifi

Nos conectaremos a la red cuyo nombre es: Naylamp , y su respectivo password es: hail_hydra

Enviamos:

AT+CWJAP=”Naylamp”,”hail_hydra”

Recibimos:

AV+CWJAP=”Naylamp”,”hail_hydra”

WIFI CONNDCTED

WIFI GOT IP

OK

La respuesta nos confirma que ya estamos conectados a la red wifi

Deshabilitamos las conexiones múltiples:

Debido a que vamos a trabajar como cliente web, deshabilitamos las conexiones múltiples, que generalmente se utilizan cunado trabajamos como servidor:

Enviamos:

AT+CIPMUX=0

Recibimos:

AT+CIPMUX=0

OK

Conectarnos con el servidor:

Enviamos:

AT+CIPSTART=”TCP”,”www.aprende-web.net”,80

Recibimos:

CONNECT

Al hacer esto iniciamos la conexión como cliente, y se especifica el tipo de conexión (TCP), el servidor (www.aprende-web.net) y el puerto (80),

Enviar el tamaño de la petición HTTP
Antes de enviar la petición HTTP, es necesario especiar el tamaño en caracteres de la petición:

Enviamos:

AT+CIPSEND=83

Recibimos:

AT+CIPSEND=83

OK

>

Cuando recibimos “>” significa que ya podemos enviar la petición HTTP.

Enviar petición HTTP

Después de  recibir “>” el ESP espera la petición del tamaño indicado para que posteriormente lo envié, para esto enviamos línea por línea la siguiente petición

Enviamos

GET /php/ejemplos/ej10destino.php?a=23&b=56 HTTP/1.1(Enter o Enviar)

Host: www.aprende-web.net(Enter o Enviar)

(Enter o Enviar)

Recibimos:

Recv 83 bytes

SEND OK

+IPD,463:HTTP/1.1 200 OK

Date: Tue, 23 Aug 2016 19:22:56 GMT

Server: Apache

X-Powered-By: PHP/5.3.29

Content-Length: 319

Content-Type: text/html

“http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd”>

 

 

 

 

 

Al abrir esta página se han pasado las siguientes variables:

variable $a : 23

variable $b : 56

 

CLOSED

Lo que recibimos es la respuesta del servidor, en donde se observa el encabezado http y el HTML de la página web de respuesta.
Notar que al final recibimos un CLOSED esto indica que se ha cerrado la conexión con el servidor.

3. Arduino como cliente web usando ESP8266:

Ahora vamos programar en un sketch que enviará los comandos AT los cuales se enviaron manualmente en el ejemplo anterior:

El código es el siguiente:

#include <SoftwareSerial.h>
SoftwareSerial SerialESP8266(10,11); // RX, TX

String server = "www.aprende-web.net";

//variables para enviar al servidor
int variable1=364;
float variable2=3.14;

String cadena="";

void setup() {

  SerialESP8266.begin(9600);
  Serial.begin(9600);
  SerialESP8266.setTimeout(2000);
  
  //Verificamos si el ESP8266 responde
  SerialESP8266.println("AT");
  if(SerialESP8266.find("OK"))
    Serial.println("Respuesta AT correcto");
  else
    Serial.println("Error en ESP8266");

  //-----Configuración de red-------//Podemos comentar si el ESP ya está configurado

    //ESP8266 en modo estación (nos conectaremos a una red existente)
    SerialESP8266.println("AT+CWMODE=1");
    if(SerialESP8266.find("OK"))
      Serial.println("ESP8266 en modo Estacion");
      
    //Nos conectamos a una red wifi 
    SerialESP8266.println("AT+CWJAP="nombre_red","contraseña"");
    Serial.println("Conectandose a la red ...");
    SerialESP8266.setTimeout(10000); //Aumentar si demora la conexion
    if(SerialESP8266.find("OK"))
      Serial.println("WIFI conectado");
    else
      Serial.println("Error al conectarse en la red");
    SerialESP8266.setTimeout(2000);
    //Desabilitamos las conexiones multiples
    SerialESP8266.println("AT+CIPMUX=0");
    if(SerialESP8266.find("OK"))
      Serial.println("Multiconexiones deshabilitadas");
    
  //------fin de configuracion-------------------

  delay(1000);
  
}


void loop() {
  
  //--- programa----------------------

    variable1=analogRead(A0);
    variable2=3.14;
    //otras operaciones
    // . . . 
  
  
  //---------enviamos las variables al servidor---------------------
  
      //Nos conectamos con el servidor:
      
      SerialESP8266.println("AT+CIPSTART="TCP","" + server + "",80");
      if( SerialESP8266.find("OK"))
      {  
          Serial.println();
          Serial.println();
          Serial.println();
          Serial.println("ESP8266 conectado con el servidor...");             
    
          //Armamos el encabezado de la peticion http
          String peticionHTTP= "GET /php/ejemplos/ej10destino.php?a=";
          peticionHTTP=peticionHTTP+String(variable1)+"&b="+String(variable2)+" HTTP/1.1rn";
          peticionHTTP=peticionHTTP+"Host: www.aprende-web.netrnrn";
    
          //Enviamos el tamaño en caracteres de la peticion http:  
          SerialESP8266.print("AT+CIPSEND=");
          SerialESP8266.println(peticionHTTP.length());

          //esperamos a ">" para enviar la petcion  http
          if(SerialESP8266.find(">")) // ">" indica que podemos enviar la peticion http
          {
            Serial.println("Enviando HTTP . . .");
            SerialESP8266.println(peticionHTTP);
            if( SerialESP8266.find("SEND OK"))
            {  
              Serial.println("Peticion HTTP enviada:");
              Serial.println();
              Serial.println(peticionHTTP);
              Serial.println("Esperando respuesta...");
              
              boolean fin_respuesta=false; 
              long tiempo_inicio=millis(); 
              cadena="";
              
              while(fin_respuesta==false)
              {
                  while(SerialESP8266.available()>0) 
                  {
                      char c=SerialESP8266.read();
                      Serial.write(c);
                      cadena.concat(c);  //guardamos la respuesta en el string "cadena"
                  }
                  //finalizamos si la respuesta es mayor a 500 caracteres
                  if(cadena.length()>500) //Pueden aumentar si tenen suficiente espacio en la memoria
                  {
                    Serial.println("La respuesta a excedido el tamaño maximo");
                    
                    SerialESP8266.println("AT+CIPCLOSE");
                    if( SerialESP8266.find("OK"))
                      Serial.println("Conexion finalizada");
                    fin_respuesta=true;
                  }
                  if((millis()-tiempo_inicio)>10000) //Finalizamos si ya han transcurrido 10 seg
                  {
                    Serial.println("Tiempo de espera agotado");
                    SerialESP8266.println("AT+CIPCLOSE");
                    if( SerialESP8266.find("OK"))
                      Serial.println("Conexion finalizada");
                    fin_respuesta=true;
                  }
                  if(cadena.indexOf("CLOSED")>0) //si recibimos un CLOSED significa que ha finalizado la respuesta
                  {
                    Serial.println();
                    Serial.println("Cadena recibida correctamente, conexion finalizada");         
                    fin_respuesta=true;
                  }
              }
    
              
            }
            else
            {
              Serial.println("No se ha podido enviar HTTP.....");
           }            
          }
      }
      else
      {
        Serial.println("No se ha podido conectarse con el servidor");
      }

        
  //-------------------------------------------------------------------------------

  delay(5000); //pausa de 10seg antes de conectarse nuevamente al servidor (opcional)
}

Como se observa son la misma secuencia de comandos que se enviaron manualmente. Trabajamos con dos comunicaciones serial, una (por software) para comunicarnos con el ESP826 y otra (por hardware) para comunicarse con la PC y monitorear el ejemplo.

A continuación mostramos la salida del monitor serial, datos que deben recibir si todo les va bien: