Proyectos IoT

Cada vez que conseguimos un nuevo cliente, Mario Bros gana una moneda

María Hernández
· 13 min de lectura
Enviar por correo electrónico

Como toda startup, nos emocionamos cada vez que nuestras métricas crecen de forma positiva, y en ocasiones podemos incluso emocionarnos más si ganamos una moneda de Mario cada vez que conseguimos un nuevo cliente… Probablemente te preguntarás cómo, ¿no?

Como una poderosa plataforma de monitoreo , inmediatamente decidimos usar Ubidots para comenzar a monitorear métricas en nuestros propios dashboards , pero lo que realmente queríamos era crear un sistema que pudiera notificar a todos los miembros de nuestro equipo cada vez que consiguiéramos un nuevo cliente para entusiasmarnos. y celebrando.

Una de las primeras preguntas fue: ¿cómo podemos motivar a todo nuestro equipo diariamente siendo notificados cuando conseguimos un nuevo cliente? Fue una pregunta fácil de responder, terminamos comprando unas sirenas de policía. Pero en realidad, la parte difícil del proyecto fue descubrir cómo integrar sirenas de policía baratas y comunes en Ubidots . Una característica positiva de los miembros del equipo Ubidots es que todos somos hackers a tiempo completo, por lo que fácilmente podemos volvernos creativos al respecto.

Para integrar las sirenas decidimos comprar dos placas de desarrollo personalizadas ESP8266 que nos permitirían gestionar un relé para poder controlar el estado de la luz de cada sirena. Además, queríamos avisar al equipo, pero el sonido de una sirena de policía podía resultar un poco molesto, así que decidimos reproducir los sonidos de Mario Bros para hacerlo más emocionante y menos intrusivo.

Al final el resultado que obtuvimos fue el siguiente:

El objetivo principal de esta publicación es compartir todos los detalles técnicos del proyecto con nuestra comunidad de Ubidots , para que puedas replicarlo y mantenerte informado en tiempo real de todo lo que se pueda medir. (Si está iniciando un canal de YouTube, este puede ser un proyecto adecuado para usted;))

¡Empecemos a hackear!

Paso a paso

  1. Resumen del proyecto
  2. Configuración Ubidots
  3. Programación
  4. Alambrado
  5. Resumen

Requisitos

1. Descripción general del proyecto

Como comentamos anteriormente, decidimos comprar dos sirenas de policía para ser avisados ​​cada vez que consigamos un nuevo cliente o cuando haya una rotación, diferenciando las sirenas por sus colores. Si se enciende la sirena verde, significa que tenemos un nuevo cliente. Si se enciende la sirena roja significa que perdimos un cliente.

Para poder controlar las sirenas según el estado de los clientes, integramos Ubidots en una Ubidots mediante el uso de UbiFunction , una función que le permite crear su propia API y obtener acceso a datos, API y herramientas mediante HTTPS. Esta guía no cubrirá cómo manejar UbiFunction ; en caso de que esté interesado en obtener más detalles, consulte esta guía .

Con las métricas de los clientes ya integradas en una cuenta Ubidots , procedimos con algunas configuraciones en la plataforma para establecer algunas variables. Luego, tuvimos que establecer una suscripción a las variables sobre MQTT para activar el relé respectivo, la sirena verde o la sirena roja, y aquí es donde ocurre la magia. - Mario gana una moneda, o pierde una vida... ¡Tenemos que ser realistas!

2. Configuración Ubidots

Las variables encargadas de informar el estado de los clientes se crearán automáticamente después de configurar UbiFunction . Sólo con fines de prueba, vamos a crear un nuevo dispositivo con las variables que deseamos manejar.

Si deseas manejar datos de tu canal de YouTube , Twitter , Instagram o, básicamente, estar atento a cualquier métrica en el trabajo, todo lo que tienes que hacer es consultar su documentación API para consumirlos usando UbiFunction . En este punto, podrás obtener las métricas para publicarlas directamente en tu Ubidots .

