Archivo de la etiqueta: Práctica

Ejercicio Avanzado LTE-M con Arduino MKR1500

1 respuesta

Experimento avanzado: sobre la base del experimento básico, conectar una entrada digital para mandar órdenes remotas (pulsador) y dos salidas digitales (leds rojo y Amarillo) para recibir órdenes remotas en base a unas alarmas, mediante una plataforma IoT propia diseñada y programada con Node-RED.

De forma más avanzada usando una plataforma IoT desarrollada con Node-RED, permite más acciones y personalización, así como publicar los datos en una web pública accesible.

Se capturarán los datos de los sensores de temperatura, humedad e iluminación y se almacenarán en una Base de Datos InfluxDB: https://aprendiendonodered.com:8086

El stream de datos se analizará en tiempo real y se generarán unas alertas cuando se superen los siguientes umbrales:

  • Temperatura > 22 ºC
  • Iluminación < 500

Se programará la lógica, de forma que cuando la iluminación sea baja, se encenderá el led amarillo y cuando la temperatura sea alta se encenderá el led rojo, según los umbrales definidos anteriormente.

Además se mostrarán en el dashboard de la plataforma IoT desarrollada por los alumnos los siguientes datos:

  • Gauge y gráfica últimos 30 minutos temperatura
  • Gauge y gráfica últimos 30 minutos humedad
  • Gauge y gráfica últimos 30 minutos iluminación
  • Estado de los leds
  • Contador con el número de veces que se pulsa el pulsador y un reset de contador.
  • Estado del dispositivo
  • Un switch para encender y apagar el led integrado

Ejemplo de ejercicio IoT con redes 5G, usando Arduino MKR1500 que tiene conectividad LTE-M.

Para el curso, usaremos esta tarjeta IoT https://1nce.com/en-us/1nce-connect que tiene activado para España tanto LTE-M como NB-IoT. Es imprescindible que cada alumno que asista al curso tenga una tarjeta de este tipo. Es posible comprar esta tarjeta en https://shop.1nce.com/portal/shop/ y tarda aprox. 5 días en llegar.

Repositorio: https://github.com/jecrespo/fundamentos-iot-5g 

Cargar el código: https://github.com/jecrespo/fundamentos-iot-5g/blob/main/Experimento-Avanzado-NodeRED/Experimeto-Basico-MQTT.ino

Repositorio Node-RED: https://github.com/aprendiendonodered/EJERCICIO33_IOT_5G 

Material para la práctica:

  • 1x Arduino MKR NB 1500
  • 1x tarjeta micro-sim de operador con red LTE-M con datos habilitados.
  • 1 Breadboard/protoboard 400 points
  • Un kit de 20 cables jumpers macho/macho
  • Un sensor de temperatura DHT-22 o ds18b20 o Temperature sensor [TMP36]
  • 1 Photoresistor [VT90N2 LDR]
  • 2 LEDs (red)
  • 1 Pushbutton
  • 5 Resistors 220 Ohms
  • 1 Resistor 10 KOhms

Alternativamente puede usarse uno de estos kits de Arduino:

Esquema de conexión:

Ejemplo de código de Node-RED:

El interfaz diseñado debe ser similar a este:

Guardar en la BBDD influxdb https://aprendiendonodered.com:8086 todo lo que se publique en cursomqtt/<ID_DISPOSITIVO>/# poniendo la tag del topic.

Ejercicio Básico LTE-M con Arduino MKR1500

Deja un comentario

Experimento básico 5G: Conexión a red LTE-M mediante un Arduino MKR NB 1500 y envío de al menos dos parámetros ambientales de sensores conectados, mediante API REST y MQTT a la plataforma https://thingspeak.com/, configuración de un dashboard y almacenado de datos históricos.

Ejemplo de ejercicio IoT con redes 5G, usando Arduino MKR1500 que tiene conectividad LTE-M.

Para el curso, usaremos esta tarjeta IoT https://1nce.com/en-us/1nce-connect que tiene activado para España tanto LTE-M como NB-IoT. Es imprescindible que cada alumno que asista al curso tenga una tarjeta de este tipo. Es posible comprar esta tarjeta en https://shop.1nce.com/portal/shop/ y tarda aprox. 5 días en llegar.

Repositorio: https://github.com/jecrespo/fundamentos-iot-5g 

Material para la práctica:

  • 1x Arduino MKR NB 1500
  • 1x tarjeta micro-sim de operador con red LTE-M con datos habilitados.
  • 1 Breadboard/protoboard 400 points
  • Un kit de 20 cables jumpers macho/macho
  • Un sensor de temperatura DHT-22 o ds18b20 o Temperature sensor [TMP36]
  • 1 Photoresistor [VT90N2 LDR]
  • 2 LEDs (red)
  • 1 Pushbutton
  • 5 Resistors 220 Ohms
  • 1 Resistor 10 KOhms

Alternativamente puede usarse uno de estos kits de Arduino:

Esquema de conexión:

Abrirse una cuenta gratuita en https://thingspeak.com/

Usaremos Arduino MKR NB 1500 que tiene conectividad LTE-M. La práctica tiene como objetivo que los alumnos puedan observar una experiencia con conectividad, «subir» datos y observarlos en un  dashboard y luego con esos datos activar por ejemplo una alarma (que representaría encendiendo un led).

Tareas previas en la plataforma https://thingspeak.com/

  • Abrirse una cuenta gratuita en https://thingspeak.com/
  • Crear un nuevo Canal llamado “curso_iot”
  • En Channel Settings, apuntar el el Channel ID
  • En Channel Settings, crear 3 fields: Temperatura, Humedad e Iluminación
  • En Api Keys, apuntar el Write API Key

Cargar el programa: https://github.com/jecrespo/fundamentos-iot-5g/blob/main/Experimeto-Basico-ThingSpeak/Experimeto-Basico-ThingSpeak.ino 

Instalar la librería de ThingSpeak en Arduino: https://www.arduinolibraries.info/libraries/thing-speak 

Más información:

Si el uso de este código da error -301, significa que no responde el servidor, en ese caso usar conexión MQTT.

Cargar el código: https://github.com/jecrespo/fundamentos-iot-5g/blob/main/Experimeto-Basico-MQTT/Experimeto-Basico-MQTT.ino 

Comprobar con MQTT Explorer: 

  • cursomqtt/<ID_DISPOSITIVO>/status – Estado del dispositivo (OK conectado. KO desconectado)
  • cursomqtt/<ID_DISPOSITIVO>/temperatura – Temperatura del sensor DHT22
  • cursomqtt/<ID_DISPOSITIVO>/humedad – Humedad del sensor DHT22
  • cursomqtt/<ID_DISPOSITIVO>/iluminación – Iluminación del sensor LDR
  • cursomqtt/<ID_DISPOSITIVO>/pulsador – un mensaje por cada vez que se pulsa 

Interactúa con los leds publicando ON/OFF en estos topics:

  • cursomqtt/<ID_DISPOSITIVO>/ledbuiltin
  • cursomqtt/<ID_DISPOSITIVO>/ledrojo
  • cursomqtt/<ID_DISPOSITIVO>/ledamarillo

Adicionalmente, interactuar con el experimento usando el protocolo MQTT y la app https://www.iot-onoff.com/ 

Instalar la app: https://play.google.com/store/apps/details?id=goliath.mobile.device.iotonoff

En configuración en la sección “Broker Server”, poner los datos del broker MQTT que estamos usando y comprobar que conecta correctamente.

Crear un dashboard con los siguientes elementos asociados a los topics:

  • Un value con nombre “temperatura” y suscrito al topic cursomqtt/<ID_DISPOSITIVO>/temperatura – para visualizar la temperatura del sensor DHT22
  • Un value con nombre “humedad” y suscrito al topic cursomqtt/<ID_DISPOSITIVO>/humedad – para visualizar la humedad del sensor DHT22
  • Un graph con nombre “iluminacion” y suscrito al topic cursomqtt/<ID_DISPOSITIVO>/iluminacion – para seguir la ilumincación del sensor LDR
  • Un switch con nombre “led rojo” que publique ON y OFF y esté suscrito al topic cursomqtt/<ID_DISPOSITIVO>/ledrojo – para controlar el estado del led rojo
  • Un switch con nombre “led amarillo” que publique ON y OFF y esté suscrito al topic cursomqtt/<ID_DISPOSITIVO>/ledamarillo – para controlar el estado del led amarillo
  • Un led con nombre “estado” que esté suscrito al topic cursomqtt/<ID_DISPOSITIVO>/status y muestre en rojo si recibe un OFF y verde si recibe un ON
  • Un texto con nombre “pulsador” que esté suscrito al topic cursomqtt/<ID_DISPOSITIVO>/status y muestre por texto cada vez que se pulse el pulsador. 

El Dashboard quedará como:

Finalmente comprobar que puedes interactuar con la maqueta desde el móvil.

Paso a Paso: Instalar y Configurar Raspberry Pi OS

6 respuestas

Paso 1: Instalación de Raspberry Pi OS con Raspberry Pi Imager

Descargar Raspberry Pi Imager: https://www.raspberrypi.org/software/

Instalar Raspberry Pi Imager y conectar un lector de tarjetas SD. Coloque la tarjeta SD que usará con su Raspberry Pi en el lector y ejecute Raspberry Pi Imager.

Seleccionar Raspberry Pi OS (64-bit) y la SD card.

Pulsar en la rueda dentada y configurar:

  • Hostname
  • Habilitar SSH
  • Configurar el usuario y contraseña (usuario pi por defecto)
  • Configurar la wifi (WLAN country: ES)
  • Configurar locales (Europe/Madrid y keyboard: es)

Paso 2: Encontrar la IP de Raspberry Pi

Una vez instalado, habrá que localizar la IP de nuestra Raspberry Pi para conectarnos a ella.

Si en nuestra red funciona mDNS, será tan sencillo como lanzar el comando desde un PC en la misma red de Raspberry Pi: ping {nombre-hostname}.local

Si este método no funciona, revisar este tutorial de como encontrar tu IP: https://www.raspberrypi.com/documentation/computers/remote-access.html#ip-address, revisando el router, usando el comando nmap (escanear redes) u otro software de escaneo de redes.

Si nada de eso funciona, conectar a la Raspberry Pi un monitor y un teclado y ejecutar el comando ifconfig.

Paso 3: Conectar por SSH y Configurar la Conexión en PuTTY o similar

Una vez tenemos la IP de nuestra Raspberry Pi, podemos conectarnos por SSH: https://www.raspberrypi.com/documentation/computers/remote-access.html#secure-shell-from-linux-or-mac-os

Usar el comando: ssh pi@<IP>

Puede usar SSH para conectarse a su Raspberry Pi desde Windows 10 que usa la actualización de octubre de 2018 o posterior sin tener que usar clientes de terceros.

Conectar mediante SSH en Windows 10: ssh -l pi 192.168.6.xx

En caso de no funcionar, instalar en windows PuTTY: https://www.putty.org/ 

Paso 4: Actualizar Raspberry Pi

Conectarse por SSH con el usuario por defecto: pi y la contraseña por defecto: raspberry o la contraseña configurada.

Lo primero una vez nos conectemos es actualizar el sistema con:

  • sudo apt update
  • sudo apt upgrade

Paso 5: Activar VNC

Una vez dentro de la consola habilitar VNC (ya viene preinstalado) para conectarse al escritorio y continuar con la instalación desde el escritorio remoto: https://www.raspberrypi.com/documentation/computers/remote-access.html#enabling-the-vnc-server

  • ejecutar: sudo raspi-config
  • Navegar hasta Interfacing Options
  • Buscar y seleccionar VNC › Yes.

Paso 6: Instalar VNC Viewer y conectarse Raspberry Pi

Ahora ya nos podremos conectar por VNC desde nuestro ordenador.

Descargar e instalar VNC Viewer y conectarse a Raspberry Pi.

Descargar en https://www.realvnc.com/es/connect/download/viewer/ 

Darse de alta en https://www.realvnc.com/es/connect/ para acceder por VNC sin estar conectado a la misma red que la Raspberry Pi.

Configurar el acceso remoto en Raspberry Pi en el icono de VNC server e introducir el usuario y contraseña de realvnc.com creada anteriormente.

Paso 7: Acabar de configurar Raspberry Pi

Es posible hacer más configuraciones desde “Configuración de  Raspberry Pi” o desde comando “sudo raspi-config”:

Como se ha configurado desde el menú avanzado de Raspberry Pi Imager, muchas de las configuraciones ya estarán realizadas. 

Entrar en Raspberry Pi Configuration y acabar de configurar nuestra Raspberry Pi. Si se han seguido todos los pasos, solo será necesario el idioma y pedirá reiniciar la Raspberry Pi. También configurar la resolución de VNC si fuera necesario.

Paso 8: Configurar Acceso Remoto a Raspberry Pi con Remote.it

Darse de alta y crear una cuenta en https://remote.it/ 

Para Raspberry Pi usar el device package, es el método más sencillo: https://docs.remote.it/software/device-package 

Instalar la Desktop Application https://remote.it/download/ o usar la versión web https://beta.remote.it/ 

Añadir un nuevo dispositivo Raspberry Pi:

Ejecutar el comando en Raspberry Pi.

Una vez instalado, aparecerá el dispositivo en nuestra cuenta de remote.it

Documentación instalación: https://docs.remote.it/software/device-package/installation 

Ahora ya podremos conectarnos por SSH desde cualquier red, activando la conexión y siguiendo las instrucciones de conexión.

Paso 9: Configurar Acceso Remoto a Raspberry Pi con Zero Tier

Darse de alta y crear un usuario en https://www.zerotier.com/ 

