Arduino con esp8266

El ESP8266-01 ha sido un gran módulo para saciar toda nuestra sed de proyectos IOT. Desde su lanzamiento, ha desarrollado una comunidad sólida y se ha convertido en un módulo Wi-Fi potente, económico y fácil de usar. Otra plataforma de código abierto que es mucho más popular es Arduino, ya tiene toneladas de proyectos construidos a su alrededor. La combinación de estas dos plataformas abrirá las puertas a muchos proyectos innovadores, por lo que en este tutorial aprenderemos cómo conectar el módulo ESP8266-01 con Arduino. De esta forma podremos enviar o recibir datos entre Arduino e Internet.

Para el propósito de este tutorial , leeremos la hora, fecha, temperatura y humedad de Internet usando una API con el ESP8266-01. Luego envíe estos valores a una placa Arduino y muéstrelos en la pantalla LCD 16 * 2. Suena bien, ¿verdad? Entonces empecemos.

Materiales necesarios:

1. Placa Arduino (cualquier versión)
2. ESP8266-01
3. Placa programadora FTDI con opción de 3,3 V
4. LCD de 16x2
5. Potenciómetro
6. Presionar el botón
7. Cables de conexión
8. Tablero de circuitos

¿Como funcionan las cosas?

Antes de sumergirnos, es importante saber cómo va a funcionar realmente esto. Básicamente, tenemos que comenzar con el módulo ESP8266-01. Usaremos el IDE de Arduino para programar el ESP8266 y el código se escribirá para usar una API para leer un archivo JSON a través de una solicitud http. Luego, expresaremos este archivo JSON para extraer solo la información requerida del archivo JSON completo.

Una vez redactada la información, la imprimiremos utilizando la comunicación en serie. Estas líneas seriales luego se conectarán al Arduino, para que Arduino pueda leer la información enviada desde ESP8266. Una vez leída y procesada la información la mostraremos en la pantalla LCD.

Está bien, si no lo ha entendido completamente, ya que aprenderemos lo mismo en el resto de este tutorial.

Programando el ESP8266-01:

Este tutorial asume que tienes algo de experiencia con el módulo ESP8266. Si no es así, se recomienda leer los siguientes tres tutoriales para comprenderlo completamente.

1. Empezando con ESP8266-01
2. Programando ESP8266-01 usando comandos AT
3. Programando el ESP8266-01 usando Arduino IDE y flasheando su memoria

También puede consultar todos nuestros proyectos ESP8266 aquí.

Aquí vamos a programar el módulo ESP8266-01 usando el IDE de Arduino. Para el hardware estamos usando la placa FTDI con 3.3V para programar el ESP8266, ya que simplificará mucho el hardware. El diagrama de circuito para conectar su ESP8266 con la placa FTDI se muestra a continuación.

Asegúrese de que se cumplan las siguientes condiciones

1. El ESP8266-01 solo es tolerante a 3.3V, no use 5V. Así que configure FTDI solo en modo 3.3V.

2. GPIO_0 debe estar conectado a tierra para el modo de programación

3. El pin de reinicio debe conectarse a través de un botón al pin de tierra. Este botón debe presionarse justo antes de cargar el código. Cada vez que se presione el botón, el LED azul en el módulo ESP8266-01 se encenderá para indicar que el módulo se reinicia.

Una vez que se realizan las conexiones, abra el IDE de Arduino y verifique si puede cargar un programa de muestra con éxito. Si no está seguro de cómo usar el IDE de Arduino para cargar el programa en ESP8266, siga la Programación ESP8266 con Arduino para aprenderlo. En este punto, supongo que ha cargado correctamente el programa Blink.

. El programa completo se proporciona al final de esta página, más abajo, y los explico como pequeños fragmentos. El programa también requiere la biblioteca Arduino JSON para compilar, por lo que si aún no ha agregado la biblioteca a su Arduino IDE, agréguela descargándola de la biblioteca Arduino JSON de Github.

