Archivo de la etiqueta: Programación Node-RED

Ejercicios Dashboard Node-RED

Ejercicio 01

Mostrar en el dashboard en un mismo grupo 3 widgets text donde cada segundo actualice el timestamp (epoch time), la fecha usando el nodo node-red-contrib-date y el día y hora en formato, usando el nodo moment para transformarlo.

Código: https://github.com/aprendiendonodered/ejercicio01 

Vídeo: https://youtu.be/wS0E1j1q7sM  

Ejercicio 02

Leer el dato de la temperatura publicado en MQTT y hacer que cuando la temperatura esté fuera de un rango entre 18 y 22 grados, ponga el estado de confort en un elemento del dashboard y mande un email.

Código: https://github.com/aprendiendonodered/ejercicio02 

Vídeos:

Imágenes:

Ejercicio 03

Sobre el ejercicio2, añadir de forma dinámica los umbrales máximos y mínimos de alerta mediante dos sliders en el dashboard.

También hacer que los valores de los colores del gauge cambien en función del valor de MAX y MIN introducido por los sliders

Opcionalmente mostrar los mensajes de alerta y los iconos:

  • Todo Correcto: <i class=”fa fa-lightbulb-o fa-2x nr-dashboard-ok”></i>
  • Temperatura Alta: <i class=”fa fa-warning fa-2x nr-dashboard-warning”></i>
  • Temperatura Baja: <i class=”fa fa-exclamation-circle fa-2x nr-dashboard-error”></i>

Para cambiar la configuración de los widgets de dashboard se usa mediante msg.ui_control como se indica aquí: https://github.com/node-red/node-red-dashboard/blob/master/config-fields.md 

En este caso uso un nodo change donde borro payload y pongo las propiedades msg.ui_control.seg1 y msg.ui_control.seg2 a los valores almacenados en las variables de contexto.

Por último no dejar que el valor MIN sea mayor que MAX, ni que MAX sea menor que min en el dashboard, para ello controlar el valor de MIN y MAX al cambiar con un nodo switch y tomar la decisión a hacer.

Código: https://github.com/aprendiendonodered/ejercicio06.git 

Ejercicios Básicos Node-RED

Primer Flujo en Node-RED

Vamos a probar un flujo muy simple. Lo que hará es mostrar un texto por el panel de debug. Arrastra un nodo inject de la categoría input y un nodo debug de la categoría output al flujo. Los tienes que conectar entre ellos arrastrando el punto de la parte derecha del nodo inject sobre el punto de la parte izquierda del nodo debug.

primer flujo node-red

A continuación vamos a editar el nodo inject. Si haces doble click sobre el nodo se abrirá un panel donde nos muestra diferentes parámetros. En este panel tienes que seleccionar del menú desplegable donde pone Payload, la opción que pone String.

En el campo de texto pon cualquier cosa como por ejemplo Hola mundo 🙂

Para guardar la aplicación sólo tienes que dar a Deploy que si te has dado cuenta, ha pasado de estar en un color gris oscuro a rojo.

deploy node-red

Una vez que lo hayas pulsado, volverá de nuevo al color gris oscuro. Esto quiere decir que ya tenemos guardados todos los cambios del flujo de Node-RED.

Para probar este primer flujo con Node-RED tenemos que abrir el panel de debug que está situado en la parte derecha. Luego, tienes que hacer click sobre la parte izquierda del nodo inject.

Esto hará que en el panel debug aparezca lo que hemos escrito en la configuración del nodo inject.

Como puedes ver, el mensaje se muestra en el panel debug.

Para saber que se ha hecho un deploy, se puede hacer que mande un correo cada vez que se reinicia Node-RED. Flujo:

[{"id":"67252650.d05f28","type":"e-mail","z":"45a71fc.1bebde","server":"smtp.gmail.com","port":"465","secure":true,"tls":true,"name":"micuenta@gmail.com","dname":"manda email alerta","x":410,"y":580,"wires":[]},{"id":"fc4c30da.caea3","type":"inject","z":"45a71fc.1bebde","name":"","props":[{"p":"payload"},{"p":"topic","vt":"str"}],"repeat":"","crontab":"","once":true,"onceDelay":0.1,"topic":"Mi instancia Node-RED deployed","payload":"Mi instancia de Node-RED ha hecho un redeploy o se ha reiniciado.","payloadType":"str","x":210,"y":580,"wires":[["67252650.d05f28"]]}]

Más información: https://programarfacil.com/blog/raspberry-pi/introduccion-node-red-raspberry-pi/

Node-RED y MQTT con Wemos D1 Mini

Capturar los datos mandados por los nodos remotos por MQTT.

Sólo tienes que arrastrar el nodo mqtt que está en la categoría input al flujo.

sistema alarma node-red

Ahora hay que configurarlo. Aquí es donde vemos la potencia de Node-RED. Cuando utilizamos una tecnología, nos centramos en lo superficial. En el caso de MQTT lo único que tenemos que hacer es configurar el broker y el topic.

Al tratarse de un nodo de entrada, lo que hace es recibir los mensajes publicados en un topic es decir, se suscribe al topic. Haz doble click sobre el nodo para que abra el panel de configuración.

En el panel de configuración MQTT vamos a configurar primero el broker MQTT. Haz click en el lápiz que aparece en Server.

sistema alarma node-red

Esto abre un nuevo panel de configuración. Pon un nombre al broker MQTT por ejemplo RASPBERRY PI MOSQUITTO. En Server tienes que poner la IP donde está instalado el broker MQTT y el puerto que utiliza, normalmente es el 1883.

Esta sería la configuración mínima. No te olvides de hacer click en el botón Add.

sistema alarma node-red

Después de esta acción volverás al panel de configuración del nodo mqtt y automáticamente, habrá seleccionado el broker MQTT que acabamos de crear.

Por último, vamos a rellenar el campo de Topic. Debe ser el mismo que hemos puesto en Arduino o el ESP8266, /casa/puerta/alarma. Una vez lo tengas, haz click en Done.

sistema alarma node-red

Ahora sólo nos queda probarlo. Para ello vamos a utilizar el mismo nodo debug de la categoría output que hemos utilizado antes.

Arrástralo al flujo, conecta los dos nodos y haz click en el botón Deploy.

sistema alarma node-red

Para probar el sistema lo podemos hacer de dos formas. Desde una terminal de Raspberry Pi podemos publicar un mensaje en el topic o directamente conectando la placa y simulando que abren la puerta.

El resultado sería el siguiente.

sistema alarma node-red

Segundo Flujo

Obtener los datos de los terremotos en el mundo descargando un csv de una web pública.

Pasos:

  • Añade un nodo inject
  • Añade un nodo http request que consulte esta web: https://earthquake.usgs.gov/earthquakes/feed/v1.0/summary/significant_month.csv
  • Añade un nodo csv
  • Añade un node debug
  • Únelo todo
  • Añade un nodo switch de forma que saque aquellos datos cuyo valor de magnitud (​​msg.payload.mag) sea mayor o igual que 7
  • Añade un nodo change que ponga en msg.payload el valor PANIC!!!
  • Añade un nodo de debug que muestre el dato del nodo change

Código:

[{"id":"e36406f2.8ef798","type":"inject","z":"f03b57d5.e525f8","name":"","topic":"","payload":"","payloadType":"str","repeat":"300","crontab":"","once":false,"x":130,"y":900,"wires":[["c3c50023.3bbed"]]},{"id":"c3c50023.3bbed","type":"http request","z":"f03b57d5.e525f8","name":"Recent Quakes","method":"GET","url":"https://earthquake.usgs.gov/earthquakes/feed/v1.0/summary/significant_month.csv","tls":"","x":300,"y":900,"wires":[["8afc6cac.e0812"]]},{"id":"8afc6cac.e0812","type":"csv","z":"f03b57d5.e525f8","name":"","sep":",","hdrin":true,"hdrout":"","multi":"one","ret":"\\n","temp":"","x":470,"y":900,"wires":[["44779781.4190f8","6f0eb546.9e208c"]]},{"id":"44779781.4190f8","type":"debug","z":"f03b57d5.e525f8","name":"","active":true,"complete":false,"x":630,"y":900,"wires":[]},{"id":"6f0eb546.9e208c","type":"switch","z":"f03b57d5.e525f8","name":"","property":"payload.mag","propertyType":"msg","rules":[{"t":"gte","v":"7","vt":"num"}],"checkall":"true","outputs":1,"x":510,"y":960,"wires":[["d78d4aa8.8c8208"]]},{"id":"d78d4aa8.8c8208","type":"change","z":"f03b57d5.e525f8","name":"","rules":[{"t":"set","p":"payload","pt":"msg","to":"PANIC!","tot":"str"}],"action":"","property":"","from":"","to":"","reg":false,"x":650,"y":1020,"wires":[["72fddece.fac0d"]]},{"id":"72fddece.fac0d","type":"debug","z":"f03b57d5.e525f8","name":"","active":true,"complete":false,"x":750,"y":960,"wires":[]}]

