Está en la página 1de 7

Otras aplicaciones para la raspberry pi re‐

lacionadas con domótica e IoT  
En el desarrollo de la asignatura nos hemos centrado principalmente en el desarrollo de aplicacio-
nes para la Raspberry utilizando C o C++. No obstante, existen otras muchas alternativas, como la
programación utilizando lenguajes interpretados como Python o Node.js, y también existen diver-
sas utilidades que permiten crear aplicaciones sin tener apenas que programar nada o haciéndolo
a muy alto nivel. En este documento se recogen algunas de estas posibilidades.

1 HOME ASSISTANT 
Home assistant ( https://www.home-assistant.io/ ) es una plataforma domótica de código abierto
desarrollada sobre Python, para la que existen numerosos módulos ya desarrollados que
posibilitan el control dispositivos de diversas tecnologías (Zigbee, Z-wave, MQTT, X-10, Bluetooth,
….), fabricantes (Philips, ikea, Xiaomi, Samsung… ), y tipos de dispositivo (lámparas,
interruptores, climatización, entretenimiento,…), permitiendo controlar numerosos dispositivos
domóticos presentes en el mercado. La plataforma permite el control desde un interfaz web de los
diversos dispositivos, la creación de comportamientos automatizados y proporciona algunas
facilidades para agregar nuevos componentes.
En el sitio web de los desarrolladores puede descargarse una imagen de Linux para la raspberry
ya preparada con el sistema confgurado (“hassbian”), aunque también pueden encontrarse los
pasos para instalar la plataforma en la imagen de debian proporcionada oficialmente por los
desarrolladores de la raspberry pi (“raspbian”), que es la que hemos utilizado durante el desarrollo
de la asignatura. Los pasos necesarios se resumen a continuación.

1.1 INSTALACIÓN DE HOME ASSISTANT.


Para realizar la instalación, debemos realizar una conexión ssh con la Raspberry utilizando la
cuenta “root” (tecleando “ssh root@la.ip.de.miraspberry”), o bien tecleando “sudo bash” tras haber
realizado la conexión como usuario “pi” con la raspberry (ssh pi@la.ip.de.miraspberry), ya que
necesitamos permisos administrativos para realizar la instalación.
En la documentación oficial de “home assistant”, se menciona que se deben instalar algunos
prerrequisitos, aunque en principio ya están instalados en la imagen oficial de Raspbian. Si no
fuese el caso, se podrían instalar ejecutando el comando:
apt-get install python3 python3-venv python3-pip

El siguiente paso es crear una cuenta de usuario para la ejecución de la aplicación desde una
cuenta sin privilegios administrativos (por seguridad). Para poder acceder a algunos dispositivos
con perfil de puerto serie, se agregará la cuenta al grupo de usuarios con permiso de acceder a
estos dispositivos (grupo “dialout”). El comando a introducir para conseguir esto es el siguiente:
sudo useradd -rm homeassistant -G dialout

A continuación, se debe crear una carpeta para la instalación de la aplicación Home Assistant. El
usuario “homeassistant” que se creó en el paso anterior deberá quedar establecido como
propietario de dicha carpeta:
cd /srv
sudo mkdir homeassistant
sudo chown homeassistant:homeassistant homeassistant
La instalación de home assistant se realizará a través del gestor de paquetes de Python (pip),
pero para evitar interferir con la instalación base de Python de la raspberry, se creará en primer
lugar un entorno virtual de python para el usuario “homeassistant”:
sudo -u homeassistant -H -s
cd /srv/homeassistant
python3 -m venv .
source bin/activate

Una vez activado el entorno virtual de Python, se instalará una dependencia y el paquete home
assistant propiamente dicho. Si nos encontramos en el laboratorio 2.1.2 de la ETSIT en la UMA,
es necesario configurar el proxy para poder instalar los paquetes (En cualquier otra red sin proxy,
esto no sería necesario):
export http_proxy=http://proxy.satd.uma.es:3128
export https_proxy=”http://proxy.satd.uma.es:3128”

Para instalar el paquete (y su dependencia) teclearemos:


python3 -m pip install wheel
pip3 in-stall homeassistant

A continuación, podremos ejecutar “home assistant” por primera vez, lo que completará la
instalación y creará una subcarpeta “.homeassistant” con la configuración base (que luego se
podrá modificar) en la carpeta “/home/homeassistant”.
hass

Una vez tecleado dicho comando, se arrancará el servidor, que podrá accederse desde un
navegador web tecleando la URL http://la.ip.de.my.raspberry:8123 (8123 es el puerto base donde
“escucha” el servidor home assistant, y “la.ip.de.my.raspberry” es la dirección IP asignada a la
raspberry). El servidor puede pararse en cualquier momento pulsando “CTRL+C” en la consola de
terminal. La primera vez que se arranca home assistant, se descargan y configuran algunas
dependencias, por lo que este primer arranque puede tardar unos minutos en llegar a completarse
(tiempo durante el cual el servidor no responderá).