El ESP8266 tiene que conectarse a Internet para obtener los datos sobre fecha, hora, temperatura y humedad. Por lo tanto, debe permitir que se conecte a su Wi-Fi probando el SSID y la contraseña en las siguientes líneas

const char * ssid = "JIO-Fi"; // Ingrese su SSID Wi-Fi const char * password = "Pas123"; // Ingresa tu contraseña de Wi-Fi

Dentro de la configuración () la función que comprobar si el ESP es capaz de conectar con la red Wi-Fi, si no se va a esperar para siempre simplemente mediante la impresión de “Conexión..” en el monitor de serie.

while (WiFi.status ()! = WL_CONNECTED) {// Espere hasta que Wi-Fi esté conectado delay (1000); Serial.print ("Conectando…"); // Imprimir Conectando… hasta que se establezca la conexión }

El siguiente paso es el paso muy importante. Si la conexión Wi-Fi es exitosa, tenemos que invocar una solicitud http get para leer el archivo JSON de Internet. En este tutorial estoy usando la API proporcionada por wunderground.com. Entonces, si planea usar el mismo, puede ingresar al enlace y registrarse para obtener la clave API gratuita o usar cualquier API de su elección. Una vez que haya finalizado con su API, terminará con un enlace similar a este a continuación

Nota: He cambiado la clave API de este enlace, por lo que no funcionará. Mantenga su clave API segura y no la comparta.

Mi API aquí se utiliza para obtener los datos meteorológicos de Chennai. Puede utilizar cualquier API. Pero cuando carga la API en cualquier navegador, debería devolver un archivo JSON. Por ejemplo, mi API devuelve el siguiente archivo JSON

El suyo puede devolver un archivo con datos diferentes. Podemos verificar si este archivo JSON también es recibido por nuestro ESP8266 leyéndolo e imprimiendo JSON en nuestro monitor serial usando las siguientes líneas

int httpCode = http.GET (); // pasa una solicitud de obtención si (httpCode> 0) {// Verifica el código de retorno // payload = http.getString (); // Almacenar el valor en la carga útil varibale para la depuración // Serial.println (carga útil); // Imprime la carga útil para depurar; de lo contrario, comenta ambas líneas

He comentado estas líneas, ya que solo son necesarias para probar. Una vez que se haya asegurado de que ESP8266 pueda obtener los datos JSON, es hora de redactar los datos. Como puede ver, estos datos son enormes y la mayoría de los valores son inútiles excepto los que nos son requeridos como fecha, hora, temperatura y humedad.

Entonces usamos la biblioteca JSON Arduino para separar los valores requeridos para nosotros y almacenarlos en una variable. Esto es posible porque los valores en el archivo JSON se asignan como pares de nombre y valor. Entonces, este nombre es una cadena que tendrá el valor requerido para nosotros.

Para hacer esto tenemos que movernos a un sitio web que analizará el archivo JSON y nos dará el código Arduino. Sí, es tan fácil como eso. Proceda a https://arduinojson.org/assistant/ y pegue el archivo JSON que cargamos en nuestro navegador y presione enter. Cuando terminó, el mío se veía algo así a continuación

Desplácese un poco hacia abajo para ver el programa de redacción que se crea automáticamente

Todo lo que tiene que hacer es seleccionar la variable que desea, copiarla y pegarla en su IDE de Arduino, como he hecho aquí.

/ * Fraseo de datos usando JSON librarey * / // Use https://arduinojson.org/assistant/ para obtener los valores de fraseo para su cadena JSON const size_t bufferSize = JSON_OBJECT_SIZE (0) + JSON_OBJECT_SIZE (1) + JSON_OBJECT_SIZE (2) + 2 * JSON_OBJECT_SIZE (3) + JSON_OBJECT_SIZE (8) + JSON_OBJECT_SIZE (12) + JSON_OBJECT_SIZE (56) + 2160; DynamicJsonBuffer jsonBuffer (bufferSize); JsonObject & root = jsonBuffer.parseObject (http.getString ()); / * Fin de los datos de fraseo * / // Direccione el valor sin a las variables deseadas JsonObject & current_observation = root; // bajo current_observation JsonObject & current_observation_observation_location = current_observation; // en ubicación_observación const char * current_observation_station_id = current_observation; // "ICHENNAI1" // obtén los detalles de la ubicación const char * current_observation_local_time_rfc822 = current_observation; // Hora local // obtener la hora local const char * current_observation_temperature_string = current_observation; // "90.7 F (32.6 C)" // obtener el valor de temperatura const char * current_observation_relative_humidity = current_observation; // "73%" // obtener el valor de humedad

Acabo de copiar las variables current_observation_station_id, current_observation_local_time_rfc822, current_observation_temperature_string y current_observation_relative_humidity . Dado que estamos planeando mostrar solo esos cuatro datos en nuestra pantalla LCD.

Finalmente, hemos obtenido los datos que necesitamos de Internet y los hemos guardado como una variable que podemos utilizar cómodamente. Para enviar estos datos a Arduino solo los tenemos que escribir en serie a través del monitor Serial. Las siguientes líneas harán exactamente lo mismo

// Imprime las variables a través del monitor serial Serial.print (current_observation_station_id); // envía los detalles de la ubicación a Arduino delay (100); // retraso de estabilidad Serial.print (current_observation_local_time_rfc822); // envía los detalles de la hora local a Arduino delay (100); // retraso de estabilidad Serial.print (current_observation_temperature_string); // envía los detalles de la temperatura a Arduino delay (100); // retardo de estabilidad Serial.print (current_observation_relative_humidity); // envía los detalles de humedad a Arduino delay (100); // retraso de estabilidad

Tenga en cuenta que he usado Serial.print () y no Serial.println () ya que el comando Serial.println () agregará una / n y / r junto con los datos que no son necesarios para nosotros. También hemos agregado un retraso de 10 segundos para que el ESP envíe estos valores solo en un intervalo de 10 segundos a Arduino.

Conectando ESP8266-01 con Arduino:

Hasta ahora hemos programado nuestro ESP8266-01 para leer los datos requeridos de Internet en un intervalo de 10 segundos y enviarlos en serie. Ahora tenemos que conectar el ESP con Arduino para que podamos leer estos datos en serie. También tenemos que agregar una pantalla LCD de 16 * 2 a Arduino para que podamos mostrar los datos recibidos del módulo ESP8266. El diagrama de circuito para interconectar el módulo ESP8266 con Arduino se muestra a continuación

Asegúrese de que el pin GPIO_0 quede libre, encienda el módulo solo con el pin 3.3V de Arduino y presione el botón para poner el módulo ESP en el módulo operativo. Ahora, el programa que subimos a ESP debería haber comenzado a funcionar y el módulo debería enviar los datos a través del pin serial a Arduino. Estos pines seriales están conectados a los pines número 6 y 7 en el Arduino. Entonces podemos usar la opción de serie de software en Arduino para leer estos datos en serie de los pines.

Programa y funcionamiento de Arduino:

El programa completo de Arduino también se proporciona junto con el código ESP al final de esta página. Puede desplazarse hacia abajo para ver el programa o leer más si desea comprender el programa.

El programa de interfaz es bastante simple, solo tenemos que usar la biblioteca en serie del software para leer los datos de los pines 6 y 7 y mostrarlos en la pantalla LCD. Dado que los datos que se reciben están en formato de cadena, tenemos que usar la opción de subcadena para romper la carga útil a nuestro requisito o incluso convertirla en entero si es necesario. Entonces, comenzamos definiendo los pines a los que está conectada la pantalla LCD.

const int rs = 8, en = 9, d4 = 10, d5 = 11, d6 = 12, d7 = 13; // Pines a los que se conecta el LCD LiquidCrystal lcd (rs, en, d4, d5, d6, d7);

Como nos hemos conectado los pines Rx y Tx de ESP8266 con el 6 y el 7 ^º pin de Arduino que tenemos que inicializar la serie de software para los pasadores para que podamos recibir los datos en serie de ellos.I tienen nombres como esta ESP_Serial, puede nómbrelos como desee

SoftwareSerial ESP_Serial (6,7); // Tx, Rx

Dentro de la función setup () inicializamos la comunicación serial para el monitor serial y también para el software serial. Si puede recordar, hicimos el programa ESP para comunicarse a una velocidad de 9600 baudios, por lo que tenemos que usar la misma velocidad en baudios para el puerto serie del software. También mostramos un pequeño mensaje de introducción en la pantalla LCD durante 2 segundos.

configuración vacía () {lcd.begin (16, 2); // Estamos usando una pantalla LCD de 16 * 2 lcd.print ("Arduino & ESP"); // Mostrar un mensaje de introducción Serial.begin (115200); ESP_Serial.begin (9600); retraso (2000); lcd.clear (); }

Dentro de la función main loop () tenemos que verificar si el ESP8266 está enviando algo. Si es así, leemos la cadena de ESP8266 y la guardamos en una variable llamada carga útil. La carga útil variable es de tipo String y contendrá la información completa enviada desde el módulo ESP8266.

while (ESP_Serial.available ()> 0) {carga útil = ESP_Serial.readString ();

Ahora tenemos que dividir esta cadena en pequeños trozos para que podamos usarlos para nuestro propio propósito, en este caso tenemos que dividirlos para mostrarlos en la pantalla LCD. Esto se puede hacer fácilmente usando la función de subcadena en Arduino. Debe conocer la posición de cada carácter para usar esta función de subcadena . Puede imprimir la carga útil en el monitor en serie para conocer la posición de los caracteres y usarlos para categorizar las subcadenas como se muestra a continuación

local_date = payload.substring (14, 20); local_time = payload.substring (26, 31); temperatura = payload.substring (48, 54); Humedad = payload.substring (55, 60);

Ahora puedo seguir adelante y usar estas variables para imprimirlas en el monitor en serie o simplemente imprimirlas en la pantalla LCD. Sin embargo, imprimirlos en el monitor Serial nos ayudará a verificar si las subcadenas están divididas correctamente. A continuación, los imprimimos en la pantalla LCD usando las siguientes líneas

lcd.clear (); lcd.setCursor (1, 0); lcd.print (fecha_local); lcd.setCursor (8, 0); lcd.print (hora_local); lcd.setCursor (1, 1); lcd.print (temperatura); lcd.setCursor (10, 1); lcd.print (humedad);

Cargue el programa en Arduino y asegúrese de que las conexiones sean las que se muestran en el diagrama de circuito anterior. Ajuste el contraste de la pantalla LCD hasta que vea las cosas con claridad. Debería ver el mensaje de introducción en la pantalla LCD y luego de unos segundos los detalles como la fecha, la hora, la temperatura y la humedad deben aparecer en la pantalla LCD como se muestra a continuación.

También puede notar que el LED azul en el ESP8266 parpadea cada vez que ingresan los datos. Si no puede ver esto, significa que el ESP no está en modo de programación, intente presionar el botón Reset y verifique las conexiones.

De manera similar, puede usar cualquier API para obtener los datos necesarios de Internet y enviarlos al Arduino y procesar su trabajo con Arduino. Hay toneladas de API disponibles en Internet y con todas ellas puedes realizar una cantidad ilimitada de proyectos. Espero que haya entendido el proyecto y haya disfrutado construyéndolo. Si ha tenido algún problema, publíquelo en la sección de comentarios a continuación o en nuestros foros.

Puede encontrar todos nuestros proyectos relacionados con ESP8266 aquí.