Futurista ambientador


Es  reconfortante tener una fragante casa floral de primavera para senirse como si estuviera en medio de un jardín de lavanda en lugar de una vivienda tradicional  donde probablemente viva, de heho eso es es que precisamente por esto, muchas de las diferentes empresas han creado para los amantes del aire  una multitud de aromas.

Hay muchos ambientadores en el mercado: desde los antiguos aerosoles manuales hasta los disparados por temporizador pero los últimos, aunque son automáticas, son bastante tontas pues seguirán rociando incluso si no estás cerca para  sentir el olor, desperdiciando esas recargas de fragancia no tan baratas.

¿No sería agradable si su refrescante de aire fuera capaz de comunicarse con otros dispositivos y disparar solo cuando realmente lo necesite ?

En este proyecto IgorF2 diseñó   un ambientador  conectado , usando algunas impresiones 3D, NodeMCU, IFTTT y Adafruit.IO.

!

¡Siempre tenga en cuenta que este es un prototipo experimental y podría usarse con precaución!

Paso 1: herramientas y materiales

Las siguientes herramientas y materiales fueron utilizados en este proyecto:

  • impresora 3d. En mi caso, utilicé Voolt3D, una impresora 3D basada en Grabber i3;
  • 1.75mm PLA de su color favorito;
  • Alambre de soldar. Tendrás que soldar algunos cables;
  • Destornillador. Lo necesitará para montar su caso;
  • Tornillos M2x6mm (x11) ;
  • Servomotor MG995
  • NodeMCU LoLin (- La versión NodeMCU LoLin tiene un pin UV, que está conectado al terminal USB 5V. De esta forma, es posible usar los 5 V de un cargador USB, pasando por la placa NodeMCU, para alimentar el servomotor. Otras versiones de NodeMCU no tienen este pin UV (tienen un pin reservado en su lugar). De esta forma, no podrá alimentar su servomotor directamente si usa una de esas otras versiones;
  • NeoPixel 16 x WS2812 5050 RGB LED
  • Botón pulsador de 12x12x12 mm
  • Cable MiniUSB , para la conexión entre NodeMCU y la computadora (para cargar el código);
  • Cargador USB 5V, 2A ( cargador de teléfono, por ejemplo) para alimentar el circuito;
  • 5 cables de puente hembra-hembra;
  • 3 cables de puente macho-hembra;
  • Recambio de aire fresco.

 

Paso 2: impresión en 3D

Imagen de impresión 3D

El modelo 3d se diseñó utilizando Fusion 360.

El modelo se compone de cinco partes diferentes:

  • Frente: cuerpo principal del gadget. Aquí es donde algunos de los componentes electrónicos (anillo LED y botón pulsador) y el servomotor se unirán;
  • Funda trasera: se usa para cerrar el cuerpo de la caja. Aquí es donde se instalarán NodeMCU y el recambio de renovación;
  • Botón : esta parte está conectada al botón;
  • Tapa: esta parte se enrosca en la parte posterior de la caja y permite reemplazar la recarga
  • Soporte: esta parte se utiliza para bloquear el anillo LED y el botón en su posición.

Puede descargar todos los archivos stl en https://www.thingiverse.com/thing:2613327

Este es un prototipo experimental. Tenga en cuenta que fue diseñado para un modelo determinado de recarga de renovación de aire (una Glade, cuyas dimensiones en milímetros puede encontrar en las imágenes). Si desea utilizar un modelo diferente, envíe un comentario y puedo ver si es posible cambiar las dimensiones del modelo para adaptarlo a sus necesidades.

Si no tiene una impresora 3D, aquí hay algunas cosas que puede hacer:

  • Pídale a un amigo que lo imprima para usted;
  • Encuentre un espacio para hackers / fabricantes cerca. Las piezas utilizadas en este modelo se pueden imprimir rápidamente (alrededor de 9 horas).Algunos espacios de hackers / fabricantes solo le cobrarán por los materiales utilizados;
  • ¡Improvisar! Puede intentar ensamblar una estructura sin partes impresas en 3D;

Paso 3: Explicación del circuito

Imagen del circuito explicado

Para este proyecto se utiliza  el modulo  NodeMCU LoLin para controlar el gadget. NodeMCU es una plataforma de código abierto IoT, que se ejecuta en un SoC Wi-Fi ESP8266 de Espressif Systems. Su hardware se basa en el módulo ESP-12.

La placa de desarrollo conecta una red Wi-Fi determinada y recibe algunos comandos de Adafruit.io plafrom. Un anillo NeoPixel se utiliza para la indicación del estado (si la conexión Wi-Fi fue exitosa, o si se recibió un comando dado, por ejemplo). El tablero de control también acciona un servomotor, que actuará en una recarga de renovación de aire. Un botón pulsador se usa para comandos locales.

Se utilizó un cargador USB de 5 V y 2 A para alimentar la placa de control y todos los periféricos. Es importante observar que cuando se activa el servo, se toma una corriente máxima considerable de la fuente de alimentación. De esta forma, no use el puerto USB de una computadora (o cualquier otro dispositivo) para alimentar su circuito. Podría reiniciarse o incluso dañarse.

Las figuras ilustran cómo se conectaron los componentes.

Paso 4: Prepare la electrónica

Imagen de Prepare the Electronics

Algunos de los componentes utilizados en este proyecto deben soldarse primero. En este paso, mostraré cómo se prepararon para una conexión más fácil de los componentes.

1. Terminales Solder NeoPixel

Los anillos NeoPixel generalmente vienen sin cables conectados a sus terminales. Esto significa que tuve que soldar algunos cables para la conexión de los LED al microcontrolador.

Para eso use tres puentes femeninos y femeninos. Corte un lado del puente y suelde sus cables en los terminales de anillo NeoPixel. El otro extremo de cada jumper estará con un terminal hembra, que se conectará más adelante en los pines NodeMCU.

  • Cable rojo = 5V
  • Cable negro = GND
  • Cable amarillo = entrada de datos

2. Terminales de botón de soldadura

Para conectar el botón pulsador al NodeMCU, primero tuve que soldar algunos cables de puente en dos terminales del botón.

Use dos jumpers femeninos y femeninos. Cortar un lado del jumper y suelde sus hilos al botón.

  • Cable verde = entrada de datos
  • Cable negro = GND

3. Servomotor MG995

Los servomotores generalmente tienen un terminal hembra de tres pines, pero desafortunadamente no se puede conectarse directamente al NodeMCU debido a la posición de los pines. Para conectar esos componentes usé un cable de puente macho-hembra.

Paso 5: Ensamblar los componentes

Imagen de Montar los Componentes

En este paso, veremos cómo ensamblar los componentes dentro de la estructura impresa en 3D. Si no desea imprimir el caso por algún motivo, puede saltar al siguiente paso y ver cómo está conectado el circuito.
Una vez que se imprime su estructura, ensamblar el circuito es bastante simple:

  1. Coloque el anillo de LED dentro de la caja frontal ;
  2. Coloque el botón impreso en 3D dentro del anillo;
  3. Coloque el botón pulsador en el medio del soporte impreso en 3D;
  4. Monte el soporte dentro de la caja frontal con cuatro pernos M2x6mm;
  5. Monte el servomotor dentro de la carcasa delantera con cuatro tornillos (los que generalmente vienen con el servo);
  6. Coloque la bocina del servo de acuerdo con la imagen y bloquee su posición con un perno. Cuando el servo está a 90 grados, la retención debe ser horizontal;
  7. Fije NodeMCU dentro de la caja trasera usando cuatro pernos M2x6mm;
  8. Inserte el relleno de renovación de aire dentro de la cámara;
  9. Thead la tapa, cerrando la cámara;
  10. Conecte el circuito (en el siguiente paso le mostraré cómo hacerlo);
  11. Cierre la caja con tres tornillos M2x6mm.

Después de eso, estará listo para subir el código.

Paso 6: Cableado del circuito

Imagen de Wire Up the Circuit

Una vez que los componentes se colocaron dentro de la caja, conecte los cables de acuerdo con los esquemas.

  • NeoPixel 5V (cable rojo) => NodeMcu 3V3
  • NeoPixel GND (cable negro) => NodeMcu GND
  • Entrada de datos NeoPixel (cable amarillo) => NodeMcu GPIO 15 (pin D8)
  • Botón pulsador 1 (cable verde) => NodeMcu GPIO 14 (pin D5)
  • Pulsador 2 (cable negro) => NodeMcu GND
  • MG995 servo 5V (cable rojo) => NodeMcu VU pin
  • MG995 servo GNG (cable marrón) => NodeMcu GND
  • Servo señal MG995 (cable naranja) => NodeMcu GPIO 12 (pin D6)

Paso 7: Configurar NodeMCU en Arduino IDE

Imagen de Setup NodeMCU en Arduino IDE

Para este proyecto se utiliza  Arduino IDE para programar  el NodeMcu. Es la forma más fácil si ya has usado un Arduino antes, y no necesitarás aprender un nuevo lenguaje de programación, como Python o Lua, por ejemplo.

Si nunca has hecho esto antes, primero tendrá que agregar el soporte de la placa ESP8266 al software Arduino.

1. Descargue e instale la última versión de Arduino IDE

Puede encontrar la última versión para Windows, Linux o MAC OSX en el sitio web de Arduino: https://www.arduino.cc/en/main/software

Descárguelo gratis, instálelo en su computadora y ejecútelo.

2. Agregar el tablero ESP8266

Arduino IDE ya viene con soporte para muchas placas diferentes: Arduino Nano, Mine, Uno, Mega, Yún, etc. Desafortunadamente ESP8266 no está por defecto entre esas placas de desarrollo soportadas. Por lo tanto, para subir sus códigos a una placa base ESP8266, primero deberá agregar sus propiedades al software de Arduino.

  • Navegue a Archivo> Preferencias (Ctrl +, en el sistema operativo Windows);
  • Agregue la siguiente URL al cuadro de texto Gestor de tableros adicionales (el que está en la parte inferior de la ventana de Preferencias):

http://arduino.esp8266.com/stable/package_esp8266com_index.json

  • Si el cuadro de texto no estaba en blanco, significa que ya había agregado otras placas antes en Arduino IDE. Agregue una coma al final de la URL anterior y la anterior.
  • Presiona el botón “Aceptar” y cierra la ventana de Preferencias.
  • Navegue hacia Herramientas> Tablero> Administrador de tableros para agregar su placa ESP8266.
  • Escriba “ESP8266” en el cuadro de texto de búsqueda, seleccione “esp8266 por ESP8266 Community” e instálelo.

Ahora su IDE de Arduino estará listo para trabajar con muchas placas de desarrollo basadas en ESP8266, como el ESP8266 genérico, NodeMcu (que utilicé en este tutorial), Adafruit Huzzah, Sparkfun Thing, WeMos, etc.

3. Agregar las bibliotecas

Las siguientes bibliotecas se usarán para nuestro código Arduino. Descargue las siguientes bibliotecas:

Navegue a Boceto-> Incluir biblioteca-> Administrar bibliotecas … en tu IDE de Arduino y agrega las bibliotecas de arriba.¡Ahora que su entorno de desarrollo está listo, pasemos al siguiente paso!

Paso 8: Configuración de Adafruit.IO

Imagen de la configuración de Adafruit.IO

Hay muchos servicios de registro de datos disponibles para comunicar un microcontrolador a la web. Con esos servicios, puede cargar / descargar datos desde / hacia la nube y hacer muchas cosas interesantes.
Adafruit.IO es uno de esos servicios gratuitos. ¡Es realmente fácil de usar y promete traer Internet de las cosas a todos!

Crear Adafruit IO Web Feed

  • Regístrese en https://io.adafruit.com/
  • En Feeds> Crear un nuevo feed, agregue un nuevo feed denominado “IoT air freshner command”. Creará una base de datos, y la usaremos para almacenar los comandos recibidos por el gadget.

En el siguiente paso, veremos cómo configurar IFTTT, otra plataforma utilizada  en este proyecto. La idea aquí es simple: IFTTT tendrá configurados algunos desencadenantes y enviará algunos datos a la plataforma Adafruit.IO cuando una lógica dada sea verdadera. El gadget podrá leer los datos almacenados en un feed determinado en Adafruit.IO, ejecutar un poco de lógica y realizar algunas acciones.

También es un buen momento para copiar su clave Adafruit.IO, que luego será utilizada para permitir que su dispositivo acceda a la base de datos. Navega por Configuración> Ver clave AIO y copia el código de tecla activa. Lo necesitará para su código Arduino (NodeMCU) en los próximos pasos.

Paso 9: Configuración IFTTT

Imagen de la configuración IFTTT

IFTTT es una plataforma gratuita que ayuda a conectar aplicaciones y dispositivos. Puede usarlo para conectar su teléfono inteligente con otros dispositivos, o para compartir datos entre sus servicios web favoritos (como Google, Facebook, Twitter, Instragram, etc.) y otros dispositivos físicos, por ejemplo. ¡Y la mejor parte es que es realmente fácil de usar!

IFTTT usa una lógica “si esto, luego eso”, donde “esto” representa un servicio que activará una acción determinada dada por “eso”. De esta forma, creará pequeños applets que conectan los servicios y dispositivos web. Para el proyecto descrito en este tutorial, hay varias manzanas que se te ocurren. Por ejemplo, los siguientes ejemplos podrían usarse para activar su dispositivo (“esto”):

  • se hace clic en un botón virtual en un teléfono;
  • todos los días en un momento dado;
  • un teléfono inteligente (GPS) llega a una ubicación determinada;
  • se recibe una notificación por correo electrónico.

En nuestros ejemplos, “ese” valor siempre será un enlace a Adafruit.IO, donde los comandos (resultado de un desencadenante dado) se almacenarán, y más tarde serán leídos por el NodeMCU.

Primero tendrá que iniciar sesión en:https://ifttt.com/

Luego instale la aplicación IFTTT en su teléfono inteligente. Puedes encontrarlo en Google Play Store:https://play.google.com/store/apps/details?id=com.ifttt.ifttt

En el sitio web, vaya a Nuevo applet (haga clic en el botón de flecha al lado de su inicio de sesión para acceder al menú).

Paso 10: Applet # 1 – The Lazy Boy

Imagen de Applet # 1 - The Lazy Boy

Para este applet crearemos un botón virtual que activará su gadget IoT. ¡En nuestro caso, significa que no tendrá que levantarse y encender su refrescante de aire! Haga clic en un botón, aguarde y respire profundamente.

Crear el applet en el sitio web:

  • Haga clic en + Esto;
  • Escriba “botón” en el cuadro de texto del servicio Seach y seleccione Botón widget> Presione botón . Tal como se describe en el sitio web de IFTTT, creará un activador que se activará cada vez que presione el botón;
  • Ahora elija + Eso ;
  • Escriba “adafruit” y seleccione Adafruit> Enviar datos a Adafruit IO . Esto enviará datos a un canal de información en su cuenta IO de Adafruit siempre que el activador que configuró previamente ( + Esto ) esté activado;
  • Configure el nombre del feed como “IoT air freshner command” y Data para guardar como “botón”.
  • Termina tu applet y enciéndelo.

Crea un botón virtual en dispositivos Android:

  • Mantenga presionado el fondo. Y elige Widgets ;
  • Búsqueda de IFTTT Small 1 x 1;
  • Ahora elija Enviar datos a IoT air freshner command feed;
  • Se creará un botón con el ícono de Adafruit.

Pruebas:

  • Haga clic en el botón que acaba de crear;
  • En https://io.adafruit.com/, vaya a su feed de comandos de renovación de aire IoT y verifique si se recibió el comando. Mostrará la última vez que se recibió la acción si funciona correctamente.

En pasos adicionales, le mostraré cómo crear el código para su ESP8266 para realizar una acción cuando se recibe el comando.

Paso 11: Applet # 2 – IIIIIIII es Tiiiiiime!

Imagen de Applet # 2 - IIIIIIIIt es Tiiiiiime!

Para este applet, crearemos un disparador de temporizador para su gadget de IoT, que se activará en determinados momentos. Reloj de alarma perfumado listo para despertarte!

Crea el applet en el sitio web:

  • Haga clic en + Esto ;
  • Escriba “Fecha” en el cuadro de texto del servicio Seach y seleccione el widget Fecha y hora> Todos los días a las . Tal como se describe en el sitio web de IFTTT, creará un disparador que se dispara todos los días en un momento determinado;
  • Haga clic en + Eso ;
  • Escriba “adafruit” y seleccione Adafruit> Enviar datos a Adafruit IO. Esto enviará datos a un feed en su cuenta IO de Adafruit siempre que el activador que configuró previamente (+ Esto) esté activado;
  • Configure el nombre del feed como “IoT air freshner command” y Data para guardar como “time”;
  • Termina tu applet y enciéndelo.

Pruebas:

  • Para probar si está funcionando, configure el tiempo de activación por un minuto después de su hora actual. Y espéralo;
  • En https://io.adafruit.com/ , vaya a su feed de comandos de renovación de aire IoT y verifique si se recibió el comando. Mostrará la última vez que se recibió la acción si funciona correctamente.

Paso 12: Applet # 3 – ¡Hogar, dulce hogar!

Imagen de Applet # 3 - Home, Sweet Home!

Para este applet, crearemos un activador de ubicación para su gadget IoT, que se activará cada vez que ingrese a un área específica (su hogar, por ejemplo).Utilizará el servicio de Localización de su teléfono (posición de GPS) para determinar si se acerca a una ubicación específica.

Crear el applet en el sitio web:

  • Haga clic en + Esto ;
  • Escriba “ubicación” en el cuadro de texto del servicio Seach y seleccione widget de ubicación> Ingrese un área . Tal como se describe en el sitio web de IFTTT, creará un activador que se activará cada vez que ingrese a una ubicación específica;
  • Especifique la dirección de su ubicación;
  • Haga clic en + Eso ;
  • Escriba “adafruit” y seleccione Adafruit> Enviar datos a Adafruit IO . Esto enviará datos a un feed en su cuenta IO de Adafruit siempre que el activador que configuró previamente (+ Esto) esté activado;
  • Configure el nombre del feed como “comando IoT air freshner” y datos para guardar como “ubicación”;
  • Termina tu applet y enciéndelo.

Pruebas:

Para probar si funciona, ¡tendrá que caminar un poco! Tienes que salir de la ubicación que especificaste y volver allí. :RE

Paso 13: Applet # 4 – ¡Tiene correo!

Imagen de Applet # 4 - ¡Tienes correo!

Para este applet, crearemos un activador de notificación para su gadget IoT, que se activará cada vez que se reciba un correo electrónico en su cuenta de gmail. Si un tono de llamada y una notificación de vibración no fueran suficientes, ¡ahora puede agregar una notificación de olor para los mensajes entrantes!

Crea el applet en el sitio web:

  • Haga clic en + Esto ;
  • Escriba “gmail” en el cuadro de texto del servicio Seach y seleccione widget de Gmail> Cualquier correo electrónico nuevo en la bandeja de entrada . Tal como se describe en el sitio web de IFTTT, creará un activador que se activará cada vez que llegue un nuevo mensaje a Gmail.
  • Haga clic en + Eso ;
  • Escriba “adafruit” y seleccione Adafruit> Enviar datos a Adafruit IO . Esto enviará datos a un feed en su cuenta IO de Adafruit siempre que el activador que configuró previamente (+ Esto) esté activado;
  • Configure el nombre del feed como “comando IoT air freshner” y datos para guardar como “correo”;
  • Termine su applet y enciéndelo.

Pruebas

  • Para probar si funciona, envíelo y envíe un correo electrónico;
  • En https://io.adafruit.com/ , vaya a su feed de comando de renovación de aire IoT y verifique si se recibió el comando. Mostrará la última vez que se recibió la acción si funciona correctamente.

Paso 14: Código ESP8266

Imagen del código ESP8266

Ahora que sus activadores están configurados, trabajemos en su código ESP8266.

Básicamente, su gadget se conectará a una red wi-fi y esperará hasta que se reciba un nuevo comando en Arduino.IO. Cada vez que se recibe un mensaje, el renovador de aire IoT realizará sus acciones (mover un servo motor para liberar un poco de perfume, cambiar los colores del LED) y regresar para el estado inactivo. El circuito también usará un botón como entrada.

Para cargar su código, seleccione NodeMCU 0.9 (Módulo ESP-12) (si está utilizando un NodeMCU) con una velocidad de carga de 11520 kbps.Desconecte el servomotor del NodeMCU, conecte NodeMCU al puerto USB de su computadora y cargue el código.

Llevará un tiempo (mucho más que completar y cargar un boceto para un Arduino … tenga paciencia …). ¡Ahora es un buen momento para que le des un mecano de instrucciones mientras esperas! :RE

Después de completar la carga, desenchufe el cable USB, conecte el servomotor y alimente su circuito desde un cargador USB.

Código explicado:

Para la configuración de IO de Adafruit, deberá reemplazar el nombre de usuario ( XXXXXXXXXX ) y la tecla io ( YYYYYYYYY ).

Visite adafruit.io, inicie sesión en su cuenta y copie la clave io (tal como se describió en los pasos anteriores).

/************************ Adafruit IO Configuration *******************************/
// visit io.adafruit.com if you need to create an account, or if you need your Adafruit IO key.
#define IO_USERNAME “XXXXXXXXXX”
#define IO_KEY “YYYYYYYYY”

También deberá especificar el SSID y la contraseña de su enrutador Wi-Fi.Reemplace WWWWWWWWWW y ZZZZZZZZZZ para configurar su conexión Wi-Fi.

/******************************* Configuración de WIFI ***************** ********************* /
#define WIFI_SSID “WWWWWWWWWW”
#define WIFI_PASS “ZZZZZZZZZZ”
#include “AdafruitIO_WiFi.h”
AdafruitIO_WiFi io (IO_USERNAME, IO_KEY, WIFI_SSID, WIFI_PASS);

 

Se usarán las siguientes bibliotecas (como se describe en los pasos anteriores).Deberá agregarlos en el ide de Arduino antes de compilar el código.

/ ************************ El programa principal comienza aquí ********************* ********* /

#include <ESP6266WiFi.h>
#include <AdafruitIO.h>
#include <AdafruitMQTT.h>
#include <ArduinoHttpClient.h>
#include “Servo.h”

 
Varias cosas (pines y parámetros de LED) se definen antes de la configuración:
#define SERV1 12 // Pin conectado al Servomotor
Servo s1;
#define BUTTON_PIN 14 // Pin conectado al pulsador
#define PIXELS_PIN 15 // Pin conectado a la entrada de datos NeoPixel
#define NUM_LEDS 16 // Número de NeoPixels
#define BRILLO 30
#define PIXEL_TYPE NEO_GRB + NEO_KHZ800 // Tipo de NeoPixels (vea el ejemplo de strandtest).
Anillo Adafruit_NeoPixel = Adafruit_NeoPixel (NUM_LEDS, PIXELS_PIN, PIXEL_TYPE); // + NEO_KHZ800);
AdafruitIO_Feed * command = io.feed (“iot-air-freshner-command”); // configura el feed ‘comando’
Durante la configuración, el NodeMCU inicializará los LED (apague y encienda), inicie el puerto de comunicación en serie y conéctese a Adafruit.io. Se mostrará una animación mientras intenta conectarse.

Las entradas (pulsador) y las salidas (servomotor) también se configuran durante la configuración.

void setup () {
ring.setBrightness (BRILLO);
ring.begin ();
ring.show (); // Inicializa todos los píxeles a ‘off’
// inicia la conexión en serie </ p> Serial.begin (115200);
// conectarse a io.adafruit.com
Serial.print (“Conectando a Adafruit IO”);
io.connect ();

// configuramos un manejador de mensajes para el feed ‘comando’.
// la función handleMessage (definida a continuación)
// se llamará cada vez que se envíe un mensaje
// recibido de adafruit io.
command-> onMessage (handleMessage);
// espera una conexión
int i = NUM_LEDS – 1;
int color = 255;
// anima los LED mientras espera la conexión
while (io.status () <AIO_CONNECTED) {
Serial.print (“.”);
ring.setPixelColor (i, 0, 0, color);
ring.show ();
i = i – 1;
if (i <0)

{ if (color == 255) {

color = 0; }

else

{ color = 255;

}

i = NUM_LEDS – 1;

} delay (50); }

lightPixels (ring.Color (0, 0, 0, 0)); // restablecer todos los píxeles a apagado cuando está conectado

// Estamos conectados

Serial.println ();

Serial.println (io.statusText ());

// mover el servomotor a la posición neutral s1.attach (SERV1);

s1.write (90); retraso (500);

s1.detach (); // establecer el pin del botón como entrada pinMode (BUTTON_PIN, INPUT_PULLUP);

}

El ciclo principal es bastante corto. Verifica si hay datos entrantes de Adafruit.io, y verifica si se presionó el botón. Si uno presiona el botón, envía datos a Adafruit.io.

 

void loop ()

{ // io.run (); es requerido para todos los bocetos.

// siempre debe estar presente en la parte superior de tu ciclo // función. mantiene al cliente conectado a

// io.adafruit.com, y procesa cualquier información entrante.

io.run ();

if(digitalRead(BUTTON_PIN) == LOW) {
command->save(“button”);
}

}

 

Cada vez que se recibe un mensaje, se llama a la función handleMessage .Esta función lee los últimos datos recibidos en una fuente dada en Adafruit.io, y verifica si se recibió una de las cadenas de comandos conocidas (‘botón’, ‘temporizador’, ‘ubicación’ o ‘correo’).

Según el comando recibido, los LED parpadearán con diferentes colores y el servomotor se activará.
// esta función se invoca cada vez que se recibe un mensaje
// de Adafruit IO. estaba adjunto a
// la alimentación en la función setup () arriba.

void handleMessage (AdafruitIO_Data * data) {

lightPixels (ring.Color (0, 0, 0, 0)); // restablecer todos los píxeles a apagado cuando se recibe nueva información
String commandStr = data-> toString (); // almacena los comandos entrantes en una cadena

Serial.print (“recibido <-“);
Serial.println (commandStr);

// Estas declaraciones if comparan la variable meteorológica entrante con las condiciones almacenadas, y controlan las NeoPixels en consecuencia.

// si se presionó el botón virtual
if (commandStr.equalsIgnoreCase (“button”)) {
Serial.println (“Botón virtual”);
rotatingPixels (ring.Color (255, 255, 0, 0)); // mostrar animación
lightPixels (ring.Color (255, 255, 0, 0)); // mostrar animación
launch (1);
lightPixels (ring.Color (0, 0, 0, 0)); // restablecer todos los píxeles a apagado cuando se recibe nueva información
}

// si es hora
if (commandStr.equalsIgnoreCase (“timer”)) {
Serial.println (“es hora”);
rotatingPixels (ring.Color (0, 0, 255, 0)); // mostrar animación
lightPixels (ring.Color (0, 0, 255, 0)); // mostrar animación
launch (2);
lightPixels (ring.Color (0, 0, 0, 0)); // restablecer todos los píxeles a apagado cuando se recibe nueva información
}

// si se alcanzó la ubicación
if (commandStr.equalsIgnoreCase (“ubicación”)) {
Serial.println (“Bienvenido a casa!”);
rotatingPixels (ring.Color (0, 255, 0, 0)); // mostrar animación
lightPixels (ring.Color (0, 255, 0, 0)); // mostrar animación
launch (2);
lightPixels (ring.Color (0, 0, 0, 0)); // restablecer todos los píxeles a apagado cuando se recibe nueva información
}

// si tiene correo
if (commandStr.equalsIgnoreCase (“mail”)) {
Serial.println (“¡tienes correo!”);
rotatingPixels (ring.Color (255, 0, 0, 0)); // mostrar animación
lightPixels (ring.Color (255, 0, 0, 0)); // mostrar animación
launch (1);
lightPixels (ring.Color (0, 0, 0, 0)); // restablecer todos los píxeles a apagado cuando se recibe nueva información
}
}

//La función auxiliar rotatingPixels fue desarrollada para mostrar una animación.El color se recibe como una entrada para esta variable.
// Rotación completa de Funcion NeoPixels 

void rotatingPixels (uint32_t color) {
for (int j = 0; j <3; j ++) { for (int i = NUM_LEDS-1; i> = 0; i–) {
ring.setPixelColor (i, color);
ring.show ();
delay (50);
ring.setPixelColor (i, 0, 0, 0);
ring.show ();
}
}
}

//la función de inicio se usa para controlar el servomotor. Ciclos su posición de //90 ° a 175 ° una cantidad determinada de veces.
// Actúa el servomotor
void launch (int number) {
s1.attach (SERV1);
para (int i = 0; i <number; i ++) {
s1.write (175);
delay (1000);
s1.write (90);
delay (1000);
}
s1.detach ();
}

 

Código completo Arduino  aqui; iot-air-freshner-code.inoiot-air-freshner-code.ino

 

Desde luego es un proyecto realmente muy interesante  no solo por su posible utilidad sino  porque no enseña la potencia de la herramientas o servios  web disponibles hoy en dia para ayudarnos en nuestros proyectos

¡Siempre tenga en cuenta que este es un prototipo experimental y podría usarse con precaución!

 

 

Fuente  ; instructables.com

Anuncios