Monitorizar temperatura, humedad y otros valores en unA RED LOCAL

MATERIAL NECESARIO

SOFTWARE UTILIZADO

Resultado sobre cómo quedaría la monitorización de cada una de las placas ESP8266 con sus respectivos sensores.

1- PREPARAR LA RASPBERRY PI

Lo primero es instalar un sistema operativo en la Raspberry. Esto es obvio y, además, al adquirirla, vendrá con una tarjeta micro SD con su sistema operativo instalado. Si no, 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. Así que, a partir de la Raspberry 3B+ hacia modelos superiores no debe de haber ningún problema en cuanto al rendimiento y conectividad.

En cualquier caso, si no se tuviera, o se quisiera instalar en otra tarjeta micro SD por aquello de hacer experimentos con gaseosa, el lugar para encontrar el software y cómo instalarlo es: https://www.raspberrypi.com/software/

Raspberry Pi 2 B(fuente: Wikipedia)
Raspberry Pi 4 B(fuente: Wikipedia)
Raspberry Pi 3 B+(fuente: Wikipedia)
Raspberry Pi 5(fuente: Wikipedia)

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.

Escritorio en Raspbian(fuente: Wikipedia)

1.1- INSTALAR MQTT EN LA RASPBERRY

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:

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:

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:


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 y humedad DHT11 (o cualquier otro sensor que instalemos).

VÍDEO DE TODO EL PROCESO EN TIEMPO REAL

INSTALACIÓN MQTT.mp4

1.2- INSTALAR NODE RED EN LA RASPBERRY

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

INSTALACIÓN NODE-RED.mp4

La Raspberry ya está lista. Ahora toca preparar las placas ESP8266 con sus sensores.

2- PREPARAR LA PLACA ESP8266 CON EL SENSOR DHT11 Y CON EL BME280

Realmente para este proyecto podría valer cualquier placa programable en Arduino con Wifi. Las que yo he empleado son las NodeMCU ESP8266 porque vienen con varios puertos digitales y uno analógico a los que se pueden conectar varios sensores.

Por otro lado, el sensor que estoy utilizando es el DHT11 que da medidas de temperatura y humedad. Es un sensor barato y fácil de configurar. También está disponible el DHT22 de mayor exactitud y algo más caro. No hay diferencia en la conexión entre la placa ESP8266 y el DHT11 o DHT22. La única diferencia es que habría que indicarlo en el código de programación en Arduino. Simplemente, en la parte de código donde corresponda:

#define DHTTYPE DHT11 

#define DHTTYPE DHT22

El sensor BME280 es completamente diferente. Además de dar mediciones sobre temperatura y humedad, también mide la presión atmosférica.

2.1- ESP8266 + DHT11 (o DHT22)

Placa ESP8266 NodeMCU
Sensor DHT11
Sensor DHT22

La conexión entre el ESP8266 y el sensor DHT11 o DHT22 debería ser esta:

Si el sensor es del DHT22 la conexión sería igual, aunque hay que prestar atención a los pines de sensor ya que no se encuentran en la misma disposición que en el DHT11.

2.2- ESP8266 + BME280

Placa ESP8266 NodeMCU
Sensor BME280

La conexión entre el ESP8266 y el sensor BME280 debería ser esta:

2.3- CONFIGURAR EL ESP8266 PARA COMUNICAR DATOS A LA RASPBERRY PI

2.3.1 - CONFIGURACIÓN ESP8266 + DHT11

A partir de aquí lo único que queda es subir el programa para que la ESP8266 mande los datos de humedad y temperatura del sensor DHT11 teniendo en cuenta varias cosas.

Programa en Arduino para el sensor DHT11

#include "DHT.h"

#include "PubSubClient.h" // Conecta y publica al broker MQTT de la Raspberry


// Código for the ESP8266

#include "ESP8266WiFi.h"  // Habilita que el ESP8266 se conecta a la red local vía WiFi

#define DHTPIN D4 // Pin conectado al sensor DHT


#define DHTTYPE DHT11

DHT dht(DHTPIN, DHTTYPE);


// 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/aula01/humidity";

const char* temperature_topic = "/instituto/aula01/temperature";

const char* mqtt_username = "pepitoperez"; // MQTT usuario

const char* mqtt_password = "pelaez19"; // MQTT contraseña

const char* clientID = " "; // ID del cliente MQTT


// Inicia la red WiFi y el MQTT como cliente

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);

 dht.begin();

}


void loop() {

 connect_MQTT();

 Serial.setTimeout(2000);


 float h = dht.readHumidity();

 float t = dht.readTemperature();


 // Muetra los datos en el monitor de Serie

 Serial.print("Humedad: ");

 Serial.print(h);

 Serial.println(" %");

 Serial.print("Temperatura: ");

 Serial.print(t);

 Serial.println(" *C");


 // MQTT solamente puede trasmitir cadenas alfanuméricas

 String hs="Hum: "+String((float)h)+" % ";

 String ts="Temp: "+String((float)t)+" C ";


 // Publica en el Broker MQTT (topic = Temperatura, 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 = Humedad, 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());

 }


 client.disconnect();  // desconecta del broker MQTT

 delay(1000*60);       // recoger nuevos valores cada minuto

}

2.3.2 - CONFIGURACIÓN ESP8266 + BME280

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/despacho/humidity";

const char* temperature_topic = "/instituto/despacho/temperature";

const char* pressure_topic = "/instituto/despacho/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

}

3- CONFIGURAR NODE RED

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.22:1880 .

3.1 CONFIGURAR DEL DASHBOARD DE NODE RED

3.1.1 INSTALACIÓN DEL DASHBOARD

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 al gestor de paletas y buscar el nodo llamado Dashboard.

3.1.2. AGREGAR NODOS

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:

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 DHT11 conectado a la placa ESP8266 situada en el aula 1 del instituto. 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.


Ahora toca conectar la placa situada en en el aula 1 y que registra los datos de temperatura y humedad. 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 aula 1. 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/aula01/humidity

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.

El espacio de trabajo quedaría, tras las respectivas configuraciones, tal que así:

Después de un rato añadiendo y configurando los diferentes nodos con los diferentes topics de todos los sensores y sus respectivas ubicaciones, tendríamos este resultado final:

4. CONSEJOS PARA EL ACABADO FINAL

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

En cuanto a la placa con el sensor DHT11, DHT22 o BME280 he creado con una impresora 3D una pequeña cajita en la que todo se encuentra bien recogido. La placa ESP8266 con el sensor lleva una serie de cables que pueden ser muy incómodos. Para el diseño de estos, y otros, modelos 3D para impresora recomiendo Tinkercad donde, además, se pueden hacer simulaciones de montajes con diferentes placas y sensores.

El resultado final de mi idea de caja para contener la placa y el sensor sería el siguiente:

5. CUESTIONES POR RESOLVER

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.