Presentación del Curso Node-RED Developer Professional

Motivación

Node-RED se está convirtiendo en un lenguaje de programación muy popular en IoT/Industria 4.0, que cada vez están adoptando más empresas en sus desarrollo.

Node-RED es una herramienta de programación visual (low-code). Node-Red se ha consolidado como framework open-source para la gestión y transformación de datos en tiempo real en entornos de Industry 4.0, IOT, Marketing digital o sistemas de Inteligencia Artificial entre otros. La sencillez de aprendizaje y uso, que  no requiere de grandes conocimientos de programación, su robustez y la necesidad de bajos recursos de cómputo ha permitido que hoy en día se encuentre integrado en prácticamente la mayoría de dispositivos IOT e IIOT del mercado, así como equipos Raspberry, sistemas cloud o equipos locales.

Introducción

Los datos industriales de la fábrica o de cualquier proceso operativo son ahora un impulsor importante de las iniciativas de big data. Los beneficios de enviar datos de tecnología de operaciones (Operations Technology – OT) a big data y aplicaciones empresariales incluyen una gestión de recursos mejorada para reducir los costos y lograr un rápido retorno de la inversión.

Hasta ahora, recopilar datos de OT y enviarlos a sistemas de IT no ha sido rentable, requiere un código personalizado, no es fácilmente escalable y puede crear una serie de enredos de tecnología patentada que dejan a las empresas con datos en silos a los que no pueden acceder fácilmente.

Conectar datos industriales a sistemas de IT parece simple, pero en realidad es complejo. Los datos de OT vienen en múltiples formatos de datos, protocolos propietarios y sin información contextual. Está diseñado para operaciones, directamente acoplado a aplicaciones y, a menudo, existe en redes aisladas. IT, por otro lado, IT necesita formatos de datos estándar, objetos de datos, información contextual, seguridad incorporada y metodología de publicación/suscripción para hacer uso de los datos. Los datos cargados en un data lake pueden requerir una transformación personalizada para ofrecer valor.

Node-RED se está utilizando para permitir la integración OT-IT. Ahora los usuarios pueden conectarse a los datos de OT para obtener una única fuente de verdad al conectarse a dispositivos de OT de forma nativa, incluidos los datos de etiquetas contextualizados.

Objetivo

Node-Red es una herramienta open source de desarrollo/programación basada en flujos. Es una programación visual desarrollada originalmente por IBM para conectar dispositivos de hardware, API y servicios en línea como parte del Internet de las cosas (IoT).

El objetivo de este curso es que el alumno aprenda el uso de Node-RED y la programación visual mediante flujos para su uso en entornos de domótica, IIoT e IoT. El alumno será capaz de instalar, configurar y realizar proyectos de dificultad intermedia usando Node-RED. Aprenderá a administrar y programar una plataforma IIoT y tener una herramienta para conocer las posibilidades de IIoT.

Node red es adecuado para profesionales dedicados al Internet de las cosas Industrial (IIoT) y personal dedicado al diseño y prueba de soluciones para la comunicación de equipos de planta con aplicaciones de IT. Dado que la mayoría de dispositivos IoT para industria 4.0 posibilitan realizar un programa de control con la herramienta de Node-Red, el dominio de dicha herramienta permitiría al equipo IIoT explorar y ampliar las soluciones que ofrece a la empresa que lo use.

Al finalizar el curso el alumno será capaz de:

  • Instalar Node-RED en diversas plataformas
  • Conocer el protocolo MQTT
  • Configurar y usar de forma segura Node-RED
  • Usar la programación de flujos de forma eficiente
  • Hacer módulos de funciones en Node-RED
  • Hacer debug de los programas Node-RED
  • Instalar y utilizar nodos
  • Configurar un dashboard
  • Integrar Node-RED con servicios de terceros

Metodología

El curso presencial consiste en 20 horas de formación en directo, repartidas en 1 primera sesión de 4 horas de 8:00 a 12:00 y dos sesiones de 8 horas de 8:00 a 16:00. Se hará descansos de 5 minutos cada aproximadamente 2 horas.

Toda la documentación se publicará de forma libre on-line en https://www.aprendiendoarduino.com/cursos/node-red-developer-professional/, permitiendo que pueda mantenerse actualizada y fácilmente accesible.

Todo el código, programas y ejemplos se publicará de forma libre en https://github.com/aprendiendonodered pudiendo actualizarse y colaborar en el repositorio.

Además están disponibles otros recursos para ampliar información:

Toda la documentación será on-line con el objetivo de mantenerla actualizada y no con un documento físico que se queda obsoleto rápidamente. Después de finalizar el curso toda la documentación on-line seguirá estando disponible de forma pública.

Toda la documentación está liberada con licencia Creative Commons.

Reconocimiento – NoComercial – CompartirIgual (by-nc-sa): No se permite un uso comercial de la obra original ni de las posibles obras derivadas, la distribución de las cuales se debe hacer con una licencia igual a la que regula la obra original.

Aprendiendo Arduino by Enrique Crespo is licensed under a Creative Commons Reconocimiento-NoComercial-CompartirIgual 4.0 Internacional License.

Contenido del Curso

Toda la documentación del curso y el código usado es libre y accesible desde https://www.aprendiendoarduino.com/

  1. Presentación del curso: 1h
  2. Instalación de Node-RED: 2h
  3. Protocolo MQTT: 1h
  4. Configurar y securizar Node-RED: 2h
  5. Programación Node-RED: 2h
  6. Ejercicio Práctico de Programación: 1h
  7. Nodos Node-RED: 1h
  8. Funciones en Node-RED: 1h
  9. Ejercicio Práctico de Funciones: 1h
  10. Debug Node-RED: 1h
  11. Creación de Nodos Simples: 1h
  12. Node-Red en la Nube: 1h
  13. Dashboard Node-Red: 1h
  14. Creación de un Dashboard: 1h
  15. Integración con Servicios de Terceros: 2h
  16. Ejercicio Práctico de Integración de Servicios: 1h

Presentaciones

  • Nombre
  • Role: IT, Administrador Sistemas, Redes, Desarrollador, Industria (OT), Producción, Jefe de Proyecto, etc…
  • Experiencia con Node-RED y node.js
  • ¿Hardware con el que interactuar? ¿Tipo de aplicaciones de Node-RED?

Contacto

Para cualquier consulta durante el curso y en cualquier otro momento mediante email: aprendiendoarduino@gmail.com

Twitter @jecrespo: https://twitter.com/jecrespom

Y más información sobre el curso y el autor: http://www.aprendiendoarduino.com/acerca-de/

Qué es Node-RED

Node-RED es una herramienta de programación visual. Muestra visualmente las relaciones y funciones, y permite al usuario programar escribiendo muy pocas líneas de código. 

Node-RED es un editor de flujo basado en el navegador donde se puede añadir o eliminar nodos y conectarlos entre sí con el fin de hacer que se comuniquen entre ellos. La idea de Node-RED es que sea ‘low-code’.

Low-code programming for event-driven applications 

Web: https://nodered.org/ 

Paradigma de programación basada en flujo: https://es.wikipedia.org/wiki/Programaci%C3%B3n_basada_en_flujo 

Razones para usar node-red: 

Sobre Node-RED: https://nodered.org/about/

Node-Red hace que el conectar los dispositivos de hardware, APIs y servicios en línea sea más fácil que nunca.

Node-red se ha convertido en el estándar open-source para la gestión y procesado de datos en tiempo real, logrando simplificar los procesos entre productores y consumidores de información.

Node-Red se ha consolidado como framework open-source para la gestión y transformación de datos en tiempo real en entornos de Industry 4.0, IOT, Marketing digital o sistemas de Inteligencia Artificial entre otros. La sencillez de aprendizaje y uso, que no requiere de conocimientos de programación, su robustez y la necesidad de bajos recursos de cómputo ha permitido que hoy en día se encuentre integrado en prácticamente la mayoría de dispositivos IOT e IIOT del mercado, así como equipos Raspberry, sistemas cloud o equipos locales.

Node-RED es una herramienta muy potente que sirve para comunicar hardware y servicios de una forma muy rápida y sencilla. Simplifica enormemente la tarea de programar del lado del servidor gracias a la programación visual.

Node red es una herramienta de programación que se utiliza para conectar dispositivos de hardware, APIs y servicios de internet. Adecuado para los equipos dedicados al Internet de las cosas Industrial (IIoT) y personal dedicado al diseño y prueba de soluciones para la comunicación de equipos de planta con aplicaciones de IT.

Dado que la mayoría de dispositivos IoT para industria 4.0 posibilitan realizar un programa de control con la herramienta de Node-Red, el dominio de dicha herramienta permitiría al equipo IIoT explorar y ampliar las soluciones que ofrece a la empresa que lo use.

Fue creada por Nick O’Leary y Dave Conway-Jones del grupo de Servicios de Tecnologías Emergentes de IBM en el año 2013. Su objetivo es dar solución a la complejidad que surge cuando queremos integrar nuestro hardware con otros servicios.

Su punto fuerte es la sencillez. Nos permite utilizar tecnologías complejas sin tener que profundizar hasta el más mínimo detalle en todas ellas. Nos quedamos en una capa inicial donde nos centramos en lo importante y dejamos de lado aquello que no es práctico.

Wikipedia: https://en.wikipedia.org/wiki/Node-RED 

Encuesta Node-RED 2019: https://nodered.org/about/community/survey/2019/ 

Node-RED está creado a partir de NodeJS y la librería de JavaScript D3.js.

Node-Red se basa en Node.js. Para instalar el Node-Red, necesitas tener tanto Node.js instalado como NPM. Con NPM, es muy fácil instalar Node-Red: npm install -g node-red

NodeJS proporciona la potencia suficiente para que Node-RED sea fiable y escalable. NodeJS es un software muy potente que permite la programación en JavaScript del lado del servidor.

La estructura mínima son los nodos. Estos se arrastran a través de la interfaz gráfica y nos permiten hacer una tarea concreta. Recibir una llamada HTTP, un mensaje MQTT o la activación de un pulsador.

Todos estos nodos se organizan en flujos o flows que agrupan nodos que se conectan entre ellos. Todo de una forma visual, sin apenas tener que programar.

Node-RED es un motor de flujos con enfoque IoT, que permite definir gráficamente flujos de servicios, a través de protocolos estándares como REST, MQTT, Websocket, AMQP… además de ofrecer integración con APIs de terceros, tales como Twitter, Facebook, Yahoo!…

Se trata de una herramienta visual muy ligera, programada en NodeJS y que puede ejecutarse desde en dispositivos tan limitados como una Raspberry, hasta en plataformas complejas como IBM Bluemix, Azure IoT o Sofia2 Platform.

Node-RED es una herramienta de código abierto, estando disponible en github.

Repositorio: https://github.com/node-red/node-red

Una de las características más notables de Node-RED es la sencillez con la que se pueden crear nuevos nodos e instalarlos, en el siguiente enlace disponemos de toda la documentación necesaria: http://nodered.org/docs/creating-nodes/, en él, podemos ver que desarrollar un nuevo nodo es tan sencillo como crear un fichero HTML con el formulario de configuración mostrado en la imagen anterior para el nodo en concreto, y un fichero JS, con la lógica del nodo escrita en NodeJS.

De este modo, cualquier persona u organización puede crear sus propios nodos, adaptando el motor de flujo a las necesidades de su negocio.

Los flujos programados en Node-RED se almacenan internamente en formato JSON y son portables entre distintas instalaciones de Node-RED, siempre que el Node-RED de destino tenga instalados los nodos utilizados en el flujo.

De este modo un flujo Node-RED consiste en un fichero con este aspecto:

La facilidad de desarrollo de nuevos nodos, así como la portabilidad de los flujos, confieren a Node-RED un marcado enfoque social. Gran parte de su éxito se fundamenta en que los nodos y flujos desarrollados por una persona u organización, pueden ser aprovechados por otras. En este sentido, en el sitio oficial de Node-RED encontramos una sección de contribuciones de terceros, con más de 2900 nodos y flujos subidos por la comunidad y listos para utilizar.

Node-RED Library: https://flows.nodered.org 

Getting Started Node-RED: https://nodered.org/#get-started 

Comunidad Node-RED: https://nodered.org/#community 

Documentación Node-RED: https://nodered.org/docs/ 

En cuanto a cómo instalar Node-RED, existen dos alternativas:

  • Modo Standalone: Donde se ejecuta como un proceso NodeJS independiente del resto de procesos.
  • Modo Embebido: Donde forma parte de una aplicación mayor, de forma que es responsabilidad de esta controlar el ciclo de vida del propio Node-RED

