ÍNDICE
Este proyecto está en evolución y ha sido desarrollado en el IES Tierrablanca (La Zarza, Badajoz). Lo que se presenta aquí es el estado actual del mismo. Esta basado en otro descrito en esta web (Monitorizar temperatura y humedad de un centro) por lo que muchas partes que aquí se desarrollan también se encuentran en el anterior.
Todo el software utilizado en el proyecto es software libre.
Básicamente consiste en disponer de un emisor de señales que transmita los datos de los sensores a una especie de servidor, que será el encargado de recoger los datos y mostrarlos. El sistema pueda manejar los datos procedentes de varios emisores de señal, por lo que se puede instalar un sensor para el exterior, otro para el pluviómetro, otro a modo de veleta u otros en el interior del centro mostrando los datos de varias estancias, como la sala de profesores, biblioteca o pabellón deportivo.
El módulo para temperatura, presión y humedad está desarrollado al 100%, aunque hacen falta realizar algunas mejoras relativas a su alimentación eléctrica y ubicación en el centro.
El módulo de pluviómetro está prácticamente terminado aunque aún no se ha puesto en funcionamiento. En este caso quedarían por resolver asuntos como el aislamiento, la alimentación eléctrica y, en menor medida, la ubicación.
MATERIAL NECESARIO
Raspberry Pi (en mi caso se trata del modelo 3B+ o 2B)
Placas ESP8266
Sensor BME280 (para medir temperatura, humedad y presión atmosférica)
Relé reed (KY-025)
Imán de pequeño tamaño
Cables para protoboard hembra-hembra
Cables para conexión USB-micro USB
Cargadores de enchufe con conexión micro USB
Impresora 3D
Opcionalmente:
Placa solar pequeña
Baterias o pilas de litio recargables
Placa TP4056, módulo de cargador para baterías de litio
SOFTWARE UTILIZADO
Raspbian
Mqtt
Node-Red
Arduino IDE
¿Por qué una Raspberry?
La respuesta es su bajo consumo energético. Si queremos un dispositivo que esté funcionando 24 horas al día, nos interesa que no consuma mucha electricidad. Realmente se podría utilizar cualquier ordenador con Linux instalado, pero la ventaja de la Raspberry son su precio y su bajo consumo energético.
Para empezar, lo primero es instalar un sistema operativo en la Raspberry. Normalmente al adquirirla, vendrá con una tarjeta micro SD con su sistema operativo instalado, pero si no fuera así, se puede comprar una tarjeta micro SD e instalar el sistema operativo según las instrucciones de este enlace de la propia compañía.
Personalmente he probado este proyecto con dos modelos, el modelo 2 B y el modelo 3 B+. El problema para el modelo 2 es que no tiene conexión WiFi, solo por Ethernet. Así que, a partir de la Raspberry 3B+ hacia modelos superiores no debe de haber ningún problema en cuanto al rendimiento y conectividad inalámbrica.
Dentro de todos los sistemas operativos disponibles para Raspberry estaríamos hablando de una distribución linux especial, basada en Debian, llamada Raspberry Pi OS (anteriormente Raspbian). Así que estaríamos desenvolviéndonos como en cualquier otro ordenador con linux, dentro de las limitaciones (y ventajas) lógicas que posee un dispositivo como una Raspberry.
De todas la versiones oficiales de Raspberry Pi OS aconsejo la más austera pero quizás la más complicada de manejar que es la no tiene interfaz gráfica y solo la consola de comandos
Lo primero que hay que hacer siempre en cualquier sistema Linux antes de hacer una configuración o instalación importante es actualizar el sistema:
sudo apt-get update
¿Qué es MQTT?
Se trata de protocolo de comunicación entre dispositivos muy popular por su facilidad de uso y porque resulta muy útil para el IoT (Intenet of the Things, - el internet de la cosas -). MQTT significa en inglés Message Queuing Telemetry Transport, y también se le conoce como mosquitto, que es su comando en la consola. Es un sistema de comunicación perfectamente compatible para microcontroladores como el ESP8266, el ESP32 y la Raspberry Pi.
¿CÓMO FUNCIONA?
Simplificando el sistema de comunicación MQTT contiene 3 componentes con unas funciones específicas:
Publisher (Publicador) que genera y manda los datos al broker. Por ejemplo, podría ser una una estación meteorológica en una placa ESP8266 con un sensor configurado con Arduino, y que manda los datos de la temperatura y la humedad con una frecuencia de tiempo que nosotros queramos. Cada minuto por ejemplo.
Broker (Agente) que es como un servidor que recoge los mensajes de todos los publicadores (publishers), los guarda y los distribuye a los respectivos suscriptores.
Subscriber (Suscriptor) es un component que se suscribe a cierto tipo de mensajes procedentes de los publicadores (publishers). En nuestro caso podría ser un monitor o un panel que muestra las diferentes temperaturas y humedades de un lugar; datos que proceden de diferentes placas ESP8266 con sus respectivos sensores, en nuestro caso el BME280.
Si queremos enviar datos vía MQTT tenemos que definir algunas variables y configuraciones que se van a relacionar con el publisher, el broker y el subscriber.
Por ejemplo, vamos a usar el ESP8266 como publisher. El broker MQTT va a ser la Raspberry Pi, ya que tiene más capacidad en todos los sentidos (memoria, velocidad, salida de vídeo y conectividad con teclado y ratón). En las Raspberry elegimos Mosquitto como el software MQTT para el broker y también para el subscriber.
La primer configuración es la IP del broker MQTT. Por descontado la IP de este broker MQTT es la misma IP de la Raspberry en la red local.
INSTALACIÓN
Para instalar MQTT broker:
sudo apt-get install mosquitto
En algunas ocasiones, después de cada orden habrá que aceptar para continuar, como ocurre en este caso y se puede ver en esta imagen:
Instalar la línea de comandos:
sudo apt-get install mosquitto-clients -y
Después de la instalación del MQTT broker tenemos que realizar algunos cambios en la configuración. Hay dos diferentes configuraciones de control para controlar Mosquitto:
/etc/mosquitto/mosquitto.conf (configuración por defecto)
/etc/mosquitto/conf.d (extensión a la configuración por defecto)
En nuestro proyecto vamos a usar el archivo de la configuración por defecto. Así que vamos a abrir el archivo con el editor de texto nano con el siguiente comando:
sudo nano /etc/mosquitto/mosquitto.conf
Y aparecerá la configuración por defecto tras la instalación de Mosquitto:
Ahí hay cuatro cosas que hay que cambiar:
El broker debe incluir solamente la configuración por defecto. Esto se hace comentando la línea donde se incluye el archivo conf.d . Es decir, añadiendo # a la línea que pone include_dir /etc/mosquitto/conf.d
No queremos que usuarios anónimos o no autorizados se conecten al broker MQTT por tanto añadimos: allow_anonymous false
Además queremos poner contraseña para la comunicación de los dispositivos con su su broker. Estas contraseñas las vamos a guardar en un archivo por separado, por lo que añadimos: password_file /etc/mosquitto/pwfile
El canal de comunicación MQTT estará accesible en el puerto 1883, por lo que añadimos: listener 1883
Debería quedar así:
Para cerrar y guardar damos a CTRL+X, y luego Y para confirma que queremos guardar el archivo con las modificaciones que hemos realizado. Finalmente pulsar INTRO para guardar el archivo.
Ahora hay que configurar el nombre de usuario y la contraseña para que los publishers (editores de información) y los subscribers (los suscriptores de esa información) tengan acceso al broker de MQTT.
Para crear un nuevo usuario y contraseña:
sudo mosquitto_passwd -c /etc/mosquitto/pwfile pepitoperez
Se entiende que por pepitoperez tenemos el nombre de usuario, que podría ser cualquier otro. A continuación el sistema nos pide que tecleemos la contraseña (que la Raspberry almacenará aunque no estemos viendo escrita en la consola). También nos pedirá que la reescribamos a modo de confirmación.
Para este ejemplo tendremos:
Nombre de usuario: pepitoperez
Contraseña: pelaez19
En el caso de que queramos borrar un usuario existente podemos usar el siguiente comando:
sudo mosquitto_passwd -d /etc/mosquitto/pwfile username
Una vez realizadas estas configuraciones, es hora de comenzar. Para ello resulta conveniente conocer qué opciones tenemos para comenzar y parar.
Iniciar broker MQTT
sudo systemctl start mosquitto
Detener broker MQTT
sudo systemctl stop mosquitto
Reiniciar broker MQTT
sudo systemctl restart mosquitto
Iniciar automáticamente broker MQTT en el inicio de la Raspberry
sudo systemctl enable mosquitto
Por ahora la Raspberry está preparada para recibir datos que, en nuestro proyecto, procederán de una placa NodeMCU ESP8266 con un sensor de temperatura, humedad y presión BME280 (o cualquier otro sensor que instalemos).
VÍDEO DE TODO EL PROCESO EN TIEMPO REAL
¿QUÉ ES?
Para recibir y visualizar los datos procedentes de un publisher en el broker de la Raspberry no es necesario tener instalado Node Red, pero es a través de ese software con el que vamos a visualizar de una manera muy sencilla y vistosa los datos recibidos por cada uno de los publisher configurados en nuestra red local.
Se trata de un motor que permite definir gráficamente relaciones entre cada una de las partes que intervienen en varios protocolos estándares de comunicación y, además, mostrarlos gráficamente.
INSTALACIÓN
La instalación de Node-RED es sencilla y se realiza ejecutando la siguiente línea de comando:
bash <(curl -sL https://raw.githubusercontent.com/node-red/linux-installers/master/deb/update-nodejs-and-nodered)
La instalación tardará unos 10-20 minutos y tendrá la siguiente apariencia:
En los pasos finales del proceso de instalación tendremos que decidir respecto a varias cuestiones. La primera es respecto a creación de un archivo de configuración de Node-RED. Ahí no hay más que darle a INTRO. Pero la segunda y más importante es respecto a la seguridad, en la que habrá que configurar un nombre de usuario y una contraseña para poder editar los flows de Node-RED:
A continuación se pregunta sobre otorgar permisos totales a ese usuario, o sobre si crear otro usuario.
El resto de las cuestiones se pueden responder con las opciones que ya aparecen señaladas por defecto.
Una vez instalado una buena idea sería tener en cuenta los siguientes comandos:
Iniciar el servicio
node-red-start
Detiene el servicio
node-red-stop
Detiene y reinicia el servicio de Node-RED
node-red-restart
Muestra la salida de registro del servicio
node-red-log
Quizás lo más importantes, por comodidad serían:
Que Node-RED se ejecute automáticamente cuando la Raspberry se encienda o reinicie
sudo systemctl enable nodered.service
Y deshabilitar el inicio automático
sudo systemctl disable nodered.service
Por fin, si ponemos en la barra de direcciones de nuestro navegador http://IP_DE_LA_RASPBERRY:1880/ entraremos en la configuración de los nodos de Node-RED. Obviamente, donde he puesto IP_DE_LA_RASPBERRY me refiero literalmente a eso, a poner la dirección IP en la red local de nuestro dispositivo, por ejemplo 192.168.1.40
La primera vez que entramos con nuestro navegador nos pedirá el nombre de usuario y contraseña que hemos consignado en la instalación de Node-RED.
VÍDEO DEL PROCESO DE INSTALACIÓN
La Raspberry ya está lista. Ahora toca preparar las placas ESP8266 con sus sensores.
El sensor BME280 es muy completo y de gran precisión. Además de dar mediciones sobre temperatura y humedad, también mide la presión atmosférica.
La conexión entre el ESP8266 y el sensor BME280 debería ser esta:
Cable rojo desde el pin VIN del sensor hacia uno de los pines de alimentación que ofrece la placa
Cable negro desde el pin GND hacia uno de los pines de tierra GND de la placa
El pin SCL del sensor se conecta al pin D1 de la placa
El pin SDA del sensor se conecta al pin D2 de la placa
Una vez realizadas las conexiones físicas como se describe en el apartado anterior, hay que programar la placa. Esto se hace mediante el IDE de Arduino. Se trata de un programa en el que se realiza la programación con lenguaje arduino, lo compila y lo sube a la placa.
Este código se muestra en el desplegable de abajo. Para adaptarlo a vuestro proyecto lo único que tendríais que cambiar sería:
Nombre y contraseña de la red Wi-Fi a la que os estéis conectando
IP del broker MQTT, es decir, la de la Raspberry en la red local a la que os estéis conectando
El usuario y contraseña de MQTT que hayáis configurado cuando se instaló MQTT en la Raspberry
Los topics en los que queráis clasificar vuestros datos de humedad, temperatura y presión
Programa en Arduino para sensor BME280
#include <Wire.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_BME280.h>
#include "PubSubClient.h" // Conecta y publica al broker MQTT de la Raspberry
#define SEALEVELPRESSURE_HPA (1013.25)
// Código para ESP8266
#include "ESP8266WiFi.h" // Habilita que el ESP8266 se conecta a la red local vía WiFi
Adafruit_BME280 bme;
// WiFi
const char* ssid = "NOMBRE_DE_LA_RED_WIFI"; // El nombre SSID de tu red Wifi
const char* wifi_password = "CONTRASEÑA_DE_LA_RED_WIFI"; // La contraseña de tu Wifi
// MQTT
const char* mqtt_server = "192.168.1.55"; // IP del broker MQTT, es decir, la de la Raspberry
// Para saber la IP en hay que ejecutar este comando en la
// consola de la Raspberry: # ifconfig
// o bien: # hostname -I
const char* humidity_topic = "/instituto/exterior/humidity";
const char* temperature_topic = "/instituto/exterior/temperature";
const char* pressure_topic = "/instituto/exterior/pressure";
const char* mqtt_username = "pepitoperez"; // MQTT usuario
const char* mqtt_password = "pelaez19"; // MQTT contraseña
const char* clientID = " "; // ID del cliente MQTT
// Initialise the WiFi and MQTT Client objects
WiFiClient wifiClient;
// 1883 es el puerto abierto para recibir noticias del Broker
PubSubClient client(mqtt_server, 1883, wifiClient);
// Función para conectar al Broker MQTT vía WiFi
void connect_MQTT(){
Serial.print("Conectando a");
Serial.println(ssid);
// Conectar a la WiFi
WiFi.begin(ssid, wifi_password);
// Espera hasta que la conexión se haya confirmado antes de continuar
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
// Depuración - Muestra la dirección IP de la placa ESP8266
Serial.println("WiFi conectado");
Serial.print("Dirección IP: ");
Serial.println(WiFi.localIP());
// Conectar al Broker MQTT
// client.connect devuelve un valor booleano para indicarnos si la conexión se realizó con éxito.
// Si la conexión falla, hay que asegurarse de que se está usando los nombres de usuario y contraseñas
// correctas en el MQTT
if (client.connect(clientID, mqtt_username, mqtt_password)) {
Serial.println("¡Conectado al Broker MQTT!");
}
else {
Serial.println("¡La conexión al Broker MQTT falló!");
}
}
void setup() {
Serial.begin(9600);
bme.begin(0x76);
}
void loop() {
connect_MQTT();
Serial.setTimeout(2000);
float h = bme.readHumidity();
float t = bme.readTemperature();
float p = (bme.readPressure() / 100.0F);
//Muestra los datos en el monitor de Serie
Serial.print("Humedad: ");
Serial.print(h);
Serial.println(" %");
Serial.print("Temperatura: ");
Serial.print(t);
Serial.println(" *C");
Serial.print("Presión: ");
Serial.print(p);
Serial.println(" hPa");
// MQTT solamente puede trasmitir cadenas alfanuméricas
String hs="Hum: "+String((float)h)+" % ";
String ts="Temp: "+String((float)t)+" C ";
String ps="Pres: "+String((float)p)+" hPa ";
// Publica en el Broker MQTT (topic = Temperature, definido al inicio)
if (client.publish(temperature_topic, String(t).c_str())) {
Serial.println("¡Temperatura enviada!");
}
// De nuevo, client.publish devolverá un valor booleano dependiendo de si tuvo éxito o no.
// Si el mensaje falló al ser enviado, se intentará de nuevo.
else {
Serial.println("El envío de la temperatura falló. Reconectando al Broker MQTT para intentarlo de nuevo.");
client.connect(clientID, mqtt_username, mqtt_password);
delay(10); // Este retraso asegura que client.publish no se cuelgue con la llamada a client.connect
client.publish(temperature_topic, String(t).c_str());
}
// Publica en el Broker MQTT (topic = Humidity, definido al inicio)
if (client.publish(humidity_topic, String(h).c_str())) {
Serial.println("¡Humedad enviada!");
}
// De nuevo, client.publish devolverá un valor booleano dependiendo de si tuvo éxito o no.
// Si el mensaje falló al ser enviado, se intentará de nuevo.
else {
Serial.println("El envío de la humedad falló. Reconectando al Broker MQTT para intentarlo de nuevo.");
client.connect(clientID, mqtt_username, mqtt_password);
delay(10); // Este retraso asegura que client.publish no se cuelgue con la llamada a client.connect
client.publish(humidity_topic, String(h).c_str());
}
// Publica en el Broker MQTT (topic = Pressure, definido al inicio)
if (client.publish(pressure_topic, String(p).c_str())) {
Serial.println("¡Presión enviada!");
}
// De nuevo, client.publish devolverá un valor booleano dependiendo de si tuvo éxito o no.
// Si el mensaje falló al ser enviado, se intentará de nuevo.
else {
Serial.println("El envío de la presión falló. Reconectando al Broker MQTT para intentarlo de nuevo.");
client.connect(clientID, mqtt_username, mqtt_password);
delay(10); // Este retraso asegura que client.publish no se cuelgue con la llamada a client.connect
client.publish(pressure_topic, String(p).c_str());
}
client.disconnect(); // desconecta del broker MQTT
delay(1000*60); // recoger nuevos valores cada minuto
}
Node-RED es una herramienta de programación para conectar dispositivos de hardware, API y servicios en línea de formas nuevas e interesantes. Proporciona un editor basado en navegador que facilita la conexión de flujos mediante la amplia gama de nodos de la paleta que se pueden implementar en su tiempo de ejecución con un solo clic.
Para acceder al editor, con Node-RED ejecutándose , hay que abrir el editor en un navegador web.
Si se está utilizando un navegador en la misma computadora que ejecuta Node-RED, se puede acceder a él con la url: http://localhost:1880
Si se está utilizando un navegador en otra computadora en la misma red en la que está conectada la Raspberry, se debe usar la dirección IP de la Raspberry (u ordenador) que ejecuta Node-RED: por ejemplo http://192.168.1.55:1880
Si lo que quisiéramos hacer es ver cómo se muestran los datos ya con formato y configurados, se debe usar la misma dirección IP pero con algún añadido: por ejemplo http://192.168.1.55:1880/ui
Antes de comenzar es necesario instalar un nuevo conjunto de nodos, que son los que nos van a permitir representar gráficamente los datos de humedad y temperatura. Para ello es necesario ir Administrar paleta o Manage palete y buscar el nodo llamado Dashboard.
El primer nodo que hay que configurar es el que permite la entrada de datos que están mandando las placas ESP8266 mediante el protocoloo de comunicación MQTT. Este nodo es:
Haciendo clic dos veces sobre el nodo mqtt in ya dentro del espacio de trabajo, se abre en la parte derecha un espacio para la configuración de este nodo. En esta configuración hay que indicar:
La IP del servidor de los datos (la IP de la Raspberry)
En Action dejamos la opción Subscribe to single topic
El llamado topic (asunto o tema) del que se están recibiendo los datos. Este topic ha sido previamente programado en la placa ESP8266, por ejemplo:
const char* humidity_topic = "/instituto/exterior/temperature";)
En QoS seleccionamos 2
Le podemos poner, si queremos, nombre al nodo
Finalmente, hay que hacer clic sobre un icono con forma de lápiz situado junto a la dirección IP del servidor. De la pantalla que se abre se observan tres pestañas. La que nos interesa es la de Seguridad, en la que tendremos que escribir el nombre de usuario y contraseña que pusimos anteriormente en la instalación de MQTT en la Raspberry, es decir:
usuario: pepitoperez
contraseña: pelaez19
El segundo nodo que vamos a usar es el llamado debug, que permite manejar los datos recibidos, en este caso por el mqtt in.
Este nodo, cuando se pasa al espacio central de trabajo, cambia de apariencia y de nombre llamándose ahora msg.payload. Sobre este nodo no hay que realizar ninguna configuración. Únicamente hay que unirlo con el nodo mqtt in arrastrando de uno a otro ese pequeño cuadrado gris que aparece en el extremo de cada uno de los nodos, quedando de este modo:
El nodo de debug realmente no es imprescindible para el funcionamiento del proyecto, pero nos permitirá ver qué dato está entrando a través del nodo al que está conectado y, por tanto, detectar si hay errores.
En tecer lugar vamos a añadir los nodos que nos van a permitir ver los gráficos de los datos que está recibiendo la Raspberry de los diferentes sensores. En este caso, los datos de temperatura del sensor BME280 conectado a la placa ESP8266 situada en el exterior. De entre los varios nodos gráficos que hay vamos a escoger los llamados gauge y chart.
De nuevo, para configurar ambos nodos deberemos hacer clic dos veces en cada uno de ellos.
El nodo gauge va a representar el dato de la temperatura mediante un indicador gráfico circular en el que el dato va señalado mediante una aguja. No obstante, dentro del mismo nodo, se puede seleccionar qué tipo de gráfico disponibles ofrece.
El nodo chart va a representar un gráfico en el que se ve la evolución en el tiempo de los datos recibidos. Por ejemplo un gráfico lineal en el que está recogida la temperatura de las últimas 24 horas. También tiene otras opciones disponibles.
Para los dos nodos existe la posibilidad de personalizar los colores y más.
La configuración de ambos nodos que yo he usado es la que se puede ver a continuación:
El siguiente paso, una vez ya configurados los nodos, es unirlos como aparece en la imagen inferior:
Para que todos los cambios que hemos efectuado en el espacio de trabajo de node red comiencen a funcionar deberemos hacer clic, en la esquina superior derecha, a un botón rojo llamado Deploy o Instanciar en la versión en castellano. Este botón permanece apagado o en gris si no se realizan cambios. Solamente se activa, mostrándose de color rojo, cuando se ha realizado alguna modificación. Una vez instanciados los cambios, esos puntos azules, que aparecen sobre el extremo de cada nodo, desaparecerán.
Ahora toca conectar la placa situada en exterior y que registra los datos de temperatura, humedad y presión. Cuando esta placa tenga corriente estará mandando, cada 60 segundos, los datos del sensor. Si está encendida desde tiempo antes no importa, simplemente habrá estado intentando comunicar los datos sin que nadie le estuviera escuchando (digitalmente hablando, por supuesto)
Si todo va bien, la Raspberry estará recibiendo los datos de la placa ESP8266 situada en el exterior. Por ahora, solamente vamos a ver el de la temperatura. Para ver la humedad tendremos que repetir los pasos anteriores pero, en esta ocasión, con el topic /instituto/exterior/humidity, y con la presión atmosférica igualmente
Para poder ver el dashboard (la consola gráfica) de los datos tendríamos que poner la ip de la Raspberry con el puerto 1800 y /ui/. Por ejemplo así: http://192.168.1.55:1880/ui/
Para la representación gráfica de la humedad, yo opté por la opción de level en el tipo de gráfico.
Para la representación de la presión atmosférica, en esta ocasión de me decanté por el nodo de texto, aunque cualquiera de los anteriores podría haber servido. Simplemente cuestión de gustos:
El espacio de trabajo quedaría, tras las respectivas configuraciones para todos los datos, tal que así:
Para quedar constancia del valor máximo y mínimo de temperatura registrados en 24 horas,hay que utilizar un nodo específico de función. Esta función comprueba si los datos que están llegando del sensor de temperatura son más altos o más bajos que los anteriores. En el caso de que sea así, bien por arriba o por abajo, almacena este dato. Si ningún otro dato es superior o inferior a los almacenados tenemos, por tanto, los valores máximo y mínimos.
El nodo de función quedaría colocado de la siguiente manera:
Al hacer doble clic sobre el nodo de función, hay que configurarlo con el siguiente código:
Código para el nodo función para el registro de las temperaturas máxima y mínima
// Obtener la temperatura actual del mensaje.
var exttemp = msg.payload;
// Validar que exttemp sea un número válido.
if (isNaN(exttemp)) {
return { error: "exttemp is not a valid number" };
}
// Guardar la temperatura actual en el contexto de flujo.
flow.set("temperaturaexterior", exttemp);
// Obtener los valores actuales de temperatura máxima y mínima.
var maxexttemp = flow.get("maxexttemp");
var minexttemp = flow.get("minexttemp");
// Inicializar maxTemp y minTemp si no están definidos.
if (maxexttemp === undefined || maxexttemp === null) {
maxexttemp = exttemp;
flow.set("maxexttemp", maxexttemp);
}
if (minexttemp === undefined || minexttemp === null) {
minexttemp = exttemp;
flow.set("minexttemp", minexttemp);
}
// Actualizar los valores máximo y mínimo si es necesario.
if (exttemp > maxexttemp) {
maxexttemp = exttemp;
flow.set("maxexttemp", maxexttemp);
}
if (exttemp < minexttemp) {
minexttemp = exttemp;
flow.set("minexttemp", minexttemp);
}
// Preparar el mensaje de salida.
msg.payload = {
"maxexttemp": maxexttemp,
"minexttemp": minexttemp
};
return msg;
Para mostrar esos datos con el nodo de texto, hay que extraerlos de la función proporcionando la ruta exacta en la que se encuentran. Es decir, si el paquete de datos en su totalidad normalmente es msg.payload ahora hay que extraer de ese paquete el dato que nos interese, que ahora se encuentra, según la función que hemos descrito antes, en msg.payload.maxexttemp para el caso de la temperatura máxima registrada.
Para mayor claridad, abajo hay dos capturas de pantalla, una de cómo tendría que ser el nodo de texto para mostra la temperatura máxima y otro para la temperatura mínima:
Como ejemplo sencillo para mostrar estos datos básicos y prescindiendo de las gráficas podríamos tener un flow con estos nodos:
Lo que podría mostrar los datos de la siguiente manera:
Existen varios proveedores y compañías que permiten subir los datos del llamado "Internet de las Cosas" (IoT) a sus servicios. De este modo se ecuentra ThingSpeak, Thinger.io y otras alternativas más complejas.
Pero una forma relativamente sencilla y absolutamente barata de subir periódicamente los datos a una hoja de cálculo es en la que se simula la entrada de datos a un formulario de Google (Google Form). En este vídeos se explican todos los pasos:
Los pasos descritos en el vídeo consisten en los siguiente:
Crear un formulario en Google Drive con una entrada para la temperatura máxima y otra para la temperatura mínima. Esto es personalizable. Si hay alguna otra variable que se quiera subir, se añade igualmente.
En el menú de opciones del formulario hay una que se llama Rellenar previamente el formulario. Una ver abierta esta pestaña, completar el formulario con unos datos ficticios. Y finalmente hacer clic sobre el botón Obtener enlace que vamos a copiar.
Este enlace lo vamos a pegar en un editor de texto plano para modificarlo más tarde.
General la hoja de cálculo vinculada al formulario.
Publicar el formulario con permisos para que cualquier persona pueda responder al formulario. No son los permisos de edición sino permisos como encuestado.
Dentro del control de nodos en Node-Red hay que añadir y unir uno a uno los nodos de marca de tiempo (timestamp), función (function), solicitud http (http request) y debug.
Configurar el nodo de tiempo (o timestamp según el idioma del Node-Red) para que se inyecten los datos a las 23:59 de cada. Por supuesto, esta opción es completamente personalizable al momento del día y frecuencia que queramos.
Configurar el nodo de función para recoger los datos de las temperaturas máxima y mínima que se van a subir a la hoja de cálculo. Estos datos ya están volcados en unas variables cuando se configuró el nodo de función para mostrar en pantalla las temperaturas máxima y mínima. Lo que hacemos ahora es recuperar los datos de esas variables para poder inyectarlas a la hoja de cálculo.
Este código viene a ser este:
var data = {}
data.maxima = flow.get("maxexttemp")
data.minima = flow.get("minexttemp")
msg.payload = data
return msg;
Modificar el enlace pegado en el editor de texto plano. En este punto hay que prestar especial atención a los cambios que hay que realizar. Se trataría de sustituir donde pone viewform por formResponse; localizar el dato que se escribió cuando se hizo el Rellenar previamente el formulario en la entrada para temperatura máxima. En el caso del vídeo es un 35 y hay que sustituirlo por la expresión {{payload.maxima}}. Lo mismo para la temperatura mínima y sustituirlo por la expresión {{payload.minima}}.
Es decir, hay que transformar esto:
https://docs.google.com/forms/d/e/1FAIpQLSfmMahCvxGjGUXGdfmvvCcBbQoWi2svl-IDHx1M3dBrXE8pKQ/viewform?usp=pp_url&entry.1140533589=35&entry.926628126=10
... en esto:
https://docs.google.com/forms/d/e/1FAIpQLSfmMahCvxGjGUXGdfmvvCcBbQoWi2svl-IDHx1M3dBrXE8pKQ/formResponse?usp=pp_url&entry.1140533589={{payload.maxima}}&entry.926628126={{payload.minima}}
Copiar esta url ya modificada. Abrir el nodo http request / solicitud http y pegar lo que hemos copiado donde pone 🌎URL.
Instanciar todo los cambios que hemos hecho.
Finalmente, para comprobar que funciona sin necesidad de esperar a las 23:59, solamente habría que hacer clic en el cuadro izquierdo que aparece en el nodo de tiempo / timestamp. De este modo se inyectarían los datos a la hoja de cálculo vinculada con el formulario, donde se podrían ver la marca temporal, la temperatura máxima y la temperatura mínima.
Por otro lado o ideal sería la obtención de valores máximos y mínimos durante 24 horas, y ya pasado este tiempo, habría que desechar estos datos. Esto se consigue con un nodo que se llama Inject y que es fácil de localizar porque está el primero de la lista en lado izquierdo.
Este nodo permite realizar una acción, la que sea, en un momento determinado. En este caso, lo que queremos es anular el valor de las variables que recogen las temperaturas máxima y mínima con un sencillo código. Así, el conjunto de nodos quedaría así:
La configuración del nodo Inject para que active una acción a las 00:00 es la siguiente:
Y el código que contiene el nodo de función es bien sencillo:
El módulo del pluviómetro está aún en proceso de desarrollo. El mecanismo funciona pero aún no se le ha implementado el programa para que suba los datos a servidor de la Raspberry y también faltan por resolver la alimentación y el aislamiento del agua cuando esté a la intemperie.
El módulo vendría a ser así:
El funcionamiento del módulo consiste en un balancín sobre el que cae el agua por el agujero del embudo que cubre toda la parte superior del módulo. Al llenarse de agua una parte del balacín, este se inclinaría hacia el otro lado, evacuando el agua y exponiendo el otro lado al llenado del agua procedente de la precipitación. Este balancín tendría un pequeño imán adherido de manera que, al balancearse de un lado para otro un relé reed, que es realmente un detector de campos magnéticos, detectaría este movimiento. Este relé estaría ubicado tras una pequeña pared que mantendría aislado a todos los circuitos de la humedad, y aún así detectaría el cambio de campo magnético provocado por el paso del imán. Por tanto, ahora solamente queda calcular el contenido del agua que recoge el balancín, antes de inclinarse por su peso hacia el otro lado, y ponerlo en relación con la superficie del embudo para obtener una estimación de la precipitación caída.
El relé o interruptor reed que he utilizado es el KY-025, aunque se puede utililzar cualquier placa o bien un montaje con el relé y montar su cableado y resistencia a parte.
La conexión entre las placas ESP8266 y KY-025 se podrían realizar de dos maneras: bien a través del puerto digital o de un puerto analógico. Yo he elegido conectarlo a través del puerto analógico tal y como viene en el diagrama de abajo.
La diferencia entre la conexión analógica y la digital es que la primera ofrece valores de detección de campo magnético entre 0 y 1000 aproximadamente, y la segunda ofrece valores de 1 ó 0. Para regular la sensibilidad en el caso de optar por el puerto digital, hay un pequeño tornillo dorado insertado en un pequeño saliente de color azul. Si lo giramos podremos obtener valores 1 ó 0 cuando haya más o menos intensidad del campo magnético.
En mi caso, he optado por el puerto analógico. El siguiente código en Arduino es un ejemplo de cómo funciona el sensor KY-025, marcando el paso del imán cuando el balancín oscila por el peso del agua. A día de hoy, por desgracia, aún no tengo el código para hacerlo funcionar con mqqt en el sistema Node-Red de la Rasbperry:
#include <Wire.h>
int balancin = 0;
void setup() {
Serial.begin(9600);
}
void loop() {
int sensorValue = analogRead(A0);
// Serial.println(sensorValue);
if(sensorValue < 100)
{
delay(500);
++balancin;
Serial.println(balancin);
}
delay(50);
}
Traducido, cuando el relé reed detecta un campo magnético y devuelve un valor superior a 100, entonces se entiende que ha pasado el balancín, avanzando el contador.
El conjunto del módulo consta de:
Una caja que recubre el conjunto
Una tapa superior con forma de embudo para recoger la precipitación
Una tapa interna para proteger y aislar la electrónica de la humedad
El balancín y una pequeña barra para que oscile por el peso del agua hacia un lado y a otro
Un pequeño imán
El funcionamiento se puede ver en el siguiente vídeo en el que, con una animación, se ve cómo están montadas las piezas y cómo, con la oscilación del balancín, el imán adherido transmite con su campo magnético el movimiento de descarga de agua del balancín. La placa KY-025 detecta ese paso del imán. Para calcular el agua precipitada únicamente habría que realizar los cálculos correspondientes a la superficie que abarca el embudo y el agua que el balancín desaloja en cada oscilación.
En cuanto a la Raspberry sería conveniente, dado que va a estar funcionando las 24 horas del día, dotarle de una caja con ventilador para disipar el calor. No es una máquina que genere mucho calor puesto que no tiene unos procesadores potentes pero cuanto más moderna sea la Raspberry más potente será y, por tanto, más calor generará.
Tal y como está descrito, estaría listo para funcionar, por ejemplo, en una red doméstica.
La cuestión es cómo hacer para conectar los dispositivos a una red corporativa. En el caso de Extremadura, los centros educativos disponemos de una eficaz red wifi administrada por el Servicio de Tecnologías Educativas y cuyo acceso está controlado.
Antes de nada, la MAC de la tarjeta ESP8266 deberá estar dada de alta o registrada en la red Educarex mediante el Servicio de Tecnologías Educativas. Para esta labor nos puede ayudar el informático de nuestro centro. En cuanto a la conexión a internet, la manera en la que he podido conseguir hacer funcionar este proyecto es mediante la red oculta Educarex_DEV y con una contraseña que el administrador informático del centro custodia.
Por otro lado, a día de hoy [julio de 2025] faltaría completar el desarrollo de los siguientes elementos:
En cuanto al sensor de temperatura, humedad y presión:
La alimentación mediante baterías de litio cargadas por una placa solar pequeña.
Que la ubicación proporcione unas mediciones homologables, al tiempo que está lo suficientemente cerca de algún edificio para logar cobertura de red inalámbrica.
En cuanto el pluviómetro:
La programación en arduino de la placa que transmita los datos a la Raspberry Pi que actúa de servidor.
La alimentación.
El aislamiento de la humedad de los componentes electrónicos.
Una ubicación, algún que en el caso anterior, que proporcione unas mediciones homologables, al tiempo que está lo suficientemente cerca de algún edificio para logar cobertura de red inalámbrica.
En cuanto al anenómetro y la veleta:
Aún no se ha iniciado el desarrollo de destos sensores, aunque aventuramos que el de la veleta no resultará complicado.