Conectar Arduino por WiFi con el módulo ESP8266 ESP01


¿Qué es el ESP8266?

El ESP8266 es un microprocesador de bajo coste con Wifi 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 Wifi (como el Wifi 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.

En realidad, el ESP8266 es mucho más que un módulo Wifi para Arduino. Es un procesador completo, con mucha más potencia que la mayoría de modelos de Arduino. De hecho es uno de los principales "competidores" a los que se enfrenta Arduino.

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.

En cuanto a comunicación Wifi, el ESP01 tiene comunicación integrada 802.11 b/g/n, incluidos modos Wi-Fi Direct (P2P) y soft-Ap. Incluye una pila de TCP/IP completa, lo que libera de la mayor parte del trabajo de comunicación al procesador.

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 dificultades que finalmente nos harán plantearnos la idoneidad de emplearlo junto a Arduino, o bien optar por una solución basada en ESP8266.

La principal dificultad es la alimentación del ESP01. El ESP8266 y, en particular, el ESP01, tiene una tensión de alimentación de 3.3V. En ningún caso puede alimentarse a una tensión superior a 3.6V, o dañaremos el módulo.

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 insuficiente 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 dificultad. 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.

Finalmente, la comunicación con el módulo se realiza mediante puerto serie. A diferencia de la alimentación del módulo, que en ningún caso debe exceder los 3.6V, existe un amplio debate sobre si los pines RX y TX son tolerantes a 5V (Es decir, si pueden conectarse directamente a un sistema a un 5V).

En principio, conectar RX y TX a un sistema de 5V no parece dañar la placa de forma inmediata. De hecho, encontramos indicios en la documentación que apuntan a que podrían ser tolerantes a 5V, sin quedar totalmente claro. No obstante, tampoco queda claro si puede reducir la vida útil del componente.

En esta entrada conectaremos directamente los pines de RX y TX. Sin embargo, si queréis total seguridad deberéis conectar un adaptador de nivel de 3.3V a 5V en los pines RX y TX.

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 con TX en el pin digital 2 y RX en el pin digital 3, pero podríamos definir el puerto en cualquiera otro pin I/O.

Por tanto, la conexión vista desde Arduino sería la siguiente.

En cuanto a las velocidades, el ESP01 puede configurarse a 9600, 19200, 38400, 74880, 115200, 230400, 460800 y 921600. Por defecto suelen venir, según fabricante, a 9600 o 115200.

Si vamos a usar Arduino como intermediario evitaremos las velocidades de 115200 en adelante porque la comunicación puede volverse inestable y aparecer errores.

Ejemplos de código

Uso del ESP8266 con comandos AT

La comunicación con el ESP01 con el firmware 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.

A continuación cargamos el siguiente Sketch en Arduino, que seguramente alguno reconocerá como el programa Serial Loop. Este sketch únicamente actúa "puente" entre el puerto serie hardware conectado con el PC, y el puerto serie Soft conectado al ESP01.

// La velocidad depende del modelo de ESP-01
// siendo habituales 9600 y 115200
const int baudRate = 9600;

#include "SoftwareSerial.h"
SoftwareSerial softSerial(2, 3); // RX, TX

void setup()
{
	Serial.begin(baudRate);
	softSerial.begin(baudRate);
}

void loop()
// enviar los datos de la consola serial al ESP-01, 
// y mostrar lo enviado por el ESP-01 a nuestra consola
{
	if (softSerial.available())
	{
		Serial.print((char)softSerial.read());
	}
	if (Serial.available())
	{
		softSerial.print((char)Serial.read());
	}
}

Una vez cargado el Sketch, encendemos (o reiniciamos) el ESP01. En el Monitor Serie el ESP01 responde con una serie de caracteres que dependen del fabricante y modelo, y finalmente "Ready", indicando que el módulo está listo.

Si ahora escribimos AT, el módulo responderá con "OK", indicando de nuevo que el módulo está listo para su uso.

Si no veis el mensaje inicial finalizado en "Ready" y en su lugar aparecen "caracteres raros", cambiar la velocidad del puerto Serie en el Sketch Serial Loop, y en el Monitor Serie.

Listado comandos AT

A continuación, un listado de algunos de los comandos AT disponibles para el ESP8266.

//**** GENERAL ****
// Acknowlege, se recive "ok"
AT

// Reset, reinicia el módudo. 
// Se recive una cadena de texto que depende del modelo y fabricante y, al final, "READY"
AT+RST



//**** CONFIGURACION ****
// Obtener la velocidad de transmision
AT+CIOBAUD?

// Cambiar la velocidad de transmision (en el ejemplo a 9600)
// Velocidades validas 9600, 19200, 38400, 74880, 115200, 230400, 460800 y 921600
AT+CIOBAUD=9600
AT+IPR=9600

// Obtener el modo de funcionamiento
// 1 Station
// 2 SoftAp
// 3 Station + SoftAp
AT+CWMODE?

// Cambia el modo de funcionamiento a 1, 2 o 3
// Lo normal es AT+CWMODE=3, por que es el más versátil
// Tras el cambio es necesario AT+RST
AT+CWMODE=mode

//**** UNISER A UNA RED WIFI ****
// List Access Point
// Muestra una lista de las redes wifi disponibles
AT+CWLAP

// Join Access Point
// Unirse a una red wifi existente
AT+CWJAP=you ssid, password

// Check if connected successfully, or use AT+CWJAP=?, or use AT+CIFSR to find your ip address
AT+CWJAP?

// Obtener la IP del módulo
AT+CIFSR



//**** CREAR UNA RED WIFI ****

// Crear una red wifi
AT+CWSAP="ssid","password",3,0

// Listar los dispositivos conectados a la red generada
AT+CWLIF


//**** TCP SERVER ****
// Configura un servidor TCP en el puerto 80 (1 significa activado)
AT+CIPSERVER=1,80


//**** TCP CLIENT ****
// Activar multiples conexiones
AT+CIPMUX=1

// Conectar con el servidor remoto 192.168.1.100 en el puerto 80
AT+CIPSTART=4,"TCP","192,168.1.100",80

// Configurar el modo de transmisión
AT+CIPMODE=1

// Enviar data por el canal 4 (en el ejemplo 5 bytes)
AT+CIPSEND=4,5

Ejemplos AT

Aquí tenemos algunos ejemplos sencillos para realizar acciones básicas con el ESP01 a través de comandos AT.

// Listar las redes WiFi y conectar a una de ella
// sustituir SSID y PASSWORD por los parametros de la red
AT+CWLAP
AT+CWJAP=SSID,PASSWORD


// Establecer conexión como cliente
AT+CWJAP=SSID,PASSWORD
AT+CIPMUX=1
AT+CIPSTART=4,"TCP","google.com",80

// Establecer una conexión como servidor
realizar un servidor
AT+CWJAP=SSID,PASSWORD
AT+CIPMUX=1
AT+CIPSERVER=1,80

Por ejemplo, para configurar el ESP01 desde un Arduino para actuar como servidor pasaríamos los comandos AT de la siguiente forma.

#include "SoftwareSerial.h"
SoftwareSerial softSerial(2, 3); // RX, TX

const int baudRate = 9600;
char* SSDI = "tuWifi";
char* password = "tuPassword";

void setup()
{
	Serial.begin(baudRate);
	softSerial.begin(baudRate);
	delay(1000);

	softSerial.write("AT+CWJAP=\"");
	softSerial.write(SSDI);
	softSerial.write("\",\"");
	softSerial.write(password);
	softSerial.write("\"\r\n");

	delay(4000);
	softSerial.write("AT+CIPMUX=1\r\n");
	delay(2000);
	softSerial.write("AT+CIPSERVER=1,80\r\n");
}

void loop()
{
	if (softSerial.available())
	{
		Serial.print((char)softSerial.read());
	}
	if (Serial.available())
	{
		softSerial.print((char)Serial.read());
	}
}

Uso del ESP8266 con librería

Existen varias librerías que facilitan el uso del ESP8266 junto con Arduino, aunque no tampoco son muy abundantes ya que en general se prefiere programar el propio ESP8266. Estas librería emplean los mismos comandos AT que hemos visto anteriormente y gestionan las respuestas recibidas, evitándonos a nosotros el trabajo.

Una de las más completas es la librería ITEADLIB Arduino WeeESP8266, disponible en este enlace.

Si queremos usar la librería con el software serial es necesario entrar en el fichero ESP8266.h y descomentar la línea.

#define ESP8266_USE_SOFTWARE_SERIAL

Otra mejoras sugeridas para el empleo del ESP8266 con Arduino son incremenar el tamaño del buffer del hardware serial o software serial, para lo cuál es necesario editar el fichero \arduino\hardware\arduino\avr\cores\arduino\HardwareSerial o \arduino\hardware\arduino\avr\cores\arduino\SoftwareSerial y modificar la siguiente línea.

// En HardwareSerial.h
#define SERIAL_BUFFER_SIZE 64

// En SoftwareSerial.h
#define _SS_MAX_RX_BUFF 64 // RX buffer size

Aunque, personalmente, no recomiendo modificar el tamaño del buffer. Si el tamaño del buffer se queda corto es porque deberías realizar el tratamiento de los datos en el propio ESP01, o usar otra máquina, pero no modificar el tamaño del buffer.

Cliente Wifi - Leer páginas web

En este ejemplo Arduino actúa como cliente, es decir, se conecta a una página web para leerla. Leer una página completa y volcarla por el puerto serie es muy lento, y es una de las muestras de las limitaciones de Arduino frente a un ordenador.

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 fichero de texto, que realice una determinada acción si existe un fichero, 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.

En la página www.pasted.co/2434bc64 he pegado el texto ~1.2.3.4.5~. Los ‘~’ los usaremos como separadores para encontrar el texto deseado ‘1.2.3.4.5’, que simula una serie de parámetros que queremos capturar de un servidor.

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.

#include "ESP8266.h"
#include <SoftwareSerial.h>

const char* SSID = "myssid";
const char* PASSWORD = "mypassword";
const char* HOST_NAME = "www.pasted.co";
const int HOST_PORT = 80;

SoftwareSerial softSerial(2, 3); // RX, TX
ESP8266 wifi(softSerial);

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

	if (wifi.setOprToStationSoftAP()) {
		Serial.print("to station + softap ok\r\n");
	}
	else {
		Serial.print("to station + softap err\r\n");
	}

	if (wifi.joinAP(SSID, PASSWORD)) {
		Serial.print("Join AP success\r\n");
		Serial.print("IP:");
		Serial.println(wifi.getLocalIP().c_str());
	}
	else {
		Serial.print("Join AP failure\r\n");
	}

	if (wifi.disableMUX()) {
		Serial.print("single ok\r\n");
	}
	else {
		Serial.print("single err\r\n");
	}

	Serial.print("setup end\r\n");
}

