Calificación:
  • 0 voto(s) - 0 Media
  • 1
  • 2
  • 3
  • 4
  • 5
[SpainLabsIoT2018] Empezamos - Servidor MQTT
#1
resim


Seguimos con el primer capitulo del Mini curso de IoT que vamos a tratar de desarrollar desde la comunidad de SpainLabs. Como comentamos en post anteriores, vamos a implementar una red de sensores a nivel de hogar, es decir, nuestra red de sensores va a estar dentro de nuestra propia casa, con algún nodo en el exterior pero a una distancia corta. Por tanto, nuestros nodos van a estar separados de nuestro equipo receptor a escasos metros. Dado que queremos hacer una aplicación sencilla, y que introduzca el mundo IoT, vamos a elegir como módulo de comunicación uno Wifi. Podíamos haber elegido trabajar a 2,4Ghz usando por ejemplo el famoso nrf24L01, pero necesitamos aplicar una capa mas de software. No obstante, queda esa opción presente para quien quiera hacerla. Si alguien se anima, y quiere explicarla, añadiremos el contenido.

Tendremos pues una serie de nodos basados en un módulo wifi, que sera el ESP8266. Un módulo ultra conocido, barato y fiable, del cual existe una gran comunidad detrás. Nuestros nodos, que vamos a diseñarlos nosotros mismos, enviaran la información cada X tiempo a nuestra Raspberry. Ella sera la encargada de recopilar, almacenar y ofrecer en un dashboard la información. Presentando la estructura de forma simple, y que ademas nos va a marcar un poco los capítulos del mini curso, quedara similar a esto:

Nodo+sensores -> Transmite usando el protocolo MQTT -> Raspberry (en modo AP) -> servidor MQTT -> Pasarela de software (Telegraf) -> Base de Datos InfluxDB -> Dashboard ( Grafana)

Como veis, hay una serie de etapas o bloques, cada uno independiente, pero interconectados entre ellos para transmitir, procesar o representar gráficamente los datos. Podéis deducir cuales van a ser los diferentes temas que vamos a presentar a lo largo de las próximas semanas. Lo comentare brevemente.

Nuestro Nodo+Sensor(es): Este sera nuestro hardware que vamos a diseñar. Ya estamos en ello, con la primera versión del proto en camino. Publicaremos en su momento los archivos para que podáis replicarlo. Tendremos un hardware basado en ESP8266, que programaremos usando el IDE Atom mas una capa que es un gran proyecto, PlatformIO. Usaremos el framework de Arduino, de manera que programaremos nuestro hardware como si de un arduino se tratase. Mola no?

Nuestro siguiente bloque es el protocolo MQTT, el que vamos a tratar en este capitulo. Abordaremos lo que es el protocolo y la instalación de un servidor privado de MQTT en nuestra Raspberry.

Desde aquí, todo el software que vamos a comentar se instalara también en la Raspberry. Nuestra Raspberry la configuraremos para que haga también de Punto de Acceso. Esto se debe a que asi no sobrecargamos nuestro router de casa, que son bien conocidos por no aguantar muchas conexiones activas.

Entre nuestro servidor de MQTT y nuestra gran base de datos vamos a necesitar un software que recopile la info. Existen multitud de opciones y scripts que cogen los datos del servidor MQTT y los indexan en la base de datos. Nosotros vamos a usar parte del paquete que ha creado InfluxDB. En este caso, se llama Telegraf. Lo comentaremos cuando abordemos el bloque de base de datos. Solamente añadir que InfluxDB es una base de datos no secuencial, diseñada para trabajar con series de datos temporales. Nos viene como anillo al dedo. Es OpenSource y ademas es la mejor en su campo, con diferencia. Su competidor mas cercano seria MongoDB.

Por ultimo, vamos a querer ver nuestros datos representados, vamos a querer hacer algo. Construiremos nuestro dashboard con la herramienta Grafana, que también pertenece al grupo InfluxDB.

Con este ultimo capitulo, cerraremos lo que es el curso. No es nada pequeño, hay mucho por ver. Cualquier cosa que veáis interesante profundizar, aprovechar para comentarlo. Esperamos que tenga aceptación y podamos hacer mas  cursillos a modo de tutoriales. Animaros a participar y desarrollar por vosotros mismos las alternativas que se proponen, complementaran el contenido aquí expuesto.


Vamos a empezar con la teoría sobre el protocolo MQTT. Posteriormente, empezaremos con la instalación del software y concluiremos esta parte.

El blogger Ricardo Vega nos explica que es, y nos presenta unos ejemplos. Explica muy bien el MQTT, así que os copio y pego su contenido Podéis profundizar mas en el enlace: https://ricveal.com/blog/primeros-pasos-mqtt/

MQTT son las siglas de Message Queue Telemetry Transport y tras ellas se encuentra un protocolo ideado por IBM y liberado para que cualquiera podamos usarlo enfocado a la conectividad Machine-to-Machine (M2M). Está enfocado al envío de datos en aplicaciones donde se requiere muy poco ancho de banda. Además, sus características le permiten presumir de tener un consumo realmente bajo así como precisar de muy pocos recursos para su funcionamiento. Estas características han hecho que rápidamente se convierta en un protocolo muy empleado en la comunicación de sensores y, consecuentemente, dentro del Internet de las Cosas.

Arquitectura MQTT

En cuanto a su arquitectura, sigue una topología en estrella, donde existe un nodo central o broker con capacidad para trabajar con un gran número de clientes. Es precisamente el broker el elemento encargado de gestionar la red y transmitir los mensajes. Una caracterísitica interesante es la capacidad de MQTT para establecer comunicaciones cifradas lo que aporta a nuestra red una capa extra de seguridad.

resim

Dentro de la arquitectura de MQTT, es muy importante el concepto "topic" o "tema" en español ya que a través de estos "topics" se articula la comunicación puesto que emisores y receptores deben estar subscritos a un "topic" común para poder entablar la comunicación. Este concepto es prácticamente el mismo que se emplea en colas, donde existen un publicadores (que publican o emiten información) y unos subscritores (que reciben dicha información) siempre que ambas partes estén subscritas a la misma cola. Este tipo de arquitecturas, lleva asociada otra interesante característica: la comunicación puede ser de uno a uno o de uno a muchos.

Además, los "topics" tienen una estructura jerárquica gracias a la cual podemos establecer relaciones padre-hijo y, al subscribirnos a un topic padre, recibir también la información de sus hijos. Como un ejemplo vale más que mil palabras, si tenemos una arquitectura como la del siguiente diagrama:

resim

Si estamos subscritos a Salón, recibiremos toda la información que recolecten Arduino1 y Arduino2.

El autor muestra una pequeña prueba de concepto usando el servidor MQTT Mosquitto. Que sera el que nosotros montaremos en nuestra Raspberry.

Uso 0 de MQTT

En lo que resta de post, voy a realizar una pequeña prueba de concepto (PoC) sobre MQTT. Para ello, vamos a hacer de uno de los brokers más conocidos que existen para MQTT: Mosquitto. Mosquitto es un broker OpenSource ampliamente utilizado debido a su ligereza lo que nos permite, fácilmente, emplearlo en gran número de ambientes, incluso si éstos son de pocos recursos. A través de esta página puedes descargar y seguir los pasos de instalación según cual sea tu sistema operativo.

Nota: En nuestro mini curso vamos a hacer la instalación en la Raspberry, que mas adelante se explica. Aquí disponéis de info para poder instalar el servidor en varias plataformas.


Una vez que tenemos instalado Mosquito, podemos proceder a crear nuestro primer emisor y subscriptor siguiendo para ello una jerarquía que podría asemejarse a la empleada en una aplicación real (en este caso, una vivienda).
Antes de nada, voy precisamente a definir esta estructura:

resim

Dentro de esta estructura, nuestros únicos "emisores" son los sensores de luz y presencia que hemos colocadao en la Hab1, Hab2 y Cocina. Cada uno de ellos, lo vamos a asignar a un topic propio quedando el listado de topics de la siguiente forma:
  • Hab1
  • Luz: casa/habitaciones/hab1/luz
  • Presencia: casa/habitaciones/hab1/presencia
  • Hab2
  • Luz: casa/habitaciones/hab2/luz
  • Presencia: casa/habitaciones/hab2/presencia
  • Cocina
  • Luz: casa/cocina/luz
  • Presencia: casa/cocina/presencia
Para ver como funciona el protocolo, vamos a subscribirnos a tres topics:
  • casa/habitaciones/hab1/luz
  • casa/habitaciones/#
  • casa/#
El '#' del final es semejante al asterisco y hace las veces de comodín por lo que todos sus hijos deberían ser escuchados bajo esa cola.

Cada uno de los comandos que escriba ahora, debería ir en una terminal / consola diferente. Por otra parte, dependiendo de tu sistema operativo puede que tengas que arrancar el servidor de Mosquitto de forma manual, en mi caso (OSX) esta operación la realicé mediante el siguiente comando:

Código:
/usr/local/sbin/mosquitto -c /usr/local/etc/mosquitto/mosquitto.conf

Empezamos por los subscriptores:

Código:
mosquitto_sub -t "casa/habitaciones/hab1/luz" -v
mosquitto_sub -t "casa/habitaciones/#" -v
mosquitto_sub -t "casa/#" -v

Y ahora empezamos a publicar mensajes desde alguno de los nodos que definimos antes. Concretamente, voy a lanzar comandos que simulen los siguientes casos:
  • encendido luz Hab1
  • encendido luz Hab2
  • encendido presencia cocina
Código:
mosquitto_pub -t "casa/habitaciones/hab1/luz" -m "ON"
mosquitto_pub -t "casa/habitaciones/hab2/luz" -m "ON"
mosquitto_pub -t "casa/cocina/presencia" -m "ON"

Como observarás, el "encendido luz Hab1" es detectado por todos nuestros subscriptores, el "encendido luz Hab2" es detectado por el subscritor general y el subscritor a las habitaciones y, por último, el "encendido presencia cocina" sólo es detectado por el subscriptor general ya que el sensor no forma parte del árbol gerárquico de habitaciones (ni lógicamente hab1).

Hasta aquí, la introducción al protocolo y un pequeño ejemplo práctico de como funciona. Podéis seguir leyendo mas sobre el protocolo. Con la teoría de esta entrada vista, vamos a pasar a empezar a montar nuestro sistema. Comencemos!

Primer paso, preparar nuestra Raspberry!

1. Iniciando la Raspberry

Empezamos a montar nuestro pequeño sistema, encargado de recepcionar toda la info y/o gestionarla. Todo nuestro sistema estará montado en una Raspberry Pi 3. La cual lleva ya wifi integrado, entre otras cosas. Por tanto, vamos a instalar una imagen de Raspbian. Podemos usar la ultima que se ha publicado.

Procederemos a descargar la imagen desde: https://www.raspberrypi.org/downloads/raspbian/
Nota: No necesitáis bajar la versión con escritorio.
Nota 2: Si alguien no tiene claro como instalar la imagen, es su primera vez, etc. Puede seguir los pasos aquí: https://www.raspberrypi.org/documentatio.../README.md

Acordaros de activar el SSH. Lo podéis hacer creando un archivo en la raiz de la SD, donde habéis instalado previamente la imagen, llamado SSH. De esta forma activareis nada mas arrancar este servicio, que por defecto no viene activado. Esto nos ayuda a no tener que conectar una pantalla y teclado para los primeros pasos de configuración. Así que podremos entrar a la Raspberry vía SSH usando un programa como Putty para windows, o desde la consola directamente en caso de Linux.

Antes de empezar a instalar nada, acordaros de ejecutar el comando siguiente para tener actualizados los repositorios.

Código:
sudo apt update

Una vez que hemos accedido a nuestra Rasp, vamos a instalar lo necesario para que nos haga de AP (Acces Point). En su día subí una pequeña guía con un script que lo hace todo solo. Así que os pongo el enlace, y siguiendo los pasos, podréis hacer de forma muy sencilla todo el proceso. Es muy rápido y sencillo. Aquí tenéis el post donde se comenta: https://www.spainlabs.com/foros/tema-APO...t-y-WebGUI

Ya tenemos lo necesario para proceder a instalar nuestro servidor MQTT.

2. Instalación de MQTT - Instalación de Mosquitto.

Vamos a instalar nuestro cliente/servidor MQTT desde el repositorio de Raspberry. Para ello ejecutaremos los siguientes comandos:

Código:
sudo apt -y install mosquitto mosquitto-clients

Nosotros no vamos a habilitar un usuario/contraseña al servidor, pero se puede hacer. Necesitaríais realizar los siguientes pasos:


Tenemos que editar el archivo: /etc/mosquitto/conf.d/auth.conf.

Podemos hacerlo con el comando:

Código:
sudo nano  /etc/mosquitto/conf.d/auth.conf.

O si os gusta mas usar el editor vi, el comando quedaría:

Código:
sudo vi /etc/mosquitto/conf.d/auth.conf.

Dentro del archivo, buscamos las siguientes lineas y las editamos para que queden así:

Código:
allow_anonymous false
password_file /etc/mosquitto/passwd

Tras editar el archivo, necesitamos crear un usuario y pass en nuestro servidor MQTT. Para ello ejecutaríamos el siguiente comando:

Código:
sudo mosquitto_passwd -c /etc/mosquitto/passwd arduino

Y para finalizar, reiniciaríamos el servicio para que se carguen los últimos cambios realizados. Ejecutamos para ello:

Código:
sudo service mosquitto reload

Ya lo tendríamos. Recordamos que vamos a usar la conexión anónima, de forma que estos pasos no son necesarios. Los comentamos para que sepáis que se puede hacer. Por ultimo, comprobamos que nuestro servidor MQTT funciona. Para ello vamos a necesitar dos terminales, es decir, dos conexiones independientes a la Raspberry, o lo que es lo mismo, conectarnos dos veces desde distintos terminales. En uno de ellos haremos la subscripción a un post del servidor MQTT, y desde el otro, le enviaremos información, la cual nos aparecerá en el primer terminal. Los pasos son los siguientes:

Código:
# Shell en el terminal 1[/align]
[align=justify]mosquitto_sub -h localhost -t test -u "arduino" -P "arduino"[/align]
[align=justify]# Shell en el terminal 2[/align]
[align=justify]mosquitto_pub -h localhost -t "test" -m "hello world" -u "arduino" -P "arduino"

3. Finalizando.

Hasta aquí llega este capitulo, donde hemos introducido el curso y hemos visto el primer punto. Hemos expuesto lo que es el protocolo MQTT, el cual es muy utilizado en el mundo del IoT, incluso en el mundo de Arduino para los proyectos Maker. Además, hemos realizado los primeros pasos de configuración en nuestra Raspberry, incluyendo la instalación del servidor MQTT Mosquitto, que sera nuestro broker.

Existen servidores públicos de MQTT. En un post anterior, comente una aplicación sencilla sobre como usar uno de ellos. Os facilito el enlace por si queréis echar un vistazo, os lo recomiendo. https://www.spainlabs.com/foros/tema-Gui...ME280-MQTT

Y esto es todo. Gracias por vuestra atención, nos vemos en unas semanas con la siguiente entrega.

Saludos!

Citar
#2
Muy bueno grafisoft, te animo a que sigas con este tema tan interesante y de actualidad.
Citar
#3
(19-01-2018, 04:52 AM)s118 escribió: Muy bueno grafisoft, te animo a que sigas con este tema tan interesante y de actualidad.

Gracias Sonrisa
Citar
#4
Muy buena explicación, espero que haya más post como este.
Citar
#5
Gracias por el currazo que te has pegado.
Citar
#6
resim
Citar
#7
impresionante!, gracias por tan gran explicación, esperamos poder continuar con este tema.
gracias.
Citar


Temas similares...
Tema Autor Respuestas Vistas Último mensaje
  [Guia] ESP8266 (NodeMCU) + sensor BME280 + MQTT grafisoft 17 3,682 09-10-2018, 09:49 PM
Último mensaje: grafisoft
  [SpainLabsIoT2018] Caso real: Nodos ESP8266 grafisoft 38 4,343 03-08-2018, 11:45 PM
Último mensaje: grafisoft
  [SpainLabsIoT2018] InfluxDB + Telegraf grafisoft 7 1,586 25-07-2018, 03:42 PM
Último mensaje: grafisoft
  [SpainLabsIoT2018] Nodo ESP8266 - Smart Sensors Shield grafisoft 16 1,844 02-07-2018, 08:55 PM
Último mensaje: grafisoft
  APORTE [SpainLabsIoT2018] ESP8266 NodeMCU - Ajustando su consumo (hack) grafisoft 4 936 15-06-2018, 06:47 AM
Último mensaje: grafisoft