Crear una red y obtener el identificador de la red https://zerotier.atlassian.net/wiki/spaces/SD/pages/8454145/Getting+Started+with+ZeroTier 

Instalar en Raspberry Pi el cliente de Zero Tier

https://www.zerotier.com/download/. Ejecutar el comando curl -s https://install.zerotier.com | sudo bash

Y luego unirse a la red con: sudo zerotier-cli join [network-id] with [device-id]

Si hemos creado una red privada, autorizar el dispositivo ponerle un nombre (p.e. el hostname)

Para saber en la Raspberry Pi el id del dispositivo, ejecutar el comando: sudo zerotier-cli info

Para ver la ruta añadida en nuestro dispositivo ejecutar: route -n

Para ver la red a la que está conectado nuestra Raspberry Pi, ejecutar: sudo zerotier-cli listnetworks

Comprobar que funciona, instalar Zero Tier en nuestro ordenador el cliente https://www.zerotier.com/download/ y conectar a la red creada.

Luego comprobar que conecta por SSH al dispositivo.

Ejercicios Finales Node-RED

1 respuesta

Ejercicio 1

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

Ejercicio 2 – Seguridad

Poner un pin para encender los Reles, de forma que si no hay pin no se puede encender desde el dashboard. Simular una cerradura de forma que al poner el pin correcto se abre y luego a los 5 segundos se cierra.

Mostar en el dashboard el estado de la cerradura.

Crear un tab nuevo en el dashboard llamado pin de seguridad

Basarse en el flujo:

Hacer el flujo como un subflow.

Dashboard

Flujo

Subflow

Código:

Ejercicio 3 – Email y SMS

Hacer un formulario en el dashboard para mandar un correo electrónico y otro para mandar un SMS usando el servicio de Twilio: https://www.twilio.com/

Dashboard

Flujo

Código: https://github.com/jecrespo/Curso-Node-RED/blob/master/04-Ejercicio%20Final/Ejercicio_4/Ejercicio_4.json

Luego usar esta configuración para enviar un correo y un SMS cuando se pulse el botón de la Raspberry Pi y el relé del nodo remoto 14 esté encendido, viéndolo en un dashboard.

Ejercicio 4 – Predicción de Lluvia con datos AEMET

Hacer un panel de control que muestre la predicción de lluvia de los próximos 7 días de una ciudad usando los datos de AEMET y su API.

Solución: https://github.com/aprendiendonodered/AEMET_Prediccion_Dias

Además mostrar la predicción de temperatura de los próximos 5 días usado el nodo de open weather map https://flows.nodered.org/node/node-red-node-openweathermap 

Por último publicar todos los datos por MQTT con el topic: “educantabria/nodo00/santander/predicción/[lluvia/santander]/{dia}/{hora}”

Topics publicados:

  • casa/santander/prediccion/lluvia/{dia} – Publica la predicción de lluvia de santander obtenida de AEMET
  • casa/santander/prediccion/temperatura/{dia}/{hora} – Publica la predicción de temperatura de santander obtenida de Open Weather

Ejercicios Subflows y Funciones Node-RED

2 respuestas

Ejercicio 01

Hacer un dashboard para controlar los wemos D1 Mini con el firmware instalado en el curso: https://aprendiendoarduino.wordpress.com/2021/02/20/mqtt-y-esp8266/

El Dashboard tendrá:

  • Un gauge y una gráfica indicando la temperatura de la sonda DS18B20
  • Un pulsador para encender y apagar el led del Wemos D1 Mini
  • Un pulsador para encender y apagar el relé
  • Un Input text o un formulario para mandar mensajes a la pantalla oled
  • Un slider para encender los 8 niveles de la matriz led.

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

Flujo:

Dashboard:

Ejercicio 2

Configura Node-RED para que se vea un dashboard “Home” con tres grupos:

  • Suscripciones: las 3 suscripciones y botón que resete los valores
  • Pulsadores: dos botones para encender led y relé de nodo remoto
  • RPi: un pulsador que maneje el LED de la RPi y un gauge con el estado del pulsador.

Además al pulsar el pulsador encender el led detectando flaco, una pulsación enciende y otra pulsación apaga.

La configuración en Node-RED es:

https://github.com/jecrespo/Curso-Node-RED/blob/master/04-Ejercicio%20Final/Ejercicio_1/Dashboard_1.png?raw=true

Código: https://github.com/jecrespo/Curso-Node-RED/blob/master/04-Ejercicio%20Final/Ejercicio_1/Ejercicio_1-1.json

Código: https://github.com/jecrespo/Curso-Node-RED/blob/master/04-Ejercicio%20Final/Ejercicio_1/Ejercicio_1-2.json

Ejercicio 03

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 

Ejercicio 04

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