Archivo de la categoría: Programación Node-RED

Material Curso Node Red

Material y servicios usados en el curso.

Instancia Node-RED:

  • 1 PC o Portátil con conexión a Internet.
  • Una Raspberry Pi conectada a Internet y con la última versión de Raspberry Pi OS instalada.
  • Una cuenta en github o bitbucket.

Las Raspberry Pis se usarán como instancias de Node-RED y nodos centrales a los que se conectan los nodos remotos, por lo que no conectaremos sensores/actuadores/periféricos a las Raspberry Pi.

Nodos Remotos:

  • 1x Wemos D1 min o NodeMCU o equivalente (M5Stick)
  • 1x shields para wemos D1 mini relé o equivalente
  • 1x shields para wemos D1 mini neopixel o equivalente
  • 1x shields para wemos D1 mini oled o equivalente
  • 1x Cable USB para programar Wemos

Datasheet wemos y shields:

Los shields son «plug and play» sobre los wemos D1 mini que usaremos como nodos remotos, lo que facilita el montaje y uso.

El firmware para los nodos remotos:

Todo el software y documentación utilizado en el curso es libre con licencia creative commons o similar.

Broker MQTT. Mosquitto

Se usará un broker común para comunicar todos los dispositivos en la dirección: mqtts://enriquecrespo.com:8883

Los alumnos recibirán usuario y contraseña para acceder al broker con permisos de lectura y escritura en nodereddeveloper/#

Servicios

Base de datos MySQL en https://enriquecrespo.com/phpmyadmin/ donde los alumnos podrán usar para almacenar datos. Los alumnos recibirán las credenciales de acceso.

Base de datos InfluxDB en https://enriquecrespo.com:8086/ donde los alumnos podrán usar para almacenar datos. Los alumnos recibirán las credenciales de acceso.

Grafana en https://enriquecrespo.com:3000/ para representar gráficamente los datos. Los alumnos recibirán las credenciales de acceso.

Otro Hardware Usado para Interactuar

Para interactuar en el curso también disponemos de diversos HW conectados.

M5stack: https://m5stack.com/collections/m5-core/products/basic-core-iot-development-kit 

M5Stick-C con sensor ENV:

Raspberry Pi Zero: Instalada en local con cámara y programada con Node-RED, usada como dispositivo remoto.

Wibeee instalado y publicando datos.

Wibeee ONE 2W

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

Versiones Node-RED

Node red pasó a la versión 1.x en septiembre de 2019 con cambios notables, veamos los cambios introducidos en Node-RED a lo largo de sus versiones.

Versiones node-red: https://github.com/node-red/node-red/releases

Novedades Node-Red 0.20: https://programarfacil.com/blog/raspberry-pi/novedades-node-red-0-20/

Salto de la 0.x a la 1.x explica las diferencias:

Version 1.0 (30/09/2019): https://nodered.org/blog/2019/09/30/version-1-0-released

Vídeo versión 1.0: https://www.youtube.com/watch?v=nIVBZQi18fQ&feature=youtu.be 

Versión 1.1 (30/06/2020): https://nodered.org/blog/2020/06/30/version-1-1-released

Version 1.2 (15/10/2020): https://nodered.org/blog/2020/10/15/version-1-2-released

Vídeo versión 1.2: https://www.youtube.com/watch?v=rnM5sfb2qoY 

Planes de releases: https://nodered.org/blog/2020/07/01/release-plans 

Releases: https://nodered.org/about/releases/ 

Planes de futuro: https://nodered.org/blog/2020/10/13/future-plans 

Vídeo de los creadores de Node-RED hablando del estado de Node-RED: https://openjsf.org/blog/2020/05/13/nodered-ama-recap/ 