Ambas instalaciones son securizables tanto a nivel control de acceso con usuario y contraseña, como con certificado SSL para acceder al editor por protocolo seguro HTTPS.

Asimismo dispone de un API Rest de administración y operación (http://nodered.org/docs/api/) de manera que puede interactuar y ser controlado por un sistema externo.

Estas características son las que hacen que Node-RED sea adecuado para ejecutarse casi en cualquier plataforma, ya que le dan la versatilidad de ser instalado tal cual, por ejemplo en una Raspberry. O poder ser administrado por un sistema mayor, como por ejemplo IBM Bluemix.

Instalación: https://nodered.org/docs/getting-started/ 

  • Localmente
  • En un dispositivo
  • En la nube

Guia de usuario: https://nodered.org/docs/user-guide/

Es posible instalar Node-RED en un portátil y controlar el broker desde el mismo.

Configuración node red: https://nodered.org/docs/configuration 

Node-RED con Arduino: https://nodered.org/docs/hardware/arduino 

API nodered: https://nodered.org/docs/api/ 

Dónde obtener ayuda de Node-RED:

Comunidad node red: https://nodered.org/about/community/ 

Más información:

Vídeo Introducción IoT: https://www.youtube.com/watch?time_continue=85&v=vYreeoCoQPI 

Curso IoT simatic (Siemens con Node red); http://www.infoplc.net/descargas/109-siemens/comunicaciones/2847-manual-simatic-iot2040-node-red 

Webinar Siemens y Node-RED: https://assets.new.siemens.com/siemens/assets/api/uuid:1c32c3de-4a78-4143-af7b-49422b471a82/webinar-simatic-iot-2040-2050.pdf

Entender Node-RED:

  • Node-RED maneja mensajes en formato JSON (objetos JSON) que se mueven a través de los nodos que se comportan y ejecutan unas acciones en función del mensaje de entrada y devuelve un mensaje con los datos o el resultado de la ejecución.
  • Hacer el ejercicio https://nodered.org/docs/tutorials/second-flow para comprobar la potencia de Node-RED

Ejercicios Curso Node-RED Developer

Ejercicios del curso “Node-RED Developer Nivel 1”: https://www.aprendiendoarduino.com/cursos/node-red-developer-para-iot-nivel-i/ 

Ejercicio 01

Mostrar en el dashboard en un mismo grupo 3 widgets text donde cada segundo actualice el timestamp (epoch time), la fecha usando el nodo node-red-contrib-date y el día y hora en formato, usando el nodo moment para transformarlo.

Código: https://github.com/aprendiendonodered/ejercicio01 

Vídeo:

Ejercicio 02

Leer el dato de la temperatura publicado en MQTT y hacer que cuando la temperatura esté fuera de un rango entre 18 y 22 grados, ponga el estado de confort en un elemento del dashboard y mande un email.

Código: https://github.com/aprendiendonodered/ejercicio02

Vídeos:

Imágenes:

Ejercicio 03

Hacer un flujo para publicar datos de CPU, Memoria y temperatura de las Raspberry Pi de casa en MQTT en los topics:

  • aprendiendonodered/alumnoxx/raspberrypi/CPU
  • aprendiendonodered/alumnoxx/raspberrypi/Memoria
  • aprendiendonodered/alumnoxx/raspberrypi/Temperatura

Luego hacer que la instancia de Node-RED del curso las recoja y muestre en el dashboard.

Para publicar los datos de casa, usar el broker MQTT del curso enriquecrespo.com:1883. Opcionalmente usar el broker integrado en Node-RED aedes o un HTTP endpoint.

Código Raspberry Pi:

Vídeo 1 con código Raspberry Pi:

Código Node-RED Dashboard:

Vídeo segunda parte:

Dashboard:

Código Total: https://github.com/aprendiendonodered/ejercicio03 

Anexo: Obtener Datos de Raspberry Pi

Código para obtener los datos de Raspberry Pi, usando en nodo exec: 

[{"id":"af22b399.12614","type":"exec","z":"8a81314e.a0f79","command":"vcgencmd measure_temp","addpay":false,"append":"","useSpawn":"","timer":"","name":"RPi Temp.","x":325.2221908569336,"y":46.33333683013916,"wires":[["14f0a295.59181d"],[],[]]},{"id":"408435c9.447fec","type":"exec","z":"8a81314e.a0f79","command":"top -d 0.5 -b -n2 | grep \"Cpu(s)\"|tail -n 1 | awk '{print $2 + $4}'","addpay":false,"append":"","useSpawn":"","timer":"","name":"CPU Load","x":325.2221908569336,"y":126.33333683013916,"wires":[["2c7475c7.6cc01a"],[],[]]},{"id":"8fbcbdf9.549b7","type":"exec","z":"8a81314e.a0f79","command":"free | grep Mem | awk '{print 100*($4+$6+$7)/$2}'","addpay":false,"append":"","useSpawn":"","timer":"","name":"Free Memory","x":325.2222099304199,"y":190.55557250976562,"wires":[["daf6433c.bad81"],[],[]]},{"id":"14f0a295.59181d","type":"function","z":"8a81314e.a0f79","name":"","func":"str = msg.payload\nmsg.payload = str.substring(5,9);\nreturn msg;","outputs":1,"noerr":0,"x":471.888858795166,"y":33.00000190734863,"wires":[["46daa272.4333ac","334a9ddd.345602"]]},{"id":"daf6433c.bad81","type":"function","z":"8a81314e.a0f79","name":"","func":"str = msg.payload\nmsg.payload = parseInt(str.substring(0,str.length - 1));\nreturn msg;","outputs":1,"noerr":0,"x":530,"y":180,"wires":[["1ba39571.ba75ab"]]}]

Ejercicio 04

Hacer un dashboard para ver la temperatura de todas las Raspberry Pi publicada en MQTT y sus gráficas. Usar MQTT Explorer para explorar qué datos están publicados.

Opcionalmente hacer varias tabs/pestañas para mostrar: temperaturas, CPU y memoria agrupadas en cada pestaña.

Código: https://github.com/aprendiendonodered/ejercicio04

Vídeos:

  • Vídeo 1:
  • Vídeo 2:
  • Vídeo 3:

Flujo:

Dashboard Final:

Ejercicio 05

Hacer IFTTT con Node-RED. Ejemplos:

  • Si recibo un correo con el asunto “twitter”, entonces twittear el contenido del correo.
  • Si recibo una llamada por el HTTP endpoint “mail”, entonces mandar un email al destinatario, asunto y contenido indicados

Integración de Node-RED con email, twitter y HTTP endpoint:

La llamada http en un GET y debe tener el formato: https://enriquecrespo.com:188xx/mail?destinatario=pepe@gmail.com&asunto=mandacorreo&contenido=hola_que_tal

Código: https://github.com/aprendiendonodered/ejercicio05

Vídeos:

  • Primera parte:
  • Segunda parte: 

Petición usada: https://enriquecrespo.com:18802/mail?destinatario=aprendiendoraspberrypi@gmail.com&asunto=correo_desde_http_para_twitter&contenido=hola_node_red 

Además en este caso si hago una petición HTTP GET o POST manda el email y luego la segunda condición cuando lee el email, manda el tweet, lo que hace que se desencadenen los dos eventos.

Ejercicio 06

Sobre el ejercicio del día 2, añadir de forma dinámica los umbrales máximos y mínimos de alerta mediante dos sliders en el dashboard.

También hacer que los valores de los colores del gauge cambien en función del valor de MAX y MIN introducido por los sliders

Opcionalmente mostrar los mensajes de alerta y los iconos:

  • Todo Correcto: <i class=”fa fa-lightbulb-o fa-2x nr-dashboard-ok”></i>
  • Temperatura Alta: <i class=”fa fa-warning fa-2x nr-dashboard-warning”></i>
  • Temperatura Baja: <i class=”fa fa-exclamation-circle fa-2x nr-dashboard-error”></i>

Para cambiar la configuración de los widgets de dashboard se usa mediante msg.ui_control como se indica aquí: https://github.com/node-red/node-red-dashboard/blob/master/config-fields.md 

En este caso uso un nodo change donde borro paylaod y pongo las propiedades msg.ui_control.seg1 y msg.ui_control.seg2 a los valores almacenados en las variables de contexto.

Por último no dejar que el valor MIN sea mayor que MAX, ni que MAX sea menor que min en el dashboard, para ello controlar el valor de MIN y MAX al cambiar con un nodo switch y tomar la decisión a hacer.

Código: https://github.com/aprendiendonodered/ejercicio06.git

Vídeos:

  • Primera Parte
  • Segunda Parte

Ejercicio 07

Hacer un subflujo con 5 salidas, que pasándole una variable de entorno con el número de datos a analizar, devuelva la media, máxima y mínima de esos datos por cada salida, una vez retenidos y analizados. En la cuarta salida me devuelva un array de los datos analizados y en la quinta el contador interno.

Personalizar el flujo, añadiendo documentación de lo que hace el subflow y lo que devuelve cada salida.

Código: https://github.com/aprendiendonodered/ejercicio07 

Vídeos:

  • Primera Parte
  • Segunda Parte
  • Tercera Parte
  • Cuarta Parte

Ejercicio 08

Clonar el proyecto https://github.com/aprendiendonodered/ejercicio04 y añadir toda la información de todas las Raspberry Pi que publican datos en mqtt://enriquecrespo.com:1883 y añadir las chart a cada datos, mostrando los datos de forma visual y personalizando el dashboard.

Código: https://github.com/aprendiendonodered/ejercicio08 

Vídeos:

  • Primera Parte:
  • Segunda Parte:
  • Tercera Parte:

Ejercicio 09

Hacer una función que guarde los últimos 20 valores en una variable de contexto y una vez tenga los 20, mande la media, máximo y mínimo por tres salidas y en una cuarta mande los 20 mensajes que ha retenido de forma consecutiva. En la quinta salida mandar el dato del contador interno.

Una vez hecho, añadir una funcionalidad para que si recibe un mensaje en la propiedad msg.acumulado, tome ese dato como el número de datos a acumular para hacer el cálculo. Una vez llegue este dato, actualiza el acumulado del contador y en función de lo que lleve acumulado, espera hasta llegar al nuevo dato o si lo ha superado, manda lo que ya tiene.

Por último, encapsular esta función en un subflow para poder reutilizarlo.

Añadir dato a un array: https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Objetos_globales/Array/push 

Función reduce: https://www.w3schools.com/jsref/jsref_reduce.asp 

Función Max: https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Objetos_globales/Math/max 

Código: https://github.com/aprendiendonodered/ejercicio09

Vídeos:

  • Primera parte:
  • Segunda parte:
  • Tercera parte:

Ejercicio 10 (Ejercicio Final)

Hacer un CSV con los datos de temperatura, memoria y CPU que manda vuestra Raspberry PI y guardar en un fichero llamado raspberrypi.csv. Añadir también el campo timestamp al fichero csv.

Para ello tomar los datos publicados en MQTT, ordenarlos y prepararlos para que los pase a un nodo join y los ponga en este orden: timestamp,CPU,Memory,Temperature 

Para que los ordene de forma automática el nodo join debemos hacer uso de la propiedad parts como hace el nodo split usando:

  • parts.index – para el orden de los elementos del grupo a unir
  • parts.id – para indicar que es el mismo grupo
  • parts.count – para indicar el nº de mensajes del grupo

También crear un flujo con un nodo inject que cree el fichero con la cabecera: “timestamp,CPU,Memory,Temperature” y que además al hacerlo vacíe el fichero existente.

Crear otro flujo con un nodo inject que lee con “file in” el contenido del fichero y lo mande a la pantalla de debug.

Luego con un botón del dashboard hacer la parte de inicializar el fichero (que aparezca una notificación del dashboard para confirmar que se desea inicializar) y con otro botón del dashboard un flujo que lea el fichero y lo mande al nodo chart del dashboard y hacer las gráficas.

Opcionalmente, hacer un tercer botón que mande por email el fichero csv, como fichero adjunto.

Opcionalmente, hacer un flujo que lea los datos del fichero llamado raspberrypi.csv y obtener los datos de media, máxima y mínima de la temperatura, memoria y CPU y mostrar en el dashboard en un nodo texto.

Opcionalmente, hacer un flujo que agrupe los datos en grupos de 100 y sacar los datos de media, máxima y mínima cada 100 valores y guardar en otro fichero llamado raspberrypi_agrupados.csv con los campos: timestamp,CPU_AVG,CPU_MAX,CPU_MIN,Memory_AVG,Memory_MAX,Memory_MIN,Temperature_AVG,Temperature_MAX,Temperature_MIN

Mandar datos al nodo chart: https://github.com/node-red/node-red-dashboard/blob/master/Charts.md 

Código: https://github.com/aprendiendonodered/ejercicio10

Vídeos:

  • Primera parte:
  • Segunda parte:
  • Tercera parte:
  • Cuarta parte:
  • Quinta parte:
  • Sexta parte: