A lo mejor eso del internet de las cosas te suena como muy lejano. Sin embargo, si ya tienes una Raspberry estás mucho mas cerca de lo que puedas pensar. Y si además se trata de una Raspberry Pi Zero, todavía estás mucho mas cerca si cabe. Y es que puedes tener el internet de las cosas en tu Raspberry.

Tengo que reconocerte, que hasta no hace mucho, a esto del internet de las cosas, no le había prestado mucha atención. Fue con la llegada de la Raspberry Pi, cuando empecé a ver algo de luz. Pero ha sido la Raspberry Pi Zero la que realmente me ha abierto los ojos, en particular la que tiene el módulo de WiFi.

Es cierto que hoy en día ya existen kits de domótica, como puede ser el de la marca Xiaomi, que te acerca mucho el internet de las cosas. Sin embargo, no es eso lo que yo quiero. A mi me gusta investigar. Ver como funcionan las cosas, crear mis propios procesos, automatizar el internet de las cosas según mis necesidades y lo que a mi me interese.

Sin lugar a dudas con un kit de domótica terminaré mucho antes, y todo funcionará a la primera. Pero no es lo que yo quiero. Quiero complicarme la vida, quiero que cuando un sensor de una puerta montado y en funcionamiento, decir, eso lo hice yo. Si, a lo mejor es algo mas barato que un kit completo. Pero sinceramente no es lo que busco.

Si quieres ver esto del internet de las cosas en tu Raspberry, escuchame durante unos 20 minutos, comienza con eso del internet de las cosas.

El internet de las cosas en tu Raspberry

Antes de meternos en faena

Artículos

Esta semana he publicado dos artículos. Uno que tiene mucho que ver con el podcast del lunes sobre como exprimir YouTube desde el terminal. Se trata de una herramienta que te permite subir tus vídeos a YouTube. La ventaja de esta herramienta, es que te permite subir los vídeos directamente desde el terminal. De esta forma, subir un vídeo se convierte en carne de automatización. Esto por lo menos es el paso que yo he añado a mi script para convertir los audios del podcast en vídeo y poder subirlos posteriormente a YouTube.

El siguiente de los artículos es el capítulo de introducción del tutorial sobre Scripts en Bash. El objetivo de este primer capítulo es el de convencerte de que tienes que aprender a realizar scripts en Bash. Por supuesto, como buen primer capítulo de introducción, harás tu primer script, un hola mundo en toda regla.

Aplicaciones

En este caso, las aplicaciones no vienen de mi mano. Todo el trabajo es de Javier. Ha estado trabajando seriamente en el sistema de monitorización para la Raspberry, del que hablé en el episodio 70 del podcast. Tengo que decir, que aunque esté sistema de monitorización está pensado para la Raspberry, lo cierto es que lo puedes utilizar para lo que tu quieras o consideres. Tanto para un VPS como tu ordenador de sobremesa. Eso si, necesitarás qu tu equipo corra con un Linux, claro.

Respecto de las mejoras introducidas por Javier, que son muchas, indicarte que básicamente lo ha estructurado en tres componentes,

• comprobación de servicios. Aquí puedes indicar los servicos que tienes instalados. De esta manera, si lo tienes instalado realizará la pertinente comprobación.
• comprobación de host. Igual que en el caso anterior, también puedes comprobar diferentes hosts, y te indicarán su estado.
• pings. Por último también puedes hacer ping a diferentes IP para asegurarte que están levantadas o no.

Por otro lado, y casi tan importante como lo primero, con estás últimas actualizaciones, ahora, la monitorización se realiza en paralelo, con un total de hasta cinco módulos en paralelo.

Realmente ha hecho un trabajo de escándalo, que te recomiendo que no te pierdas bajo ningún concepto. E insisto, no tienes porque instalarlo en tu Raspberry, también, puedes instalarlo en tu equipo de sobremesa.

Te recomiendo que si todavía no lo has probado no esperes a probarlo, por que es una auténtica pasada.

El internet de las cosas en tu Raspberry

Un poquito de historia

De acuerdo a lo que figura en la Wikipedia, el concepto de internet de las cosas fue acuñado en 1999, por Kevin Ashton, en el Auto-ID Center del MIT, donde se estaban realizando investigaciones en el campo de la identificación por radiofrecuencia.

Seguro que en algún momento te has encontrado en la situación de no saber donde dejaste las llaves o incluso el coche. Sin embargo si tanto las llaves como el coche las tienes interconectadas con el internet de las cosas, ya no te tienes que preocupar. Esto hace unos años, era inimaginable, hoy en día es una realidad. Existen productos como tile que te hace las cosas más fáciles. Y esto no es mas que la punta del iceberg de las posibilidades que te ofrece el internet de las cosas.

¿Como traer el internet de las cosas a tu Raspberry?

Teniendo varias Raspberry de cualquier tipo, la cosa la tienes mas que hecha. Aquí la que mas me gusta es la Raspberry Pi Zero con WiFi por sus características. Pero vale cualquiera de ellas.