1.2 CONFIGURACIÓN DE COMPONENTES DE HOME ASSISTANT


La configuración de componentes de home assistant se realiza a través del fichero configura-
tion.yaml que se encuentra en la carpeta “/home/homeassistant/.homeassistant”. En la carpeta
“ficheros adicionales” del campus virtual puede encontrarse un ejemplo que configura un bróker
MQTT y agrega tres “bombillas mqtt”, permitiendo su control desde el interfaz. Para ello, se han
añadido las siguientes líneas al fichero original (nótese que “127.0.0.1” es la dirección IP del bró-
ker MQTT, que en este ejemplo sería la propia raspberry, pero podría cambiarse por otra dirección
para utilizar cualquier otro bróker):
mqtt:
broker: 127.0.0.1

light:
- platform: mqtt_template
name: "Led rojo"
command_topic: "/rpi/ejemplosub"
command_on_template: '{ "greenLed" : true }}'
command_off_template: '{ "redLed" : false }'
#state_template: '{{ value_json.state }}'
- platform: mqtt_template
name: "Led verde"
command_topic: "/rpi/ejemplosub"
command_on_template: '{ "greenLed" : true }'
command_off_template: '{ "greenLed" : false }'
- platform: mqtt_template
name: "Led azul"
command_topic: "/rpi/ejemplosub"
command_on_template: '{ "blueLed" : true }'  
command_off_template: '{ "blueLed" : false }'  
 

Mediante este fichero de configuración se puede añadir el control de otros elementos a la plata-
forma home assistant.

1.3 ARRANQUE AUTOMÁTICO DE “HOME ASSISTANT” AL INICIO DEL SISTEMA


Según los pasos que hemos seguido hasta ahora, sería necesario arrancar home assistant cada
vez que se reinicie la raspberry pi. Para ello, habría que realizar los siguientes pasos:

1. Ejecutar el entorno virtual de Python (“sudo -u homeassistant -H -s”; “cd


/srv/homeassistant”; “python3 -m venv .”); “source bin/activate”).
2. Ejecutar el servidor (“hass”).

No obstante, lo lógico sería configurar el arranque del sistema de forma que “home assistant” se
arrancase automáticamente como otros servicios de Linux. Para ello, habría que crear un fichero
de configuración apropiado para el sistema de gestión de arranque servicios de la distribución de
Linux que estemos utilizando. Los sistemas de arranque de servicios han ido evolucionando con
las diferentes versiones de Linux (System V, Upstart, Systemd…), pero en el caso de la mayoría
de las distribuciones modernas (como es el caso de Raspbian) el sistema de arranque utilizado es
Systemd.

En el campus virtual se ha dejado un fichero de configuración (“home-


assistant@homeassistant.service”) que permitiría arrancar automáticamente el servicio home
assistant. Dicho fichero puede guardarse mediante los diversos medios explicados hasta ahora
(SFTP, SCP, SSHFS, conexión desde el remote system explorer de eclipse…) en la carpeta
“/lib/systemd/system/” de la Raspberry. También puede crearse tecleando el comando “leafpad
/lib/systemd/system/home-assistant@homeassistant.service” (desde una conexión SSH con la
opción “-X”) o el comando “nano /lib/systemd/system/home-assistant@homeassistant.service”, y
añadiendo el siguiente contenido:
[Unit]
Description=Home Assistant
After=network-online.target

[Service]
Type=simple
User=%i
ExecStart=/srv/homeassistant/bin/hass -c
"/home/homeassistant/.homeassistant"

[Install]
WantedBy=multi-user.target

Una vez creado el fichero de configuración del servicio home assistant, su arranque al inicio
puede activarse mediante los siguientes comandos:
sudo systemctl --system daemon-reload
sudo systemctl enable home-assistant@homeassistant

NOTA: El primer comando es para refrescar los servicios disponibles, ya que acabamos de añadir
uno. El Segundo comando es el que activa el servicio.“…@homeassistant” indica que el usuario
desde el que se arranca el servicio no es el usuario “root” sino el usuario “homeassistant”, que no
tiene permisos administrativos. Si más adelante quisiéramos deshabilitar el servicio, deberíamos
ejecutar el comando “[sudo] systemctl disable home-assistant@homeassistant”.
Para reiniciar el servicio (por ejemplo, si se cambia algún fichero de configuración, para que tenga
efecto dicho cambio), se podría utilizar el comando “systemctl restart home-
assistant@homeassistant.service” o, alternativamente, el comando “service home-
assistant@homeassistant restart”.

2 NODERED 
NodeRed es un entorno de programación “gráfica” de alto nivel desarrollado sobre Node.js y
orientado al tratamiento y procesado de información para la IoT. Tanto NodeRed como el intérprete
de node.js están ya instalados en las imágenes actuales de Raspbian, y sólo es necesario
ejecutarlo para poder acceder a su funcionalidad, tecleando (en una consola SSH con permiso
administrativo):
node-red-start

Una vez arrancado el servicio, puedes acceder a él mediante un navegador web, configurando la
URL “http://la.ip.de.la.raspberry:1880” (1880 es el número del puerto donde por defecto queda
escuchando el servidor Node-RED).
NodeRed es un entorno que permite procesar, de forma más o menos sencilla, diversas entradas
(procedentes de pines hardware de entrada GPIO, topics MQTT, mensajes entrantes a conexiones
TCP, correos o tweets entrantes, etc.) y conectar el resultado del procesado con diversas salidas
(publicación en topics MQTT, actuación sobre salidas GPIO hardware, envío de correos o tweets,
…), todo ello principalmente a través de una programación gráfica.
Por ejemplo, para crear un flujo de datos en NodeRed con una funcionalidad similar a la de la
especificación 1 de la práctica 2 (controlar el estado de 3 Leds mediante mensajes JSON
publicados en un topic MQTT), bastarían los siguientes pasos:
1. Añadir una entrada (“input”) MQTT, y configurar el servidor (“localhost”) y el topic
(“/rpi/ejemplosub”):

2. Para “parsear” el JSON, añadir un elemento de procesado “json” (convertir de JSON a


JavaScript Object):

3. Para extraer y separar los campos del JSON (redLed, greenLed y blueLed), es necesario
añadir un elemento de procesado de tipo “función”, indicando que tiene 3 salidas y
especificando el código a ejecutar (en node.js) para realizar la extracción de las 3
componentes:
4. Para actuar sobre cada salida GPIO de la Raspberry podemos añadir elementos de tipo
salida (output). En su configuración podemos indicar el pin sobre el que actual (por ejemplo
el pin 35, GPIO19):

 
También podemos crear este “flujo” si pinchamos en “menú  Import” y pegamos el siguiente 
texto (por si acaso, el texto plano se ha dejado en un fichero en el campus virtual):  
[{"id":"b3362eb2.140fa8","type":"tab","label":"Ejemplo1","disabled":false,"info":""},{"id":"102df305
.5ec5cd","type":"rpi-gpio
out","z":"b3362eb2.140fa8","name":"","pin":"35","set":"","level":"0","freq":"","out":"out","x":1200,
"y":480,"wires":[]},{"id":"ecd4e4fa.debbb","type":"mqtt
in","z":"b3362eb2.140fa8","name":"","topic":"/rpi/ejemplosub","qos":"2","broker":"57f74379.715784","
x":480,"y":480,"wires":[["1643924f.f279ce"]]},{"id":"1643924f.f279ce","type":"json","z":"b3362eb2.14
0fa8","name":"","property":"payload","action":"obj","pretty":false,"x":730,"y":480,"wires":[["42e183
5b.7dd6fc"]],"inputLabels":["redLed"],"outputLabels":["salida"]},{"id":"42e1835b.7dd6fc","type":"fun
ction","z":"b3362eb2.140fa8","name":"","func":"var newMsg1 = { payload: msg.payload.redLed };\nvar
newMsg2 = { payload: msg.payload.greenLed };\nvar newMsg3 = { payload: msg.payload.blueLed
};\n\nreturn [ newMsg1 , newMsg2, newMsg3
];","outputs":3,"noerr":0,"x":930,"y":480,"wires":[["dd9e64f9.ba4098"],["102df305.5ec5cd"],["bffb0e9
a.452ad"]]},{"id":"dd9e64f9.ba4098","type":"rpi-gpio
out","z":"b3362eb2.140fa8","name":"","pin":"33","set":"","level":"0","freq":"","out":"out","x":1200,
"y":420,"wires":[]},{"id":"bffb0e9a.452ad","type":"rpi-gpio
out","z":"b3362eb2.140fa8","name":"","pin":"37","set":"","level":"0","freq":"","out":"out","x":1200,
"y":560,"wires":[]},{"id":"57f74379.715784","type":"mqtt-
broker","z":"","name":"","broker":"localhost","port":"1883","clientid":"","usetls":false,"compatmode
":true,"keepalive":"60","cleansession":true,"willTopic":"","willQos":"0","willPayload":"","birthTopi
c":"","birthQos":"0","birthPayload":""}]  

También podemos crear este “flujo” si pinchamos en “menú  Import” y pegamos el siguiente 
texto (por si acaso, el código se ha dejado en un fichero de texto plano en el campus virtual). 
Para ejecutar el código hay que pinchar en el botón/pestaña “Deploy”