Sin nada más que decir, entremos en detalles sobre cómo configurar un evento Ubidots para evitar resultados falsos positivos. Realmente no queremos que nuestro equipo celebre en vano.

1) Vaya a la sección Dispositivo Ubidots y cree un nuevo dispositivo llamado " cliente ". Para crear un nuevo dispositivo, haga clic en el signo más azul ubicado en la parte superior derecha de la pantalla. Luego, seleccione los dispositivos “ En blanco ” y asígneles el nombre definido.

2) Ingrese al dispositivo creado previamente e incluya 2 nuevas variables sin procesar . Para crear las variables, vaya a la sección del dispositivo, haga clic en " Agregar variable> Sin procesar " y asigne un nombre a la variable que se creará. Para este proyecto, nombramos las variables con:

  • abandono: variable encargada de recibir un indicador positivo (1) cada vez que un cliente abandona
  • nuevo-cliente: variable encargada de recibir un flag positivo (1) cada vez que conseguimos un nuevo cliente.

Con las variables ya recibiendo datos, toca manejar algunos trucos para evitar falsos positivos en caso de que nuestros dispositivos pierdan la conexión.

3) Los módulos instalados funcionan bajo MQTT como protocolo de comunicación. Si no estás familiarizado con él, te recomendamos encarecidamente que eches un vistazo a la documentación oficial .

Este protocolo tiene una característica especial que se denomina " Mensaje Retenido ". Básicamente, permite al corredor conservar el último mensaje de un tema específico configurando el indicador de mensaje retenido, de modo que cada vez que un dispositivo establece una suscripción con el tema, el corredor devuelve automáticamente el último mensaje retenido.

En base a esto, decidimos configurar un evento Ubidots para establecer la variable " abandono " y " nuevo cliente " en 0 justo después de recibir la bandera positiva (1). Lo que buscamos con esto es evitar un falso positivo en caso de que las sirenas pierdan la conexión a internet.

Imagínese si se activara la sirena verde y de repente el módulo WiFi perdiera la conexión. ¿Qué podría estar pasando?... Una vez que el módulo WiFi restablezca su conexión, la sirena restablecerá la suscripción también con la variable "nuevo-cliente", y si el último valor fuera la bandera positiva - 1, se encendería automáticamente. la sirena nuevamente cuando la notificación para ese cliente era antigua.

Para configurar un Ubidots vaya a la pestaña " Datos> Eventos " en su Ubidots . Luego, crea un nuevo evento seleccionando " +Agregar evento ". En la configuración del evento, seleccione el Dispositivo y la Variable con la que desea configurar las condiciones de su Evento, en nuestro caso el dispositivo es “ cliente ” y las variables son “ abandono ” y “ nuevo-cliente ”.

NOTA : Este evento debe crearse para ambas variables de forma independiente.

Con la variable ya seleccionada, asegúrese de que el desencadenador del evento tenga la siguiente configuración:

  • " nuevo-cliente " (variable) - Valor -> es igual a - 1 durante 0 minutos.

Para continuar con la configuración de la acción, presione la flecha derecha ubicada en la parte inferior derecha de la página. Seleccione " Establecer variable " como acción, elija la misma variable relacionada con el activador y asigne " 0 " como valor.

Para finalizar, guarda los cambios presionando las flechas hacia la derecha.

Una vez que el evento se haya creado correctamente, repita el mismo proceso para crear un segundo evento para la variable que falta.

Después de configurar los eventos, el comportamiento esperado es que cada vez que la variable reciba el indicador positivo un valor igual a 1 pasará a 0 automáticamente. Para una mejor comprensión consulte la imagen a continuación:

4. Como probablemente ya habrás notado, las variables que informan " nuevos clientes " y " abandonos " simplemente actualizan un indicador positivo cada vez que Ubidots Core actualiza una de las variables. También queremos saber el total de nuevos clientes o mantequeras que tenemos. Para esto, tenemos que configurar una variable sintética que sumará el total de indicadores recibidos en la variable durante un período de tiempo definido.

Para crear la variable sintética, seleccione "+Agregar variable > Sintética " dentro del dispositivo " cliente ". Luego, aplica la siguiente fórmula:

suma(x, rango_datos): Devuelve la suma de los dots en el rango_datos especificado.

Dónde:

  • X: es la variable deseada
  • Data_range: el período de tiempo deseado para devolver la sumatoria.

La fórmula final para cada variable debe ser:

  • suma(“nuevo-cliente”, “1M”)
  • suma(“abandono”, “1M”)

Para finalizar con la creación de la variable, selecciona “aceptar” y asigna el nombre que desees.

En este punto, podrá ver el total de nuevos clientes o abandonos que se produjeron durante un mes.

5. Ahora que tu Ubidots ya está configurada, es el momento de ser creativo y crear un dashboard para mostrar todos tus datos en un solo lugar. Consulta esta guía para conocer todos los detalles sobre los diferentes widgets que puedes configurar en tu Ubidots .

3. Programación

3.1. control de sirenas

El módulo encargado de manejar el control de estado de las sirenas es el relé ESP8266 + 1 Canal. El código base para ambas sirenas será el mismo, el único cambio que notará está en la etiqueta de la variable. Debes asignar la etiqueta de variable respectiva donde deseas que el módulo ESP8266 establezca la conexión para activar la sirena correcta.

1. Para poder trabajar con la ESP8266 en el IDE de Arduino, deberá instalar la plataforma ESP8266 utilizando el Arduino Board Manager preconfigurado. Si no está familiarizado con cómo agregar una placa con Arduino IDE, consulte este artículo para obtener orientación adicional .

2. Con la plataforma ESP8266 instalada, seleccione el dispositivo ESP8266 con el que está trabajando. En este caso, estamos trabajando con un “ Módulo ESP8266 genérico ”. Para seleccionar su placa desde el IDE de Arduino, seleccione Herramientas > Placa “Módulo ESP8266 genérico” .

3. Descargue e instale la Ubidots MQTTESP8266 . Para obtener una explicación detallada de cómo instalar bibliotecas utilizando el IDE de Arduino, consulte esta guía .

4. Ahora, con los siguientes códigos de muestra, podrá suscribirse a las variables que informan los valores.

Una vez que haya insertado el código, deberá asignar su TOKEN , SSID (nombre de WiFi) y contraseña únicos Ubidots de la red disponible. En caso de que sus variables y dispositivo administren una etiqueta diferente a las utilizadas en esta guía, asegúrese de asignar las correctas.

  • Código de muestra para la sirena roja:
/**************************************** * Incluir Bibliotecas ****** ********************************/ #include " Ubidots ESPMQTT.h" /****** ********************************** * Definir constantes ************* ***************************/ #define TOKEN "***" // Tu TOKEN Ubidots #define WIFINAME "***" / /Su SSID #define WIFIPASS "***" // Su Pase Wifi #define DEVICE_LABEL "clientes" // Coloque aquí la etiqueta de su dispositivo Ubidots #define VARIABLE_LABEL "churn" // Coloque aquí su etiqueta de variable Ubidots Cliente Ubidots (TOKEN); retransmisión de bytes activada[] = {0xA0, 0x01, 0x01, 0xA2}; //0xA00101A2 bytes reléOff[] = {0xA0, 0x01, 0x00, 0xA1}; //0xA00100A1 /**************************************** * Funciones Auxiliares *** ***********************************/ devolución de llamada nula (tema char*, carga útil byte*, sin firmar int length) { if ((char)payload[0]=='1') // Retransmisión en { Serial.write(relayOn, sizeof(relayOn)); retraso(10000); Serial.write(relé apagado, tamaño de (relé apagado)); } } /**************************************** * Funciones principales **** ***********************************/ void setup() { // pon tu código de configuración aquí, para ejecutar una vez: cliente. ubidots SetBroker(" ubidots "); // Configura el corredor correctamente para la cuenta comercial client.setDebug(false); // Pasa un valor bool verdadero o falso para activar los mensajes de depuración client.wifiConnection(WIFINAME, WIFIPASS); cliente.begin(devolución de llamada); cliente. ubidots Suscribirse(DEVICE_LABEL, VARIABLE_LABEL); //Inserte la fuente de datos y las etiquetas de la variable Serial.begin(9600); } bucle vacío() { if(!client.connected()) { client.reconnect(); cliente. ubidots Suscribirse(DEVICE_LABEL, VARIABLE_LABEL); //Inserte la fuente de datos y las etiquetas de la variable } client.loop(); }
  • Código de muestra para la sirena verde:
/**************************************** * Incluir Bibliotecas ****** ********************************/ #include " Ubidots ESPMQTT.h" /****** ********************************** * Definir constantes ************* ***************************/ #define TOKEN "***" // Tu TOKEN Ubidots #define WIFINAME "***" / /Tu SSID #define WIFIPASS "***" // Tu Pase Wifi #define DEVICE_LABEL "clientes" // Pon aquí la etiqueta de tu dispositivo Ubidots #define VARIABLE_LABEL "nuevo-cliente" // Pon aquí tu etiqueta de variable Ubidots Cliente Ubidots (TOKEN ); retransmisión de bytes activada[] = {0xA0, 0x01, 0x01, 0xA2}; //0xA00101A2 bytes reléOff[] = {0xA0, 0x01, 0x00, 0xA1}; //0xA00100A1 /**************************************** * Funciones Auxiliares *** ***********************************/ devolución de llamada nula (tema char*, carga útil byte*, sin firmar int length) { if ((char)payload[0]=='1') // Retransmisión en { Serial.write(relayOn, sizeof(relayOn)); retraso(10000); Serial.write(relé apagado, tamaño de (relé apagado)); } } /**************************************** * Funciones principales **** ***********************************/ void setup() { // pon tu código de configuración aquí, para ejecutar una vez: cliente. ubidots SetBroker(" ubidots "); // Configura el corredor correctamente para la cuenta comercial client.setDebug(false); // Pasa un valor bool verdadero o falso para activar los mensajes de depuración client.wifiConnection(WIFINAME, WIFIPASS); cliente.begin(devolución de llamada); cliente. ubidots Suscribirse(DEVICE_LABEL, VARIABLE_LABEL); //Inserte la fuente de datos y las etiquetas de la variable Serial.begin(9600); } bucle vacío() { if(!client.connected()) { client.reconnect(); cliente. ubidots Suscribirse(DEVICE_LABEL, VARIABLE_LABEL); //Inserte la fuente de datos y las etiquetas de la variable } client.loop(); }

5. Verifique su código dentro del IDE de Arduino. Para hacer esto, en la esquina superior izquierda de nuestro IDE de Arduino verás el ícono de " Marca de verificación "; selecciónelo para verificar su código.

6. Cargue el código en su “Módulo ESP8266 genérico” . Para hacer esto, elija el ícono de " flecha hacia la derecha" al lado del ícono de "marca de verificación".

7. Para verificar la conectividad del dispositivo y los datos enviados, abra el monitor serie seleccionando el icono de "lupa" en la esquina superior derecha del IDE de Arduino para ver los logs .

3.2. control de sonidos

El módulo encargado de encargarse del control MP3 es el WEMOS D1. Básicamente el código establece la suscripción con las mismas variables configuradas con cada sirena pero esta también reproduciría los sonidos de Mario Bros. Recordar:

  • Si se enciende la sirena verde, el altavoz reproducirá el sonido de Mario Bros ganando una moneda: Ubidots consigue un nuevo cliente.
  • Si se enciende la sirena roja, el altavoz reproducirá el sonido de Mario Bros perdiendo una vida: Ubidots pierde un nuevo cliente.