void loop(void)
{
	uint8_t buffer[800] = { 0 };

	if (wifi.createTCP(HOST_NAME, HOST_PORT)) {
		Serial.print("create tcp ok\r\n");
	}
	else {
		Serial.print("create tcp err\r\n");
	}

	char *request = "GET /2434bc64 HTTP/1.1\r\nHost: www.pasted.co\r\nConnection: close\r\n\r\n";
	wifi.send((const uint8_t*)request, strlen(request));

	uint32_t len = wifi.recv(buffer, sizeof(buffer), 10000);
	if (len > 0) 
	{
		Serial.print("Received:\r\n");
		for (uint32_t i = 0; i < len; i++) 
		{
			char c = (char)buffer[i];
			if (c == '~')
			{
				for (uint32_t j = i + 1; j < len; j++)
				{
					c = (char)buffer[j];
					if (c == '~') break;
					Serial.print(c);
				}
				break;
			}
		}
		Serial.print("\r\n");
	}

	while (1) delay(1000);
}

Servidor Wifi - Atender peticiones

En este ejemplo configuramos el módulo ESP01 para actuar como un servidor Web, es decir, recibir solicitudes por WiFi y responder a ellas.

#include "ESP8266.h"
#include <SoftwareSerial.h>

const char* SSID = "myssid";
const char* PASSWORD = "mypassword";