La cuestión es que cada una de estas RPI se va a convertir en un concentrador de señales. Señales tanto internas como externas. Por un lado tienes la monitorización que está niquelando Javier. Y por otro lado, puedes añadir otros sensores y a cada uno de esas RPI.

¿Y como comunicar unas RPIs con otras para que interactúen entre ellas? Para esto vamos a utilizar un protocolo abierto de comunicación a través de mensajes. En particular el protocolo MQTT (Message Queue Telemetry Transport).

Este protocolo es del tipo cliente servidor basado en publicaciones y suscripciones. Las suscripciones y publicaciones se hacen por tópicos. De forma que si un mensaje es publicado con un determinado tópico, todos los dispositivos que estén suscritos a ese tópico recibirán el mensaje.

La ventaja de este protocolo es que es realmente ligero y simple. Requiere poco ancho de banda y no tiene un muy reducido consumo de recursos.

Los dispositivos se conectan con un dispositivo central, que en el caso del protocolo MQTT se llama Broker. Así todos los mensajes pasan por este punto central.

Los tópicos

Una de los aspectos que resultan interesantes a la hora de las suscripciones es la forma en la que están definidos los tópicos. Cada tópico se define por niveles separados por una barra inclinada /. Así por ejemplo, suponiendo que hemos puesto sensores de temperatura en varias estancias de nuestra casa, quedaría como /edificio/piso1/habitacion1/temperatura, /edificio/piso1/habitacion2/temperatura. Así si nos queremos saber la temperatura de la habitación 1 del piso 1 nos suscribiríamos a /edificio/piso1/habitacion1/temperatura.

Pero el protocolo MQTT además admite dos comodines + y #. El primero nos permite sustituir un nivel. Así, si queremos saber la temperatura de todas las habitaciones del primer piso, sería algo como /edificio/piso1/+/temperatura. El segundo de los comodines, nos permite suscribirnos a todas las publicaciones de aguas abajo. Así para conocer todas las mediciones del piso1, la suscripción tendría el suguiente aspecto /edificio/piso1/#

Y ¿como instalar MQTT en tu Raspberry?

Para instalar MQTT vas a utilizar Eclipse Mosquitto. Se trata de un broker de código abierto liberado bajo licencia EPL/EDL. Además el proyecto Mosquitto pone a tu disposición una librería en C que implementa el protocolo MQTT para clientes. Y por supuesto dos clientes para escritorio mosquitto_sub y mosquitto_pub. Además, y como no podía ser de otra forma existen implementación de Mosquitto para Python. Pero no solo Python, también lo puedes encontrar para C, C++, Java, JavaScript, Go,…

Solo pensar todas las opciones que ofrece se me hace el cerebro agua. Poder conectar la Raspberry, el móvil Android y Ubuntu con un mismo protocolo… Madre mía.

Instalando Mosquitto

Para que puedas utilizar una Raspberry como broker, tan solo tienes que instalar el paquete mosquitto y si quieres también el paquete de cliente por si quieres hacer pruebas. Así, tan solo tienes que ejecutar las siguientes instrucciones en un terminal,

sudo apt install mosquitto
sudo apt install mosquitto-clients

Una vez instalado, habilita e inicia el broquer. Para ello ejecuta estas dos instrucciones,

sudo systemctl enable mosquitto
sudo systemctl start mosquitto

Ahora vamos a otra Raspberry o incluso a tu ordenador e instala única y exclusivamente el cliente. Para ello, ejecuta la siguiente instrucción,

sudo apt install mosquitto-clients

Probando Mosquitto

Para estas pruebas te recomiendo que utilices el cliente Terminator. Esta aplicación te permite tener varios terminales ejecutándose de forma simultánea y en una misma pantalla. Así puedes iniciar varios suscriptores de forma simultánea, cada uno en unas coordenadas, y ver que es lo que sucede.

Así por ejemplo, puedes ejecutar para cada uno de los suscriptores alguna de las siguientes líneas,

mosquitto_sub -h 192.168.1.48 -p 1883 -t "/casa/p1/h1" -v
mosquitto_sub -h 192.168.1.48 -p 1883 -t "/casa/p1/h2" -v
mosquitto_sub -h 192.168.1.48 -p 1883 -t "/casa/p2/h1" -v
mosquitto_sub -h 192.168.1.48 -p 1883 -t "/casa/p2/h2" -v
mosquitto_sub -h 192.168.1.48 -p 1883 -t "/casa/+/h1" -v
mosquitto_sub -h 192.168.1.48 -p 1883 -t "/casa/#" -v

Y realizar diferentes pruebas de publicación,

mosquitto_pub -h 192.168.1.48 -p 1883 -t "/casa/" -m "1"
mosquitto_pub -h 192.168.1.48 -p 1883 -t "/casa/h1" -m "1"
mosquitto_pub -h 192.168.1.48 -p 1883 -t "/casa/h2" -m "1"
mosquitto_pub -h 192.168.1.48 -p 1883 -t "/casa/" -m "1"
mosquitto_pub -h 192.168.1.48 -p 1883 -t "/casa/" -m "1"
mosquitto_pub -h 192.168.1.48 -p 1883 -t "/casa/" -m "1"
mosquitto_pub -h 192.168.1.48 -p 1883 -t "/casa/p1/" -m "1"
mosquitto_pub -h 192.168.1.48 -p 1883 -t "/casa/p1/h1" -m "1"
mosquitto_pub -h 192.168.1.48 -p 1883 -t "/casa/p2/h1" -m "1"
mosquitto_pub -h 192.168.1.48 -p 1883 -t "/casa/p2/h2" -m "1"
mosquitto_pub -h 192.168.1.48 -p 1883 -t "/casa/p2/h3" -m "1"
mosquitto_pub -h 192.168.1.48 -p 1883 -t "/casa/p2/h1" -m "1"

De esta manera verás que se publica y donde se publica… Otra bonita manera de pasar una agradable tarde de domingo.

Un paso mas allá

Una vez ya has visto las posibilidades, y sobre todo lo sencillo que es, el siguiente paso lógico sería integrarlo con tu propia aplicación. De forma que, en función de los mensajes que recibas, en base a los tópicos a los que estás suscrito realices unas acciones u otras. Sencillamente espectacular.

Así para tu segunda Raspberry vas a crear un sencillo cliente, que responderá en función de lo que le preguntemos. Para ello, lo primero vas a crear un entorno virtual en Python y a continuación instalar la librería de Mosquitto con la que trabajar,

sudo apt install python3-venv
python3 -m venv mosquitto
source mosquitto/bin/activate
cd mosquitto/
pip install paho-mqtt

A continuación crea tu propio cliente, por ejemplo client.py, con el siguiente contenido

#!/usr/bin/env python3

import paho.mqtt.client as mqtt
import shlex
import subprocess
import re

def execute(command, parser=None):
    command_with_args = shlex.split(command)
    execution = subprocess.Popen(command_with_args, stdout=subprocess.PIPE,
                                 stderr=subprocess.PIPE)
    stdout, stderr = execution.communicate()
    return stdout.decode(), stderr.decode()


class Client(mqtt.Client):
    def __init__(self, client_id, host, port):
        mqtt.Client.__init__(self, client_id=client_id)
        self.host = host
        self.port = port
        self.on_connect = self.do_on_connect
        self.on_message = self.do_on_message

    def connect(self):
        super(Client, self).connect(host=self.host, port=self.port)

    def do_on_connect(self, client, serdata, flags, rc):
        print("Connected with result code {0}".format(rc))
        self.subscribe(topic="/rpis/rpi2", qos=2)
        print("Suscribed")

    def get_ram(self):
        stdout, stderr = execute('free')
        x = re.findall(r'Mem\w*:\s+(\d+)\s+(\d+)', stdout)
        ram = '{0:.1f}%'.format(float(x[0][1])/float(x[0][0]) * 100.0)
        return ram

    def get_swap(self):
        stdout, stderr = execute('free')
        x = re.findall(r'Swap:\s+(\d+)\s+(\d+)', stdout)
        swap = '{0:.1f}%'.format(float(x[0][1])/float(x[0][0]) * 100.0)
        return swap

    def get_temperature(self):
        f = open('/sys/class/thermal/thermal_zone0/temp', 'r')
        temp = float(f.read().split('\n')[0])/1000.0
        f.close()
        return temp

    def do_on_message(self, client, userdata, msg):
        topic = msg.topic
        msg = msg.payload.decode()
        print("{0} -> {1}".format(topic, msg))
        if msg == 'temperature':
            self.publish("/rpis/rpi2/temperature", self.get_temperature())
        elif msg == 'ram':
            self.publish("/rpis/rpi2/ram", self.get_ram())
        elif msg == 'swap':
            self.publish("/rpis/rpi2/swap", self.get_swap())

if __name__ == "__main__":
    client = Client("rpi2", "192.168.1.48", 1883)
    client.connect()
    client.loop_forever()
    exit(0)

Cambia la dirección IP del servidor y…ya lo tienes, para ponerlo en marcha simplemente ejecuta python client.py. Te aparecerán dos líneas,

Connected with result code 0
Suscribed

Para ver las respuestas, el primer paso es que te suscribas a todas las publicaciones que se realicen. Para eso, en un terminal ejecuta la siguiente instrución,

mosquitto_sub -h 192.168.1.48 -p 1883 -t "/#"

Y ahora desde cualquier otro equipo, simplemente ejecuta alguna de las siguientes instrucciones,

mosquitto_pub -h 192.168.1.48 -p 1883 -t "/rpis/rpi2" -m "ram"
mosquitto_pub -h 192.168.1.48 -p 1883 -t "/rpis/rpi2" -m "swap"
mosquitto_pub -h 192.168.1.48 -p 1883 -t "/rpis/rpi2" -m "temperature"

Y verás las siguientes respuestas en el equipo donde te hayas sucrito a todo,

ram
4.8%
swap
0.0%
temperature
40.242

En una sola palabra espectacular