1. Con la plataforma ESP8266 instalada, seleccione el dispositivo ESP8266 con el que está trabajando. En este caso estamos trabajando con un “ WeMos D1 ”. Para seleccionar su placa desde el IDE de Arduino, seleccione Herramientas > Placa “WeMos D1” .

2. En caso de que no lo hayas hecho en el paso anterior, descarga e instala la biblioteca Ubidots MQTTESP8266 Para obtener una explicación detallada de cómo instalar bibliotecas utilizando el IDE de Arduino, consulte esta guía .

3. Coloque el siguiente código en su IDE de Arduino. Una vez que haya pegado el código, asegúrese de asignar su TOKEN , SSID (nombre de WiFi) y contraseña únicos Ubidots de la red disponible.

/**************************************** * Incluir Bibliotecas ****** ********************************/ #include " Ubidots ESPMQTT.h" /****** ********************************** * Definir constantes ************* ***************************/ #define TOKEN "***" // Tu TOKEN Ubidots #define WIFINAME "***" / /Tu SSID #define WIFIPASS "***" // Tu Pase Wifi #define DEVICE_LABEL "clientes" // Pon aquí la etiqueta de tu dispositivo Ubidots #define RED_SIREN "churn" // Pon aquí tu etiqueta de variable Ubidots #define GREEN_SIREN "nuevo- cliente" // Coloque aquí la etiqueta de su variable Ubidots #define RESET D5 #define NEXT D6 #define PLAY D7 Ubidots client(TOKEN); /**************************************** * Funciones auxiliares ****** ********************************/ void enable(int pin) { digitalWrite(pin, LOW); retraso(500); escritura digital (pin, ALTO); } devolución de llamada vacía (tema char*, carga útil byte*, longitud int sin signo) { char val = carga útil[0]; //Serial.println(tema); if (strstr(tema,"nuevo-cliente") && val == '1') { activar(RESET); activar(REPRODUCIR); retraso(2000); } else if (strstr(tema,"abandono") && val == '1') { activar(RESET); activar(SIGUIENTE); retraso(2000); } } /**************************************** * Funciones principales **** ***********************************/ void setup() { pinMode(RESET, SALIDA); pinMode(SIGUIENTE, SALIDA); pinMode(REPRODUCCIÓN, SALIDA); escritura digital (RESET, ALTA); escritura digital (SIGUIENTE, ALTA); escritura digital (REPRODUCCIÓN, ALTA); // pon tu código de configuración aquí, para ejecutarlo una vez: client. ubidots SetBroker(" ubidots "); // Configura el corredor correctamente para la cuenta comercial client.setDebug(false); // Pasa un valor bool verdadero o falso para activar los mensajes de depuración client.wifiConnection(WIFINAME, WIFIPASS); cliente.begin(devolución de llamada); cliente. ubidots Suscribirse (DEVICE_LABEL, GREEN_SIREN); //Inserte el cliente de fuentes de datos y etiquetas de variables. ubidots Suscribirse (DEVICE_LABEL, RED_SIREN); Serie.begin(9600); } bucle vacío() { if(!client.connected()) { client.reconnect(); cliente. ubidots Suscribirse (DEVICE_LABEL, GREEN_SIREN); //Inserte el cliente de fuentes de datos y etiquetas de variables. ubidots Suscribirse (DEVICE_LABEL, RED_SIREN); } cliente.loop(); }

4. Verifique su código dentro del IDE de Arduino. Para hacer esto, en la esquina superior izquierda de nuestro IDE de Arduino verás el ícono de " Marca de verificación "; selecciónelo para verificar su código.

5. Cargue el código en su "WeMos D1" . Para hacer esto, elija el ícono de " flecha hacia la derecha" al lado del ícono de "marca de verificación".

6. Si no estás familiarizado con el módulo MP3, te recomendamos que consultes esta guía , una de las mejores para empezar.

Según nuestra experiencia, asegúrese de estar utilizando el formato correcto para la SD y también para las canciones que se reproducirán.

  • Tamaño Tarjeta Micro SD: 1 o 2 GB como máximo.
  • Formato Micro SD: FAT: le recomendamos formatear su tarjeta SD usando SD Card Formatter .
  • Formato de canciones: AD4: le recomendamos que utilice AD4Converter .

Para ahorrarte unos minutos de trabajo, en esta carpeta encontrarás los sonidos de Mario Bros utilizados para el proyecto.

Según la lógica utilizada en el código, la primera canción identificada en la tarjeta Micro SD como "0000" reproducirá el sonido de Mario Bros cuando esté ganando una moneda, y la segunda identificada como "0001" reproducirá el sonido de Mario Bros. sonido cuando perdió una vida.  

4. Cableado

NOTA IMPORTANTE: Antes de establecer todas las conexiones en conjunto, asegúrese de que las placas tengan el código de muestra ya cargado. Además, asegúrese de que funcionen correctamente con su Ubidots .

Para que el cableado sea fácil de entender, dividí este proceso en diferentes pasos. Siga el diagrama y la tabla de cableado que se muestran a continuación para establecer las conexiones adecuadas.

  • Control del módulo MP3

Para integrar el módulo de relé ESP8266 + 1 canal con las sirenas tuvimos que hacer algunas modificaciones al cableado original de cada sirena. Básicamente, hemos eliminado el interruptor manual de cada sirena para sustituirlo por el módulo de relé.

Para poder alimentar cada módulo de relé ESP8266 + 1 canal, utilizamos un cargador de celular para regular el voltaje de entrada de 110V a 5V.

Consulte el diagrama a continuación para tener una referencia de cómo establecer la modificación del cableado original de las sirenas, también de cómo encender los módulos ESP8266.

  • Control del módulo MP3

El módulo MP3 tiene diferentes configuraciones . Según los requisitos necesarios para este proyecto, decidimos utilizar el "circuito de aplicación en modo MP3".

Consulte la tabla de cableado y el diagrama a continuación para establecer las configuraciones adecuadas:

  • Todo el sistema

Para finalizar, encienda la placa WEMOS con la salida de 5V del regulador utilizado:

Con las conexiones de cables adecuadas ya establecidas, coloque todos los componentes dentro de las sirenas y continúe con la instalación de las sirenas. En nuestro caso decidimos colocarlos en la pared principal de nuestra oficina.

5. Resumen

Realmente disfrutamos el tiempo de pirateo para reconstruir la funcionalidad de las sirenas de la policía para notificar a todo el equipo sobre el estado de los clientes en tiempo real, pero de una manera divertida usando los sonidos de Mario Bros.

Sabemos que este es un proyecto interno que no podría no ser tan útil para todos, pero lo encontramos relevante para todos aquellos que están iniciando sus canales de YouTube, logs o incluso en una empresa y desean realizar un seguimiento de las métricas de una manera amigable y en tiempo real cada vez que obtenga un nuevo suscriptor, visitante o cliente.

Si eres un creador apasionado como nosotros y decides reproducir este proyecto, siéntete libre de compartirlo, pero no olvides etiquetarnos en @ubidots ubidots través de nuestras redes sociales ( facebook , linkedin , twitter , instagram ). Será un placer para nosotros compartirlo con Ubidots .

Proyectos IoT más útiles:

Escrito por María Hernández

María es una creadora de corazón. Con experiencia en Ingeniería Eléctrica, constantemente aprende, comparte y experimenta con las últimas tecnologías IoT que existen. Embajador IoT en Ubidots .

Sigue leyendo