Beta version 1.3 Node-RED: https://discourse.nodered.org/t/node-red-1-3-0-beta-1-released/41960

  • change log: https://github.com/node-red/node-red/blob/15715a296862bf9603facd45bf1a7ef17623890b/CHANGELOG.md
  • Uso de de módulos npm en funciones. Al establecer functionExternalModules en verdadero en el archivo de configuración, podrá configurar sus nodos de función con una lista de módulos adicionales.
  • Ahora es posible anidar referencias a las propiedades del mensaje en los nodos change y switch. Ejemplo: set flow.rooms[msg.topic] to the value of msg.payload
  • Node-RED Plugins framework
  • Ahora es posible empaquetar un subflujo como un módulo y publicarlo en npm para instalarlo en la paleta como cualquier otro nodo.
  • El cuadro de diálogo Exportar ahora muestra una lista estructurada de lo que está exportando. El JSON sin formato aún se puede ver en una segunda pestaña del cuadro de diálogo.
  • Con esta versión, si pulsa Mayús y hace clic en el lado izquierdo del nodo, seleccionaremos todos los nodos ascendentes. Si pulsa Mayús y hace clic en el lado derecho, seleccionaremos todos los nodos de corriente abajo. Shift-clic en el centro del nodo seleccionará todo el flujo como antes.
  • Los nodos MQTT ahora son compatibles con MQTTv5 y la gran mayoría de las nuevas funciones que presenta la versión 5.

Versión 1.3 (08/04/2021): https://nodered.org/blog/2021/04/08/version-1-3-released

  • Mejorada la selección de nodos. Más información: https://github.com/node-red/node-red/pull/2877 
  • Hay un nuevo ajuste disponible que gobierna lo que puede ser instalado en Node-RED – externalModules. Esto cubre dos cosas separadas: qué nuevos nodos pueden ser instalados a través del gestor de paletas, y qué módulos pueden ser cargados por el nodo Function. Más información: https://github.com/node-red/node-red/pull/2797 
  • Los nodos MQTT ahora soportan MQTTv5 y la gran mayoría de las nuevas características que introduce v5.

Planning Node-RED 2.0: https://discourse.nodered.org/t/planning-for-node-red-2-0/41918

Presentación Curso Node-RED Developer. 2021

Título: “Curso Node-RED Developer. Nivel 1”

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 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.

Dentro del itinerario de formación para IoT/Industria 4.0, este curso profundiza de forma práctica en la programación dentro del entorno IoT/Industria 4.0/digitalización. Anteriormente se trataron muchos temas y tecnologías de forma práctica sin profundizar en ellas, para entrar ahora en la programación.

Gracias a la herramientas libres/Open Source es posible democratizar el IoT y la industria 4.0. Antes se necesitaba muchísimo dinero no solo en HW y licencias de SW, sino en consultores que hacen un diseño a medida y realizan la integración de los sistemas, ahora no solo el SW libre y el HW libre y barato, sino que la comunidad da soporte a las dudas, hace documentación y tutoriales, así como librerías para facilitar el trabajo.

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.

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

Requisitos

Para la realización de este curso es necesario tener conocimientos básicos o experiencia en algunas de estas áreas: programación, redes TCP/IP, redes inalámbricas, protocolos de comunicación, bases de datos, uso de sistemas linux, microcontroladores, autómatas, electrónica, uso de sensores, actuadores, motores, etc… 

También es recomendable nociones básicas de programación, especialmente javascript o Node.js, protocolos IoT (REST y MQTT) y servicios IoT on-line

Es recomendable un conocimiento medio de Inglés puesto que gran parte de la documentación está en Inglés.

Metodología

El curso on-line consiste en 20 horas de formación en directo, repartidas en 10 sesiones de 2 horas en horario de 18:00 a 20:00 entre el 19 y 30 de abril de 2021.

Al finalizar cada sesión de 2 horas, se propondrá un reto o ejercicio para realizar a lo largo de la duración del curso. Cada día se hará una sesión de tutoría de 1 hora de duración para ayuda, en grupos reducidos, sobre las dudas relativas a los retos o ejercicios propuestos.

La plataforma en vídeo usada será https://meet.jit.si/ y se grabarán todas las sesiones, tanto las de formación como las de tutorías para las prácticas.

Los recursos utilizados para la realización de este curso son:

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/cursos/node-red-developer-2021-nivel-i/

  • Presentación del Curso
  • Entorno On-Line de Prácticas
  • Instalación de Node-RED
  • Protocolo MQTT
  • Edge Computing
  • Configurar y securizar Node-RED
  • Node-Red en la Nube
  • Programación Node-RED
  • Nodos Node-RED
  • Dashboard Node-Red
  • Debug Node-RED
  • Funciones en Node-RED
  • Integración con Servicios de Terceros
  • Proyectos con Node-RED

Presentaciones

  • Nombre
  • ¿Has usado Node-RED?
  • ¿Aplicaciones de Node-RED?
  • ¿Hardware con el que interactuar?

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/

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: