Si todavía no sabes cómo configurar IFTTT con Arduino y NodeMCU o no sabes las ventajas que ofrece esta plataforma, estás seriamente limitando las capacidades de tus proyectos. La traducción de IFTTT es «Si esto, entonces eso» y permite combinar servicios de diferentes orígenes a través de la lógica.
IFTTT es una herramienta de productividad muy potente, sencilla y con capacidades casi infinitas. Por ejemplo, te permite cambiar la hora del despertador si el tráfico es malo, desactivar la WiFi cuando no estás en casa o enviar un Tweet si la temperatura de tu casa supera un valor. Todo esto sin programar.
Hasta hace poco tiempo, era difícil que el hardware y los objetos pudieran utilizar IFTTT. Pero todo esto ha cambiado debido al nuevo servicio que ofrece esta plataforma, IFTTT Maker. A través de servicios web nos permite comunicar Arduino o ESP8266 al mundo de los servicios.
¿Te imaginas las capacidades que puede llegar a tener en el IoT? Sin duda alguna, se trata del vínculo perfecto entre máquinas y servicios de Internet. En este artículo te voy a mostrar cómo puedes enviar un Tweet con IFTTT desde Arduino y NodeMCU.
Indice de contenidos
¿Qué es el IFTTT?
IFTTT es una plataforma que pone en contacto diferentes aplicaciones web o servicios de Internet. Lo hace de una manera muy peculiar, a través de la lógica. El significado de IFTTT es «If This Then That» lo que viene a decir «Que si pasa esto, haz lo otro«.
IFTTT nos permite configurar un disparador o un evento que desencadenará una reacción. Pongamos un ejemplo que podemos ver dentro de la plataforma. Imagina que cuando llueva en tu ciudad, quieres que te avise a través de un email o incluso que te cambie la hora del despertador para despertarte más tarde o más pronto.
El disparador o evento es la lluvia. Se puede detectar de diferentes maneras, pero lo lógico es que sea a través de algún servicio meteorológico. La parte de la reacción se configurar a través de la app IFTTT disponible para iOS y Android.
Pero ¿qué sucede si en vez de detectar la lluvia a través de un servicio meteorológico quieres hacerlo a través de Arduino y NodeMCU? Bueno pues hasta hace bien poco, esto era complejo. Pero gracias al servicio IFTTT Maker, ahora es bastante más sencillo.
Todo gracias a los servicios web. En este artículo veremos un ejemplo y enviaremos un Tweet desde estas dos placas.
La finalidad de IFTTT es que cuando suceda algo, una acción, lance otro proceso, reacción. ¿Te imaginas lo que puedes hacer con esto? Si sube la temperatura del sensor, envíame un email, envíame un Tweet, publica en Facebook o guarda la temperatura en Google Drive.
¿Qué servicios encontramos dentro de IFTTT?
Prácticamente permite poner en contacto todos los servicios que existen en Internet, es una locura :). Por ejemplo, podemos conectarnos a una hoja de cálculo de Google Drive y almacenar información de temperatura, humedad o cualquier magnitud física obtenida desde nuestra placa.
Hay servicios catalogados para Facebook, Instagram, Apps de Google, para Android, para iOS, Alexa, Google Home, Adafruit y un sin fin de aplicaciones más. Solo tienes que pensar qué quieres hacer y buscar el servicio que mejor se ajuste a tus necesidades.
Vamos a ver un ejemplo. Si tienes un dispositivo Android, puedes utilizar IFTTT para que configure tu teléfono y que al salir de casa apague la WiFi de forma automática. Estas son recetas o, Applets. Lo único que tienes que hacer es configurar tu App.
Si realmente quieres ver el potencial que tiene IFTTT, te recomiendo que entres en su página web y veas las recetas y servicios que tienes disponibles.
Configuración IFTTT Maker para enviar un Tweet desde Arduino y NodeMCU
Lo primero es darte de alta en la plataforma. Da lo mismo que entres al servicio Maker o al servicio original de IFTTT. Esto te permitirá crear tus propias recetas. También encontrarás recetas creadas por otros usuarios e incluso podrás compartir las tuyas.
Si ahora mismo no lo entiendes no te preocupes, verás como dentro de muy poco todo tendrá sentido. Antes de continuar déjame que te explique algo fundamental y que debes entender para comprender cómo utilizar juntos IFTTT, Arduino y NodeMCU.
¿Cómo captamos algo del mundo físico, como pulsar un botón, y lo traducimos a una reacción en el mundo virtual? Aquí está la clave de todo. Gracias a los servicios web esto es posible y podemos poner en contacto estos dos mundos.
¿Qué son los servicios web?
Seguramente ya me hayas oído hablar en más de una ocasión de los servicios web o API web. Es una interfaz de software que nos permite comunicarnos entre diferentes sistemas es decir, lo que pretenden es que podamos acceder a las bases de datos, a los servicios, herramientas, etc…. de una máquina a través de URLs.
Vamos a verlo con un ejemplo. Si quieres almacenar una temperatura en una base de datos, creas una página web con PHP, C#, Java o el lenguaje de backend que prefieras. Esta página web lo que hará es capturar la información que se envíe mediante los diferentes métodos HTTP (GET, POST, PUSH, DELETE, HEAD) y almacenarla en la base de datos.
Es un proceso sencillo, tu desde un navegador, desde otra aplicación, desde un móvil o desde un Arduino haces la llamada a una URL como www.midominio.com/guardar_temperatura.php?temperatura=145 y la página PHP se encarga de recoger ese valor y almacenarlo.
Pues así funciona el servicio Maker de IFTTT. A través de URLs lanzaremos los eventos que ejecutarán las acciones como guardar temperatura, enviar un tweet, enviar un email, encender una luz o lo que sea.
Configurar nuevo Applet de IFTTT
Vale, ahora que ya sabes qué es un servicio web, ya puedes crear tu primer Applet de IFTTT. Ves a tu nombre de usuario y haz click en New Applet.
Como ya te he comentado más arriba, tenemos una acción o evento y una reacción. Tienes que configurar los dos servicios por separado. Empezaremos con la acción (this).
Configurar acción o evento IFTTT
Cuando creas un nuevo Applet, lo primero es seleccionar la acción. Haz click en + this.
Una vez has hecho click, te aparece un campo de búsqueda y un montón de servicios que puedes utilizar. Algunos se basan en la fecha y la hora, otros en el email o en redes sociales. El que nos interesa a nosotros para comunicar nuestro Arduino o ESP8266 con IFTTT es el servicio Maker Webhooks.
Así que, en el campo donde pone Search services escribe «Webhooks». Puede que aparezca más de un servicio. En la siguiente imagen te indico cual es que hay que elegir.
Y ¿qué es un servicio Maker Webhooks? Pues precisamente es un servicio web es decir, es un servicio que está esperando una petición web, una llamada a una URL concreta.
Para configurar el servicio Maker haz click en el recuadro gris.
Lo siguiente es poner un nombre al evento por ejemplo, enviar_tweet. Luego pulsa el botón Create trigger para crear el trigger. Este evento es el que nos va a permitir seleccionar la acción a través de una URL.
Y con esto ya habríamos terminado la parte de la acción o evento (this).
Configurar reacción IFTTT
En esta parte vamos a configurar la aplicación o servicio que queremos que se ejecute con la acción que hemos configurado antes es decir, la reacción. Para acceder al servicio Maker tenemos que hacer una petición HTTP lo que viene a ser escribir una URL en un navegador :).
De momento no sabemos cuál es, eso lo veremos más tarde. Como ejemplo voy a configurar mi cuenta de Twitter para que publique un Tweet. Haz click en + that.
Seleccionamos o buscamos el servicio de Twitter.
Una vez que seleccionas el servicio de Twitter, te pedirá que conectes con tu cuenta en esta red social y que des permisos a IFTTT para que publique en tu nombre.
Ahora puedes seleccionar una acción eligiendo entre 5 opciones:
- Enviarnos un mensaje directo a nosotros mismos
- Enviar un Tweet
- Enviar un Tweet con una imagen
- Actualizar nuestra bio en Tweeter
- Actualizar la imagen de perfil
En este ejemplo voy a enviar un Tweet con la cuenta de Programarfacil, @programarfacilc. Así que seleccionamos la acción Post a tweet.
Bueno, ahora hay que configurar el texto a enviar a Twitter. Aquí es donde empezamos a ver el gran potencial ya que podemos incorporar variables. Por ejemplo, podemos añadir el nombre del evento que hemos configurado antes y la fecha y la hora en la que se ejecutó el evento o disparador.
Para poner el nombre del evento dentro del Tweet debes utilizar este texto {{EventName}} y, automáticamente sustituirá la propiedad por el nombre que hayamos puesto.
Pero no solo eso, podemos añadir más ingredientes es decir, variables. En total podemos elegir 3 variables (Value1, Value2 y Value3) y la fecha en la que se lanzó el evento (OccurredAt).
La fecha está claro y los valores pueden ser de cualquier tipo. Por ejemplo, imagínate que quieres enviar la temperatura y la humedad en un Tweet. Para eso sirven estos valores. Luego veremos cómo enviarlos desde un Arduino o un ESP8266.
Vamos a escribir el texto definitivo del mensaje. En mi caso será el siguiente
|
1 2 3 4 5 |
Tweet de prueba #IFTTT #Arduino "{{EventName}}". Temperatura ({{Value1}}) Humedad ({{Value2}}) ValorA0 ({{Value3}}) Hora: {{OccurredAt}} |
Y quedaría de la siguiente manera.
Una vez que lo tengas, haz click en Create action. Por último nos quedaría revisar y finalizar el Applet. En este último paso, podemos modificar la descripción. Cuando hayas terminado pulsa Finish.
Probar Applet IFTTT
Ya lo tenemos todo preparado en IFTTT, pero antes de configurar el Arduino MKR1000 o el NodeMCU, vamos a probar el Applet. Comunicar con la acción es relativamente sencillo gracias a los servicios web.
Para probar el nuevo Applet accede a esta URL https://maker.ifttt.com, y haz click en Settings.
En la ventana que aparece debes copiar la URL. Mucho cuidado con esta dirección web ya que aquí viene concatenada la clave secreta de tu cuenta IFTTT que luego utilizaremos dentro del código de Arduino y del NodeMCU.
Pega la URL en una ventana o pestaña de un navegador. Se abrirá una nueva página web donde nos pide los campos de nombre de evento y los tres valores que queremos utilizar. Todo esto ya lo hemos configurado en los pasos anteriores.
Rellena la información de la siguiente manera:
- En este campo pon el nombre del evento.
- Pon el valor que quieras que aparezca en el value1.
- Lo mismo pero con el valu2.
- Y por último el value3.
Ahora haz click en Test It y vete a tu cuenta de Twitter para ver si se ha publicado. Como puedes comprobar en la cuenta de Twitter de Programarfacil (@programarfacilc) si que se ha publicado con toda la información.
Lo realmente importante es quedarnos que vamos a enviar una petición GET a la url https://maker.iftttt.com/trigger/{event}/with/key/{secret_key}?value1={value1}&value2={value2}&value3={value3} donde debemos sustituir los parámetros por los configurados en IFTTT.
Esto precisamente es lo que utilizaremos dentro de nuestro Arduino MKR1000 y del NodeMCU para enviar la información a Twitter.
Configurar Arduino MKR1000 para utilizar IFTTT
El objetivo es poder hacer una petición mediante HTTP a la URL que hemos visto. Esto lo conseguimos en Arduino MKR1000 utilizando como cliente la placa. Prácticamente no vamos a tener que hacer nada ya que hay un ejemplo que viene incorporado con la librería WiFi 101.
Si utilizas otro tipo de placa que se conecta por ejemplo por Ethernet, los pasos serán muy parecidos. Lo único que cambiarán son las sentencias para hacer la petición HTTP.
Si todavía no tienes configurado tu Arduino MKR1000, puedes ver el tutorial donde te explico cómo configurar la WiFi.
#1 Abrir el ejemplo WifiWebClient de la librería WiFi101
Este ejemplo lo puedes encontrar en la web oficial de Arduino, pero también lo puedes abrir desde el propio IDE de Arduino. Vete a Archivo/Ejemplos/WiFi101/WiFiWebClient.
#2 Adaptación del código y añadir parámetros del IFTTT
En este segundo paso lo que voy a hacer es adaptar el código del ejemplo y voy a añadir los parámetros necesarios para el IFTTT. Estos parámetros son los siguientes:
- El host del servicio IFTTT es maker.ifttt.com.
- El nombre del evento que hayas puesto en la configuración.
- La clave secreta del IFTTT la puedes obtener de la pantalla Maker settings que hemos visto antes.
De momento nos vamos a quedar con la parte de conexión con la WiFi, lo que está dentro de la función setup(). Eliminaremos todo el código que permite conectarse al servidor ya que eso lo haremos más adelante.
El código quedaría de la siguiente manera.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 |
#include <SPI.h> #include <WiFi101.h> // Definimos los parámetros para el IFTTT #define HOSTIFTTT "maker.ifttt.com" #define EVENTO "nombre_tu_evento" #define IFTTTKEY "tu_clave_ifttt" // Parámetros conexión WiFi char ssid[] = "yourNetwork"; // your network SSID (name) char pass[] = "secretPassword"; // your network password (use for WPA, or use as key for WEP) int status = WL_IDLE_STATUS; WiFiClient client; void setup() { //Initialize serial and wait for port to open: Serial.begin(9600); while (!Serial) { ; // wait for serial port to connect. Needed for native USB port only } // check for the presence of the shield: if (WiFi.status() == WL_NO_SHIELD) { Serial.println("WiFi shield not present"); // don't continue: while (true); } // attempt to connect to WiFi network: while (status != WL_CONNECTED) { Serial.print("Attempting to connect to SSID: "); Serial.println(ssid); // Connect to WPA/WPA2 network. Change this line if using open or WEP network: status = WiFi.begin(ssid, pass); // wait 10 seconds for connection: delay(10000); } Serial.println("Connected to wifi"); } void loop() { } |
Puedes probar el programa anterior sustituyendo el SSID y el PASS por los de tu conexión WiFi.
#3 Función que construye la petición HTTP
En esta fase vamos a crear una nueva función a la que llamaremos para que nos envíe un Tweet. El desencadenante de esta llamada puede ser cualquier cosa, un botón, por tiempo o cuando la temperatura suba más de X grados.
Esto te lo dejo a ti, investiga cómo puedes conectar el mundo físico con el mundo virtual gracias a la computación física.
Solo hay que tener en cuenta que la petición HTTP se debe hacer mediante el protocolo seguro SSL. Para ello llamamos al método conectSSL, es la única diferencia que podemos encontrar con respecto a una llamada estándar.
Si no utilizas este protocolo seguro no te va a funcionar. La función que voy a incorporar al código sería la siguiente.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 |
void enviar_tweet(int valor1, int valor2, int valor3) { // Cerramos cualquier conexión anterior if (client.connected()) { client.stop(); } // Esperamos hasta que se hayan enviado todos los datos client.flush(); // Hacemos la petición mediante SSL if (client.connectSSL(HOSTIFTTT, 443)) { // Construimos la petición HTTP String toSend = "GET /trigger/"; toSend += EVENTO; toSend += "/with/key/"; toSend += IFTTTKEY; toSend += "?value1="; toSend += valor1; toSend += "&value2="; toSend += valor2; toSend += "&value3="; toSend += valor3; toSend += " HTTP/1.1\r\n"; toSend += "Host: "; toSend += HOSTIFTTT; toSend += "\r\n"; toSend += "Connection: close\r\n\r\n"; client.print(toSend); } // Esperamos hasta que se hayan enviado todos los datos client.flush(); // Desconectamos del cliente client.stop(); } |
#4 Lanzar la petición HTTP a IFTTT desde la función loop()
Por último voy a añadir la lógica que me permita lanzar la petición HTTP. En mi caso solo lo voy hacer una vez, cuando se inicie el Arduino. Enviará un Tweet con la temperatura, la humedad y el valor del pin Analógico 0.
No voy a conectar ningún sensor a la placa. Voy a simular la temperatura y humedad con la función random que genera números aleatorios. El código final sería el siguiente.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 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 101 102 103 104 |
#include <SPI.h> #include <WiFi101.h> // Definimos los parámetros para el IFTTT #define HOSTIFTTT "maker.ifttt.com" #define EVENTO "nombre_tu_evento" #define IFTTTKEY "tu_clave_ifttt" // Parámetros conexión WiFi char ssid[] = "yourNetwork"; // your network SSID (name) char pass[] = "secretPassword"; // your network password (use for WPA, or use as key for WEP) int status = WL_IDLE_STATUS; WiFiClient client; // Variable que permite ejecutar una sola vez la función bool ejecutado = false; void setup() { //Initialize serial and wait for port to open: Serial.begin(9600); while (!Serial) { ; // wait for serial port to connect. Needed for native USB port only } // check for the presence of the shield: if (WiFi.status() == WL_NO_SHIELD) { Serial.println("WiFi shield not present"); // don't continue: while (true); } // attempt to connect to WiFi network: while (status != WL_CONNECTED) { Serial.print("Attempting to connect to SSID: "); Serial.println(ssid); // Connect to WPA/WPA2 network. Change this line if using open or WEP network: status = WiFi.begin(ssid, pass); // wait 10 seconds for connection: delay(10000); } Serial.println("Connected to wifi"); //Establecemos la semilla en un pin analogico randomSeed(analogRead(A0)); } void loop() { if (!ejecutado) { // Obtenemos los valores int valor1 = (int)random(12, 40); int valor2 = (int)random(50, 99); int valor3 = analogRead(A0); Serial.println(valor1); Serial.println(valor2); Serial.println(valor3); enviar_tweet(valor1, valor2, valor3); ejecutado = true; } } void enviar_tweet(int valor1, int valor2, int valor3) { // Cerramos cualquier conexión anterior if (client.connected()) { client.stop(); } // Esperamos hasta que se hayan enviado todos los datos client.flush(); // Hacemos la petición mediante SSL if (client.connectSSL(HOSTIFTTT, 443)) { // Construimos la petición HTTP String toSend = "GET /trigger/"; toSend += EVENTO; toSend += "/with/key/"; toSend += IFTTTKEY; toSend += "?value1="; toSend += valor1; toSend += "&value2="; toSend += valor2; toSend += "&value3="; toSend += valor3; toSend += " HTTP/1.1\r\n"; toSend += "Host: "; toSend += HOSTIFTTT; toSend += "\r\n"; toSend += "Connection: close\r\n\r\n"; client.print(toSend); } // Esperamos hasta que se hayan enviado todos los datos client.flush(); // Desconectamos del cliente client.stop(); } |
Configurar NodeMCU para utilizar IFTTT
Al igual que con Arduino MKR1000, con NodeMCU también podemos enviar un Tweet. Básicamente vamos a hacer lo mismo que hemos hecho antes, la diferencia es que utilizaremos las librerías propias del ESP8266.
Si todavía no has configurado el IDE de Arduino para programar este microcontrolador, puedes ver el tutorial, podcast y vídeo de la guía para configurar el ESP-01.
#1 Conectando a la red WiFi desde NodeMCU
Quizás esta sea la parte que más diferencia tiene con respecto al Arduino MKR1000. Esto es debido a que utiliza otras librerías, pero más o menos los pasos son los mismos. También he incluido los parámetros IFTTT que nos harán falta.
A continuación te dejo el código para conectarse a la red WiFi desde NodeMCU.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 |
#include <ESP8266WiFi.h> #include <ESP8266WiFiMulti.h> // Definimos parámetros #define WIFISID "nombre_wifi" #define WIFIPASS "clave_wifi" // Definimos los parámetros para el IFTTT #define HOSTIFTTT "maker.ifttt.com" #define EVENTO "nombre_tu_evento" #define IFTTTKEY "tu_clave_ifttt" ESP8266WiFiMulti WiFiMulti; // Utilizamos la conexión SSL del ESP8266 WiFiClientSecure client; // Variable que permite ejecutar una sola vez la función bool ejecutado = false; void setup() { Serial.begin(115200); delay(10); // Conectamos a la red WiFi WiFiMulti.addAP(WIFISID, WIFIPASS); Serial.println(); Serial.println(); Serial.print("Eperando a conectar a la WiFi... "); while (WiFiMulti.run() != WL_CONNECTED) { Serial.print("."); delay(500); } Serial.println(""); Serial.println("WiFi conectada"); Serial.println("Direccion IP: "); Serial.println(WiFi.localIP()); delay(500); //Establecemos la semilla en un pin analogico randomSeed(analogRead(A0)); } void loop() { } |
Sustituye el nombre de tu WiFi y la contraseña. Para cargar el programa estoy utilizando una velocidad de 115200. Como verás en el código, utilizo la clase WifiClientSecure para enviar peticiones por SSL.
La gran diferencia entre Arduino MKR1000 y NodeMCU con respecto al SSL es que en el primero viene implementado a nivel de hardware y en el segundo a nivel de software. A la hora de programar no hay grandes diferencias aunque siempre es más seguro la primera opción.
#2 Enviar petición HTTP a IFTTT desde NodeMCU
En este punto nos sirve todo lo que hemos hecho anteriormente. La función que envía el tweet es idéntica salvo el método que conecta con el servidor. Con Arduino MKR1000 utilizábamos conectSSL(…) y con NodeMCU utilizamos connect(…).
El resto del código es el mismo. Te dejo todo el programa a continuación.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 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 101 102 103 |
#include <ESP8266WiFi.h> #include <ESP8266WiFiMulti.h> // Definimos parámetros #define WIFISID "nombre_wifi" #define WIFIPASS "clave_wifi" // Definimos los parámetros para el IFTTT #define HOSTIFTTT "maker.ifttt.com" #define EVENTO "nombre_tu_evento" #define IFTTTKEY "tu_clave_ifttt" ESP8266WiFiMulti WiFiMulti; // Utilizamos la conexión SSL del ESP8266 WiFiClientSecure client; // Variable que permite ejecutar una sola vez la función bool ejecutado = false; void setup() { Serial.begin(115200); delay(10); // Conectamos a la red WiFi WiFiMulti.addAP(WIFISID, WIFIPASS); Serial.println(); Serial.println(); Serial.print("Eperando a conectar a la WiFi... "); while (WiFiMulti.run() != WL_CONNECTED) { Serial.print("."); delay(500); } Serial.println(""); Serial.println("WiFi conectada"); Serial.println("Direccion IP: "); Serial.println(WiFi.localIP()); delay(500); //Establecemos la semilla en un pin analogico randomSeed(analogRead(A0)); } void loop() { if (!ejecutado) { // Obtenemos los valores int valor1 = (int)random(12, 40); int valor2 = (int)random(50, 99); int valor3 = analogRead(A0); Serial.println(valor1); Serial.println(valor2); Serial.println(valor3); enviar_tweet(valor1, valor2, valor3); ejecutado = true; } } void enviar_tweet(int valor1, int valor2, int valor3) { // Cerramos cualquier conexión anterior if (client.connected()) { client.stop(); } // Esperamos hasta que se hayan enviado todos los datos client.flush(); // Hacemos la petición mediante SSL if (client.connect(HOSTIFTTT, 443)) { // Construimos la petición HTTP String toSend = "GET /trigger/"; toSend += EVENTO; toSend += "/with/key/"; toSend += IFTTTKEY; toSend += "?value1="; toSend += valor1; toSend += "&value2="; toSend += valor2; toSend += "&value3="; toSend += valor3; toSend += " HTTP/1.1\r\n"; toSend += "Host: "; toSend += HOSTIFTTT; toSend += "\r\n"; toSend += "Connection: close\r\n\r\n"; client.print(toSend); } // Esperamos hasta que se hayan enviado todos los datos client.flush(); // Desconectamos del cliente client.stop(); } |
Conclusiones de cómo configurar IFTTT con Arduino y NodeMCU
Como has podido comprobar a lo largo de este artículo, no resulta difícil configurar IFTTT con Arduino y NodeMCU. La dificultad existe en la información tan dispersa que hay en Internet. Este tutorial pretende ser una guía para utilizar este servicio en nuestros proyectos Makers.
No te quedes solo en enviar un Tweet, te aconsejo que investigues todo lo que se puede hacer con el IFTTT, te dejará sorprendido. La sensación que tenemos los que nos dedicamos a esto es que IFTTT es un gran desconocido dentro del movimiento Maker.
Por eso he decidido escribir este artículo, para dar a conocer las grandes virtudes del servicio IFTTT a los Makers.
¿Conoces algún servicio IFTTT para Arduino o ESP8266 que sea interesante?
¿Crees que ha quedado claro la utilización de IFTTT con Arduino y NodeMCU?
Agradecería me dejaras algún comentario aquí debajo y si te ha gustado puedes compartirlo con los demás. Muchas gracias.
Gracias a Shutterstock por ceder los derechos de la imagen