SoftwareSerial softSerial(2, 3); // RX, TX
ESP8266 wifi(softSerial);

void setup(void)
{
	Serial.begin(9600);
	Serial.print("setup begin\r\n");
	
	wifi.restart();
	delay(500);

	if (wifi.setOprToStationSoftAP()) {
		Serial.print("to station + softap ok\r\n");
	}
	else {
		Serial.print("to station + softap err\r\n");
	}

	if (wifi.joinAP(SSID, PASSWORD)) {
		Serial.print("Join AP success\r\n");
		Serial.print("IP: ");
		Serial.println(wifi.getLocalIP().c_str());
	}
	else {
		Serial.print("Join AP failure\r\n");
	}

	if (wifi.enableMUX()) {
		Serial.print("multiple ok\r\n");
	}
	else {
		Serial.print("multiple err\r\n");
	}

	if (wifi.startTCPServer(80)) {
		Serial.print("start tcp server ok\r\n");
	}
	else {
		Serial.print("start tcp server err\r\n");
	}

	if (wifi.setTCPServerTimeout(10)) {
		Serial.print("set tcp server timout 10 seconds\r\n");
	}
	else {
		Serial.print("set tcp server timout err\r\n");
	}

	Serial.println("setup end\r\n");
}


void loop(void)
{
	uint8_t buffer[128] = { 0 };
	uint8_t mux_id;

	uint32_t len = wifi.recv(&mux_id, buffer, sizeof(buffer), 100);
	if (len > 0) {
		Serial.print("Received from: ");
		Serial.print(mux_id);
		Serial.print("\r\n");
		for (uint32_t i = 0; i < len; i++) {
			Serial.print((char)buffer[i]);
		}
		Serial.print("\r\n");
		
		if (wifi.releaseTCP(mux_id)) {
			Serial.print("release tcp ");
			Serial.print(mux_id);
			Serial.println(" ok");
		}
		else {
			Serial.print("release tcp");
			Serial.print(mux_id);
			Serial.println(" err");
		}

		Serial.print("Status: ");
		Serial.print(wifi.getIPStatus().c_str());
		Serial.println();
	}
}

Si ahora en un navegador web introducimos la dirección IP local que se ha asignado al ESP01 veremos que el ESP8266 nos "sirve" una página web, que no es más que el contenido de la solicitud que ha emito el navegador (en realidad parte de la solicitud).

Si modificamos 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.

Servidor WiFI - Controlar salidas digitales

El este ejemplo Arduino actúa también como servidor, pero esta vez queremos que el usuario pueda realizar acciones sobre Arduino a través de la página web que servimos.

#include "ESP8266.h"
#include <SoftwareSerial.h>

const char* SSID = "myssid";
const char* PASSWORD = "mypassword";


SoftwareSerial softSerial(2, 3); // RX, TX
ESP8266 wifi(softSerial);

void setup(void)
{
	pinMode(LED_BUILTIN, OUTPUT);

	Serial.begin(9600);
	Serial.print("setup begin\r\n");
	
	wifi.restart();
	delay(500);
	if (wifi.setOprToStationSoftAP()) {
		Serial.print("to station + softap ok\r\n");
	}
	else {
		Serial.print("to station + softap err\r\n");
	}

	if (wifi.joinAP(SSID, PASSWORD)) {
		Serial.print("Join AP success\r\n");
		Serial.print("IP: ");
		Serial.println(wifi.getLocalIP().c_str());
	}
	else {
		Serial.print("Join AP failure\r\n");
	}

	if (wifi.enableMUX()) {
		Serial.print("multiple ok\r\n");
	}
	else {
		Serial.print("multiple err\r\n");
	}

	if (wifi.startTCPServer(80)) {
		Serial.print("start tcp server ok\r\n");
	}
	else {
		Serial.print("start tcp server err\r\n");
	}

	if (wifi.setTCPServerTimeout(20)) {
		Serial.print("set tcp server timout 20 seconds\r\n");
	}
	else {
		Serial.print("set tcp server timout err\r\n");
	}

	Serial.println("setup end\r\n");
}

#define wifiWrite(A) wifi.send(mux_id, (uint8_t*) A, sizeof(A) - 1);
void loop(void)
{
	uint8_t buffer[128] = { 0 };
	uint8_t mux_id;

	uint32_t len = wifi.recv(&mux_id, buffer, sizeof(buffer), 100);
	if (len > 0) {
		Serial.print("Received from: ");
		Serial.print(mux_id);
		Serial.print("\r\n");

		wifiWrite("HTTP/1.1 200 OK\r\nnContent-Type: /html\r\nConnection: close\r\n\r\n");
		wifiWrite("<html>\n<head>\n<title>Luis Llamas</title>\n</head>\n<body>");
		wifiWrite("<h2>Salidas digitales</h2>");
		wifiWrite("<button onClick=location.href='./?data=0'>ON</button>");
		wifiWrite("<button onClick=location.href='./?data=1'>OFF</button>");
		wifiWrite("</body></html>");

		Serial.println("Send finish");

		for (uint32_t i = 0; i < len; i++) {
			char c = (char)buffer[i];
			if (c == '?')
			{
				if ((char)buffer[i + 6] == '1')
				{
					digitalWrite(LED_BUILTIN, HIGH);
					Serial.println("LED ON");
				}
				else
				{
					digitalWrite(LED_BUILTIN, LOW);
					Serial.println("LED OFF");
				}

				break;
			}
		}
	}
}

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
4.2 5 votes
Article Rating

Anuncio:

Previous Conectar Arduino a Internet con módulo Ethernet ENC28J60
Next Implementar un array de tamaño dinámico en Arduino
28 Comments
oldest
newest
Inline Feedbacks
View all comments
Osqui
3 years ago

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
3 years ago
Reply to  Osqui

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
3 years ago
Reply to  luisllamas

