Conectar Arduino Por WiFi Con El Módulo ESP8266 ES PDF
Conectar Arduino Por WiFi Con El Módulo ESP8266 ES PDF
LUIS LLAMAS
Ingeniería, informática y diseño
27 MAYO, 2017
¿QUÉ ES EL ESP8266?
El ESP8266 es un microprocesador de bajo coste con Wi integrado fabricado por
Espressif. Podemos usar el ESP8266 para conectar nuestros proyectos de electrónica y robótica
con Arduino.
Antes del ESP8266, las opciones disponibles para conectar un Arduino a Wi (como el Wi
Shield) eran prohibitivamente caras. La aparición del ESP8266 supuso una pequeña revolución
al ser el primer dispositivo realmente barato que proporcionaba conectividad WiFi.
Existen muchos modelos de placas que integran el ESP8266, y una creciente comunidad de
usuarios en torno a este procesador. Trataremos extensamente sobre más detalles y modelos
con ESP8266 en la sección de tutoriales avanzados.
Anuncio:
De momento en esta entrada nos limitaremos a emplear Arduino junto con un módulo
ESP01, un de los primeros en aparecer con el chip ESP8266 y uno de los módulos más sencillos
y baratos.
El ESP01 monta la versión más sencilla del ESP8266. Aún así, sigue siendo un procesador de
32bits a 80 Mhz, con 512kB o 1MB de memoria según modelo. Dispone de 2 pines GPIO, SPI, I2C
y UART.
Podemos usar el ESP01 para dotar de conectividad WiFi a nuestros proyectos con Arduino.
Sin embargo, como comentamos con los módulos de Ethernet, la comunicación con Internet
puede suponer una carga excesiva para Arduino.
En caso de requerir un uso intensivo de Internet, deberemos plantearnos otras alternativas
como Raspberry Pi, Orange Pi, o, curiosamente, el propio ESP8266.
PRECIO
Los módulos ESP8266 de tipo ESP01 son muy baratos, ya que como hemos dicho es uno de
los motivos de su amplio éxito. Podemos encontrarlos por 1.65€ en vendedores internacionales
de eBay o AliExpress.
ESQUEMA DE MONTAJE
La conexión de un módulo ESP01 con Arduino no es complicada, aunque en la práctica van
a aparecer ciertas di cultades que nalmente nos harán plantearnos la idoneidad de emplearlo
junto a Arduino, o bien optar por una solución basada en ESP8266.
Por otro lado, el consumo del módulo puede sobrepasar los 200mA, sobre todo durante la
conexión y arranques. Sin embargo, el regulador de voltaje de 3.3V de Arduino sólo puede
proporcionar 50mA (150mA en algunos modelos), lo cual es insu ciente para alimentar el
ESP01.
Por tanto, necesitaremos alimentar el ESP01 con una fuente externa de 3.3V. De lo
contrario experimentaremos continuos cortes y cuelgues durante su funcionamiento, que
además pueden reducir la vida útil del ESP01.
El resto de la conexión no tiene ninguna di cultad. Por un lado tenemos el pin CH_PD que
apaga o enciende el módulo conectándolo, respectivamente, a Gnd o 3.3V. Por su parte, el pin
RST reinicia el módulo si se conecta a Gnd. En algunas versiones del módulo podremos dejarlo
sin conexión pero, en general, tendremos que conectarlo a 3.3V para que el módulo arranque.
En esta entrada conectaremos directamente los pines de RX y TX. Sin embargo, si queréis
Para la conexión con Arduino podemos emplear el puerto serie normal, pero esto implica
que tendremos que desconectar el ESP01 cuando queramos programar Arduino, y no
podremos usar el puerto serie para la comunicación con el PC.
Por este motivo frecuentemente se emplea un puerto serie por software. No obstante,
tener en cuenta que esto supone una carga de procesado importante para Arduino.
En los esquemas de esta entrada asumimos que estamos usando un puerto serie software
En cuanto a las velocidades, el ESP01 puede con gurarse a 9600, 19200, 38400, 74880,
115200, 230400, 460800 y 921600. Por defecto suelen venir, según fabricante, a 9600 o 115200.
EJEMPLOS DE CÓDIGO
USO DEL ESP8266 CON COMANDOS AT
La comunicación con el ESP01 con el rmware por defecto se realiza a través de
comandos AT, que recordemos no son más que comandos de texto enviados por Serial.
Podemos enviar estos comandos por un conversor USB-TTL (FT232, CH340G o CP2102) o,
en nuestro caso, usando Arduino y Software serial como adaptador.
PRIMERA PRUEBA
Vamos a hacer la primera prueba de conexión con el ESP01. Para ello conectamos el ESP01
a Arduino como hemos visto en el apartado anterior. Dejamos conectado Arduino al ordenador
por USB.
25
26
LISTADO COMANDOS AT
A continuación, un listado de algunos de los comandos AT disponibles para el ESP8266.
67
68
69
70
71
72
73
EJEMPLOS AT
Aquí tenemos algunos ejemplos sencillos para realizar acciones básicas con el ESP01 a
través de comandos AT.
Por ejemplo, para con gurar el ESP01 desde un Arduino para actuar como servidor pasaríamos los
comandos AT de la siguiente forma.
1 #include "SoftwareSerial.h"
2 SoftwareSerial softSerial(2, 3); // RX, TX
3 const int baudRate = 9600;
4 char* SSDI = "tuWifi";
5 char* password = "tuPassword";
6
7 void setup()
8 {
9 Serial.begin(baudRate);
10 softSerial.begin(baudRate);
11 delay(1000);
12
13 softSerial.write("AT+CWJAP=\"");
14 softSerial.write(SSDI);
15 softSerial.write("\",\"");
16 softSerial.write(password);
17 softSerial.write("\"\r\n");
18
19 delay(4000);
20 softSerial.write("AT+CIPMUX=1\r\n");
21 delay(2000);
softSerial.write("AT+CIPSERVER=1,80\r\n");
22 }
23
void loop()
24 {
25 if (softSerial.available())
26 {
27 Serial.print((char)softSerial.read());
28 }
29 if (Serial.available())
30 {
softSerial.print((char)Serial.read());
31 }
32 }
33
34
35
36
Una de las más completas es la librería ITEADLIB Arduino WeeESP8266, disponible en este
enlace.
1 #define ESP8266_USE_SOFTWARE_SERIAL
Otra mejoras sugeridas para el empleo del ESP8266 con Arduino son incremenar el tamaño
del bu er del hardware serial o software serial, para lo cuál es necesario editar el chero
\arduino\hardware\arduino\avr\cores\arduino\HardwareSerial o
\arduino\hardware\arduino\avr\cores\arduino\SoftwareSerial y modi car la siguiente línea.
1 // En HardwareSerial.h
2 #define SERIAL_BUFFER_SIZE 64
3
4 // En SoftwareSerial.h
5 #define _SS_MAX_RX_BUFF 64 // RX buffer size
Aunque, personalmente, no recomiendo modi car el tamaño del bu er. Si el tamaño del
bu er se queda corto es porque deberías realizar el tratamiento de los datos en el propio
ESP01, o usar otra máquina, pero no modi car el tamaño del bu er.
Sin embargo, puede ser útil para Arduino capture información desde un servidor. Por
ejemplo, podemos hacer que sincronice la hora, que lea una serie de parámetros de un chero
de texto, que realice una determinada acción si existe un chero, etc.
Para mostrar en este ejemplo esta capacidad de lectura de datos desde un servidor en
Internet vamos a usar www.pasted.co, una de muchas páginas web que nos permiten añadir un
texto para compartirlo con más gente.
El siguiente ejemplo se conecta con esta dirección y realiza la búsqueda del texto 1.2.3.4.5,
que muestra por puerto serie. En un ejemplo real emplearíamos estos valores, por ejemplo,
para controlar un robot, cambiar los parámetros de medición de una estación, encender o
apagar un dispositivo, etc.
1 #include "ESP8266.h"
2 #include <SoftwareSerial.h>
3
4 const char* SSID = "myssid";
5 const char* PASSWORD = "mypassword";
const char* HOST_NAME = "www.pasted.co";
6 const int HOST_PORT = 80;
7 SoftwareSerial softSerial(2, 3); // RX, TX
8 ESP8266 wifi(softSerial);
9
void setup(void)
10 {
11 Serial.begin(9600);
12
13 if (wifi.setOprToStationSoftAP()) {
14 Serial.print("to station + softap ok\r\n");
15 }
16 else {
Serial.print("to station + softap err\r\n");
17 }
18 if (wifi.joinAP(SSID, PASSWORD)) {
19 Serial.print("Join AP success\r\n");
20 Serial.print("IP:");
Serial.println(wifi.getLocalIP().c_str());
21 }
22 else {
23 Serial.print("Join AP failure\r\n");
}
24
if (wifi.disableMUX()) {
25 Serial.print("single ok\r\n");
26 }
else {
27 Serial.print("single err\r\n");
28 }
29
Serial.print("setup end\r\n");
30 }
31
32 void loop(void)
33 {
uint8_t buffer[800] = { 0 };
34
35 if (wifi.createTCP(HOST_NAME, HOST_PORT)) {
36 Serial.print("create tcp ok\r\n");
}
37 else {
38 Serial.print("create tcp err\r\n");
39 }
40
41 char *request = "GET /2434bc64 HTTP/1.1\r\nHost: www.pasted.co\r\nConnection: clo
42 se\r\n\r\n";
43 wifi.send((const uint8_t*)request, strlen(request));
44
45 uint32_t len = wifi.recv(buffer, sizeof(buffer), 10000);
46 if (len > 0)
{
47 Serial.print("Received:\r\n");
for (uint32_t i = 0; i < len; i++)
48 {
49 char c = (char)buffer[i];
50 if (c == '~')
{
51 for (uint32_t j = i + 1; j < len; j++)
52 {
53 c = (char)buffer[j];
if (c == '~') break;
Serial.print(c);
54 }
break;
55 }
56 }
Serial.print("\r\n");
57 }
58
59 while (1) delay(1000);
}
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
1 #include "ESP8266.h"
2 #include <SoftwareSerial.h>
3
4 const char* SSID = "myssid";
5 const char* PASSWORD = "mypassword";
6 SoftwareSerial softSerial(2, 3); // RX, TX
7 ESP8266 wifi(softSerial);
8 void setup(void)
9 {
10 Serial.begin(9600);
11 Serial.print("setup begin\r\n");
12
13 wifi.restart();
14 delay(500);
15
16 if (wifi.setOprToStationSoftAP()) {
17 Serial.print("to station + softap ok\r\n");
18 }
else {
19 Serial.print("to station + softap err\r\n");
}
20
21 if (wifi.joinAP(SSID, PASSWORD)) {
22 Serial.print("Join AP success\r\n");
Serial.print("IP: ");
23 Serial.println(wifi.getLocalIP().c_str());
24 }
25 else {
Serial.print("Join AP failure\r\n");
26 }
27 if (wifi.enableMUX()) {
28 Serial.print("multiple ok\r\n");
}
29 else {
30 Serial.print("multiple err\r\n");
31 }
32 if (wifi.startTCPServer(80)) {
33 Serial.print("start tcp server ok\r\n");
34 }
35 else {
Serial.print("start tcp server err\r\n");
36 }
37
38 if (wifi.setTCPServerTimeout(10)) {
Serial.print("set tcp server timout 10 seconds\r\n");
39 }
40 else {
41 Serial.print("set tcp server timout err\r\n");
42 }
43 Serial.println("setup end\r\n");
44 }
45
46 void loop(void)
47 {
48 uint8_t buffer[128] = { 0 };
uint8_t mux_id;
49
uint32_t len = wifi.recv(&mux_id, buffer, sizeof(buffer), 100);
50 if (len > 0) {
51 Serial.print("Received from: ");
52 Serial.print(mux_id);
Serial.print("\r\n");
53 for (uint32_t i = 0; i < len; i++) {
54 Serial.print((char)buffer[i]);
55 }
56 Serial.print("\r\n");
57
58 if (wifi.releaseTCP(mux_id)) {
59 Serial.print("release tcp ");
60 Serial.print(mux_id);
61 Serial.println(" ok");
62 }
63 else {
64 Serial.print("release tcp");
Serial.print(mux_id);
65 Serial.println(" err");
66 }
67 Serial.print("Status: ");
68 Serial.print(wifi.getIPStatus().c_str());
69 Serial.println();
}
70 }
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
Si modi camos la solicitud, por ejemplo, añadiendo parámetros GET, veremos que el
ESP8266 recibe los parámetros a través de la URL de la solicitud, lo cuál podemos usar para
realizar acciones en el lado del servidor, como veremos en la siguiente entrada.
1 #include "ESP8266.h"
2 #include <SoftwareSerial.h>
3
4 const char* SSID = "myssid";
5 const char* PASSWORD = "mypassword";
6
7 SoftwareSerial softSerial(2, 3); // RX, TX
8 ESP8266 wifi(softSerial);
9 void setup(void)
10 {
11 pinMode(LED_BUILTIN, OUTPUT);
12
13 Serial.begin(9600);
14 Serial.print("setup begin\r\n");
15
16 wifi.restart();
delay(500);
17 if (wifi.setOprToStationSoftAP()) {
18 Serial.print("to station + softap ok\r\n");
19 }
20 else {
Serial.print("to station + softap err\r\n");
21 }
22 if (wifi.joinAP(SSID, PASSWORD)) {
23 Serial.print("Join AP success\r\n");
24 Serial.print("IP: ");
Serial.println(wifi.getLocalIP().c_str());
25 }
26 else {
27 Serial.print("Join AP failure\r\n");
}
28
if (wifi.enableMUX()) {
29 Serial.print("multiple ok\r\n");
30 }
else {
31 Serial.print("multiple err\r\n");
32 }
33
if (wifi.startTCPServer(80)) {
34 Serial.print("start tcp server ok\r\n");
35 }
36 else {
37 Serial.print("start tcp server err\r\n");
}
38
39 if (wifi.setTCPServerTimeout(20)) {
40 Serial.print("set tcp server timout 20 seconds\r\n");
}
41 else {
42 Serial.print("set tcp server timout err\r\n");
43 }
44
Serial.println("setup end\r\n");
45 }
46
47 #define wifiWrite(A) wifi.send(mux_id, (uint8_t*) A, sizeof(A) - 1);
void loop(void)
48 {
49 uint8_t buffer[128] = { 0 };
50 uint8_t mux_id;
51 uint32_t len = wifi.recv(&mux_id, buffer, sizeof(buffer), 100);
if (len > 0) {
52 Serial.print("Received from: ");
53 Serial.print(mux_id);
54 Serial.print("\r\n");
55 wifiWrite("HTTP/1.1 200 OK\r\nnContent-Type: /html\r\nConnection: close\r\n\r
56 \n");
57 wifiWrite("<html>\n<head>\n<title>Luis Llamas</title>\n</head>\n<body>");
wifiWrite("<h2>Salidas digitales</h2>");
58 wifiWrite("<button onClick=location.href='./?data=0'>ON</button>");
59 wifiWrite("<button onClick=location.href='./?data=1'>OFF</button>");
60 wifiWrite("</body></html>");
61 Serial.println("Send finish");
62
63 for (uint32_t i = 0; i < len; i++) {
64 char c = (char)buffer[i];
65 if (c == '?')
66 {
if ((char)buffer[i + 6] == '1')
67 {
68 digitalWrite(LED_BUILTIN, HIGH);
Serial.println("LED ON");
69 }
70 else
71 {
72 digitalWrite(LED_BUILTIN, LOW);
Serial.println("LED OFF");
}
73
break;
}
74 }
}
75 }
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
Para ello, servimos una página web con dos botones, que permitirán encender o apagar el
LED integrado en Arduino. La extensión de la página que podemos servir es bastante reducida
pero, como ya hemos repetido varias veces, si tenéis que servir páginas complejas seguramente
deberíais pensar en usar el ESP8266 de forma independiente, o en usar otra máquina.
Al hacer click en los correspondientes botones, la URL solicitada tiene como parámetro '?
data=0' o '?data=1'. Estos parámetros se obtienen a través de la URL de la solicitud, empleando
el carácter '?' como separador.
En función de que el carácter tras '?data=' sea igual a '0' o '1' se enciende o apaga el LED
integrado, y se muestra la acción por el puerto serie.
Si te ha gustado esta entrada y quieres leer más sobre Arduino puedes consultar la sección
tutoriales de Arduino
Anuncio:
Arduino,Arduino intermedio,Comunicación,ESP8266,Internet,Wi ,Wireless
PREVIOUS
CONECTAR ARDUINO A INTERNET CON MÓDULO ETHERNET ENC28J60
NEXT
IMPLEMENTAR UN ARRAY DE TAMAÑO DINÁMICO EN ARDUINO
9 1 19
14
newest oldest
Osqui
Hola!
Muchas gracias por estos artículos tan estupendos!
Una pregunta: ¿merece la pena pasarse al nuevo módulo ESP32 en vez de seguir usando el
ESP8266?
Gracias!
luisllamas
Depende. El ESP32 es una bestia de procesador pero cuesta el doble que un ESP8266,
que aunque sea inferior es un buen procesador.
A medida que el ESP32 baje acabará sustituyendo al ESP8266, pero a día de hoy
depende de qué proyectos estés haciendo. Si no vas a usar las funciones de más del
ESP32, puedes ahorrarte el sobrecoste.
Osqui
victor mancilla
hola muy buen articulo gracias
una consulta respecto a wemos d1 esp 8266
necesito conectar varios sensores analogicos a el pero este solo cuenta con una entrada analoga
existe alguna forma de poder hacerlo
o conectar esta placa a aun arduino
de antemano gracias
Luis
La opción de usar un Arduino Nano, por ejemplo, es una opción válida. Aunque lo más
habitual sería emplear un multiplexor como este https://www.luisllamas.es/mas-salidas-
y-entradas-en-arduino-con-multiplexor-cd74hc4067/
JoseM
Hola:
Muchas gracias por el tutorial, llevo sus buenas horas intentando conectar un arduino uno con el
módulo, hasta ahora solo obtengo "????????????????" como salida en el monitor de serie. He
intenté conectarlo con un convertidor USB-TTL y no conseguí nada distinto, he probado todas las
velocidades desde 4800 a 115200 e intenté con otro módulo y nada ¿ tienes alguna idea de que
estoy haciendo mal?, agradecería cualquier idea.
Carlos
Hola. Tienes conectada la linea GND? Me pasó algo similar y yo estaba seguro que
estaba todo bien conectado (TX, RX, GND), pero veri cando con más atención me
encontré con que el GND estaba conectado a un pin que no llegaba a GND en mi
protoboard!! Chequealo por las dudas.
Dr T
hola, muchas gracias por poner luz en la oscuridad...! igualmente tengo el mismo problema que
JoseM. Probé distintas combinaciones de velocidades entre el sketch y el monitor serie, pero en
ninguna obtengo el OK.
Alguna idea de que mirar?
Luis
Puede que venga con otro rmware cargado. Podéis o restituir el original, o
directamente pasar y reprogramar el ESP8266 con el programa que queréis, y
pasar de los comandos AT
Juancho
Hola!
Muy bueno el artículo!
Me sabrías decir hasta qué distancia puedo conectar dos módulos ESP8266 01 entre sí?
Nacho
Hola Luis, excelente post, muy claro! Te hago una consulta, veo que para el servidor usas una
llamada recv. Entiendo que esto es bloqueante, por lo que el hilo del programa quedará
esperando allí hasta tener alguna comunicación entrante. Al no contar con hilos de ejecución
multiples (multi-threadings) en Arduino, ¿Sabes como se manejan este tipo de cuestiones? Por
ejemplo, si tuvieramos una aplicación que esté sensando otro tipo de interfaces que le den
ordenes al arduino (como pulsadores), y también quisieramos recibir comandos por medio de
wi . No se si me explico. Muchas gracias, Saludos!
Luis Eli
Luis, he leido con atencion este y muchos articulos tuyos. Ando buscando utilizar un arduino que
use el esp01 como modulo wi para interactuar con la plataforma thinger.io Si tienes algo te dejo
mi correo !De nuevo gracias!
Nacho
Muchas gracias por el articulo.
¿Hay alguna forma de con gurar el módulo ESP01 para que cree una red wi a la que
conectarse?
Angela
Gracias,
Al descomentar la línea #de ne ESP8266_USE_SOFTWARE_SERIAL y cargar el código nuevamente
me sale el error:
Master pro
excelente tutorial una pregunta como puedo acceder al servidor sin estar conectado ala misma
red que el esp8266?
Mike
Como en todos los casos en que hay que accede desde internet a una conexion local hay
que hacer un port forwarding en el router a la IP del modulo
Aaron
Hola
Muchas gracias por el tutorial
Cuantos dispositivos se podrían conectar a la red wi que se crea?
Gracias
Edgardo Mancini
Hola Luis !. Muy buenos tus trabajos y enriquecedores. Sos un grande que hace grandes aportes
a la comunidad de Arduino , Raspberry Pi y muchos otros temas con tus publicaciones.
Te pregunto en los sketch de este articulo gura una libreria que no tengo instalada y me da
error. Desde donde la puedo instalar? la misma es #include "ESP8266.h"
Muchas gracias.
larry aguilera
Hola Luis,
Muchas Gracias por su portal es de gran ayuda!
Quisiera saber cual es el microcontrolador con Wi que tenga al menos dos entradas analogicas
y que sea mas economico que el arduino UNO wi ?
Ricardo
Luis
Hola. Prueba con la sección del ESP8266, tienes muchos tutoriales que pueden ayudarte
en tu proyecto. Un saludo!
Buscar
NOS VEMOS EN
INGENIERIA
PROGRAMACION
TUTORIALES ARDUINO
ZONA GEEK
Excepto notación expresa, los contenidos de este sitio se ofrecen bajo licencia Creative Commons
License BY-NC-SA.
Más información
ANA
on Detector de metales con Arduino y sensor inductivo
Hola Luis buenas tardes Estoy probando el código y el sensor no me detecta. el…
JAIME
on Reproducir sonidos con Arduino y un buzzer pasivo o altavoz