Académique Documents
Professionnel Documents
Culture Documents
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.
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
1
<h1>Al abrir esta página se han pasado las siguientes variables:</h1>
<?php
$a=$_GET['a'];
$b=$_GET['b'];
echo "<p>variable $a : $a";
echo "<p>variable $b : $b";
?>
</body>
</html>
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.
ESP8266 Arduino
TX D10
CH_PD 3V3 El
RST No conectado
3.3V 3V3
GND GND
GPIO2 No conectado
GPIO0 No conectado
RX D11 (Usando resistencias)
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
2
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:
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á.
3
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
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
4
X-Powered-By: PHP/5.3.29
Content-Length: 319
Content-Type: text/html
El código es el siguiente:
#include <SoftwareSerial.h>
5
SoftwareSerial SerialESP8266(10,11); // RX, TX
String cadena="";
void setup() {
SerialESP8266.begin(9600);
Serial.begin(9600);
SerialESP8266.setTimeout(2000);
//------fin de configuracion-------------------
delay(1000);
void loop() {
//--- programa----------------------
variable1=analogRead(A0);
variable2=3.14;
//otras operaciones
// . . .
6
//---------enviamos las variables al servidor---------------------
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");
7
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");
}
//-------------------------------------------------------------------------------
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:
8
9
10