Mmm, entiendo. ¡Muchas gracias!

victor mancilla
3 years ago

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

JoseM
3 years ago

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
3 years ago
Reply to  JoseM

Hola. Tienes conectada la linea GND? Me pasó algo similar y yo estaba seguro que estaba todo bien conectado (TX, RX, GND), pero verificando 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
3 years ago

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?

Polko
2 years ago
Reply to  Dr T

Hola, yo tengo el mismo problema, pudiste solucionarlo de alguna manera?
me aparece el "ready" pero al escribir AT, nunca da el OK.

Juancho
3 years ago

Hola!
Muy bueno el artículo!
Me sabrías decir hasta qué distancia puedo conectar dos módulos ESP8266 01 entre sí?

Nacho
3 years ago

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 wifi. No se si me explico. Muchas gracias, Saludos!

Luis Eli
3 years ago

Luis, he leido con atencion este y muchos articulos tuyos. Ando buscando utilizar un arduino que use el esp01 como modulo wifi para interactuar con la plataforma thinger.io Si tienes algo te dejo mi correo !De nuevo gracias!

Nacho
3 years ago

Muchas gracias por el articulo.
¿Hay alguna forma de configurar el módulo ESP01 para que cree una red wifi a la que conectarse?

Angela
2 years ago

Gracias,
Al descomentar la línea #define ESP8266_USE_SOFTWARE_SERIAL y cargar el código nuevamente me sale el error:

serv:10: error: no matching function for call to 'ESP8266::ESP8266(SoftwareSerial&)'

Master pro
2 years ago

excelente tutorial una pregunta como puedo acceder al servidor sin estar conectado ala misma red que el esp8266?

Mike
1 year ago
Reply to  Master pro

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
2 years ago

Hola
Muchas gracias por el tutorial
Cuantos dispositivos se podrían conectar a la red wifi que se crea?
Gracias

Edgardo Mancini
2 years ago

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 figura una libreria que no tengo instalada y me da error. Desde donde la puedo instalar? la misma es #include "ESP8266.h"
Muchas gracias.

Antonio Rueda Treviño
2 years ago

Buenas localizaste la libreria?

larry aguilera
2 years ago

Hola Luis,
Muchas Gracias por su portal es de gran ayuda!

Quisiera saber cual es el microcontrolador con Wifi que tenga al menos dos entradas analogicas y que sea mas economico que el arduino UNO wifi?

Ricardo
1 year ago

Buenas, tengo un arduino recogiendo datos con un Max485 de un inversor fotovoltaico.
La cuestión es que quiero poner un ESP-1 y entrando por ip, leer los datos que recoge arduino.
Por mas que busco por la red mas me lio y no se por donde empezar

Claudio
1 year ago

Hola Luis! Felicitaciones por todo el trabajo que te has tomado. Excelente material.
Consulta: He conectado un Arduino UNO al ESP01 y en Arduino cargué el squetch de la primer prueba que publicas. El problema es que sólo obtengo caracteres extraños (⸮⸮⸮⸮>⸮I⸮ڒ⸮⸮⸮⸮R⸮⸮0⸮⸮N֟⸮2%K⸮\⸮×⸮⸮փ⸮⸮t⸮⸮⸮+:⸮4⸮⸮A⸮) He revisado varias veces las conexiones y están correctas. Lo comunico a 9600 y el módulo está alimentado por una fuente de 3.3V
Es necesario programar el módulo o se supone que con esta prueba debiera funcionar sin tocar nada?
Desde ya agradezco de antemano cualquier ayuda

Hernán Gómez Vélez
1 year ago

Buenos días, es posible conectar este módulo ESP01 con un sensor de temperatura GY-906 MLX90614 ESF, toda vez que el GY-906 viene con confección I2C. Los conectores SCL y SCA que son a 5V del GY_906 podrían quemar la placa ESP01. Es especialmente importante que sea el módulo ESP01.

MUCHAS GRACIAS.

Francisco Javier
1 year ago

Buenas noches Luís:
Intento poner en marcha una D1 mini y no lo consigo. He probado con todas las velocidades posibles y no consigo una respuesta ready, y por supuesto no hay respuesta a comandos AT. ¿Qué puedo hacer?

Lucas
10 months ago

Hola Luis, muchas gracias por todas las ayudas y explicaciones que das. Estoy con un problema. El modulo ESP enciende el led testigo, pero en el serial monitor no tengo ninguna respuesta. Alguna pista de que puede estar mal?