Home Assistant: Diseñando un Elegante Cuadro de Mandos

En este artículo vamos a analizar un compañero de Home Assistant - AppDaemon (https://goo.gl/UD3hDA). Se trata de un entorno de trabajo que te permite desarrollar tus propias aplicaciones Python y hacer que éstas reaccionen a los eventos e interactúen directamente con Home Assistant. Te proporciona la flexibilidad de poder escribir complejas automatizaciones directamente en Python, y si cuentas con ciertos conocimientos de programación, te puedo decir que bastante más fácil que escribir largas automatizaciones en YAML. Tiene la ventaja añadida de contar con un entorno de trabajo que te permite desarrollar cuadros de mandos muy atractivos.

AppDaemon se puede instalar en el mismo sistema que Home Assistant, también conocido como HA, o en un sistema diferente, ya que se comunica con HA a través de un socket de red. La instalación es sencilla, puede encontrar instrucciones para ello en https://goo.gl/Hci4zm.

$ sudo pip3 install appdaemon

En el futuro, podrás actualizar fácilmente appdaemon con:

$ sudo pip3 install --upgrade appdaemon

También deberías crear este servicio systemd para gestionar el inicio automático:

$ cat /etc/systemd/system/appdaemon.service
[Unit]
Description=AppDaemon
After=homeassistant.service
[Service]
Type=simple
User=homeassistant
ExecStart=/usr/local/bin/appdaemon -c /home/homeassistant/.homeassistant
[Install]
WantedBy=multi-user.target

$ sudo systemctl enable appdaemon
$ sudo systemctl start appdaemon

Necesitarás crear una configuración por defecto preferiblemente dentro del directorio de configuración de HA y añadir aplicación para probar tu configuración. El archivo de configuración appdaemon.yaml también almacena las credenciales para acceder a tu Home Assistant, o puede leerlas desde el archivo “secrets.yaml”.

$ sudo su - homeassistant
$ cat /home/homeassistant/.homeassistant/appdaemon.yaml
 AppDaemon:
 logfile: STDOUT
 errorfile: STDERR
 logsize: 100000
 log_generations: 3
 threads: 10
 HASS:
 ha_url: http://127.0.0.1:8123
 ha_key: !secret api_password
$ mkdir /home/homeassistant/.homeassistant/apps
$ cat /home/homeassistant/.homeassistant/apps/hello.py
import appdaemon.appapi as appapi

#
# Hello World App
#
# Args:
#

class HelloWorld(appapi.AppDaemon):

def initialize(self):
 self.log("Hello from AppDaemon")
 self.log("You are now ready to run Apps!")

El código hello.py anterior ha sido sacado de las instrucciones de instalación, aunque también puede encontrar algunas aplicaciones útiles en el repositorio https://goo.gl/6nkzhm. Para activar y configurar una aplicación, deberás añadir lo siguiente dentro de 'apps.yaml':

$ cat /home/homeassistant/.homeassistant/apps.yaml
 hello_world:
 module: hello
 class: HelloWorld

Una vez que reinicies AppDaemon, las aplicaciones se cargarán automáticamente. En este caso, deberías ver el mensaje "Hello from AppDaemon" en tus registros log, lo cual indica que la configuración inicial se ha cargado, puedes verificarlo con:

$ sudo journalctl -f -u appdaemon

La mejor manera de empezar es leyendo la documentación. Hay un completo tutorial que te guía por todos los pasos: https://goo.gl/ha5iC8. Además, existe una referencia API para la búsqueda rápida: https://goo.gl/QeJSYu. El entorno de trabajo está basado en eventos, de modo que necesitas configurar “oyentes” para los varios eventos que tienen lugar en Home Assistant, de esta manera tu código será llamado automáticamente. Además, puedes acceder a todos los estados y atributos de las entidades de Home Assistant. Cuando estés familiarizado con el entorno de trabajo, puedes echar un vistazo a las aplicaciones de ejemplo para tener una idea de cómo se hacen las cosas.

¿Te acuerdas del proyecto del calentador con Home Assistant, publicado en el último número de ODROID Magazine? Pues bien, quizás porque me estoy haciendo viejo, siento la necesidad de encender la calefacción durante ciertas horas del día y de la noche, así que quería crear una aplicación que lo hiciera por mí. No obstante, hay un problema: quiero disponer de algún tipo de panel de control que sea fácil de usar dentro de Home Assistant y que me permita seleccionar el momento en el que quisiera que se encendiera la calefacción, como si fuera algún tipo de sustituto a la típica tarea cron. Considere apropiados los intervalos de 15 minutos por interruptor, de modo que si quería encender el calentador de 4:00 a 4:30, tendría que pulsar dos interruptores en la interfaz de usuario (4:00 y 4:15).

Haciendo un cálculo rápido podemos concluir que un día tiene 96 intervalos de 15 minutos, y puesto que soy algo flojo y no quiero escribir todo este código de configuración, hice un script para que generase la configuración (https://goo.gl/DYY5Mj). Si ejecutas el script, se crearán 96 interruptores input_boolean (https://goo.gl/BtJZ41) que serán distribuidos en grupos de 4 horas. Puedes copiarlo/pegarlo en tu archivo de configuración bajo las secciones correspondientes y reiniciar Home Assistant. No olvides añadir el 'heater_timer_group' en la vista 'heater':

$ wget https://raw.githubusercontent.com/mad-ady/home-assistant-customizations/master/configuration_helper/make_heater_switches.py
$ python make_heater_switches.py

Configuration.yaml debería parecerse a esto:

input_boolean:
 …
 heater_timer_00_00:
 name: Heater timer 00:00
 initial: off
 icon: mdi:fire
 heater_timer_00_15:
 name: Heater timer 00:15
 initial: off
 icon: mdi:fire
 …

group:
 heater_timer_group_0:
 name: Timer group 00:00 - 04:00
 control: hidden
 entities:
 - input_boolean.heater_timer_00_00
 - input_boolean.heater_timer_00_15
 - input_boolean.heater_timer_00_30
 …
 heater_timer_group:
 name: Heater timer
 control: hidden
 entities:
 - group.heater_timer_group_0
 - group.heater_timer_group_1
 - group.heater_timer_group_2
 - group.heater_timer_group_3
 - group.heater_timer_group_4
 - group.heater_timer_group_5

…
 heater:
 name: Gas heater
 view: yes
 icon: mdi:fire
 entities:
 - switch.heater
 - climate.heater_thermostat
 - group.heater_timer_group

Cuando termines deberías ver una pantalla similar a la que se muestra en la Figura 1.

Para que estos interruptores funcionen, hay que hacer una aplicación que escuche sus cambios de estado y de este modo se llevarán a cabo las acciones deseadas. Escribí un código para AppDaemon que hace lo siguiente:

• Al arrancar, empieza a escuchar eventos de entidades input_boolean llamadas heater_timer_ *, que se repiten a lo largo de todas las entidades y registra un “oyente” para cada una.
• Cuando detecta que se ha activado un booleano, comprueba si el nombre del booleano es el mismo que el momento actual y si es así, controla la calefacción
• Cada minuto se comprueba el correspondiente input_boolean para el intervalo del momento actual. Si está activado, entonces la calefacción se enciende.

El código fuente completo está disponible en https://goo.gl/WGvoAL, y se puede instalar con los siguientes comandos:

$ cd ~homeassistant/.homeassistant/apps/
$ wget \
 https://raw.githubusercontent.com/mad-ady/home-assistant-customizations/master/appdaemon_apps/manual_heater.py

También necesitarás editar el archivo apps.yaml y añadir lo siguiente:

manual_heater:
 module: manual_heater
 class: ManualHeater
 climate: "climate.heater_thermostat"
 heater: "switch.heater"
 interval_length: 15

Ahora, cuando reinicies AppDaemon, la nueva aplicación se cargará y reaccionará al estado de tus input_booleans. Puede seguir su avance leyendo el registro log de AppDaemon.

Todo parece funcionar bien, sin embargo, existe un problema. Si reinicias Home Assistant, o si hay un corte de luz en medio de la noche, los 96 interruptores pasarán a la posición de apagado por defecto. Tiene que haber alguna manera de guardar su estado y hacer que éste se cargue al reiniciar. Afortunadamente ya existe una aplicación para eso: switch_reset.py, disponible en https://goo.gl/LVYdD2. Así es como puedes configurarlo:

$ cd ~homeassistant/.homeassistant/apps/
$ wget -O switch_reset.py \
 https://raw.githubusercontent.com/home-assistant/appdaemon/dev/conf/example_apps/switch_reset.py
$ wget -O globals.py \
 https://raw.githubusercontent.com/home-assistant/appdaemon/dev/conf/example_apps/globals.py

Añade la siguiente configuración a apps.yaml:

switch_reset:
 module: switch_reset
 class: SwitchReset
 log: ""
 file: "/home/homeassistant/.homeassistant/switch_states"
 delay: 10

Tras reiniciar AppDaemon, los cambios en las entidades input_boolean, input_number, input_select y device_tracker se almacenarán dentro de /home/homeassistant/.homeassistant/switch_states, haciendo persistentes los estados de nuestros interruptores.

Aunque utilizamos aplicaciones automatizadas, la razón principal por la que las personas usan AppDaemon es porque proporciona una interfaz a modo de cuadro de mandos que permite presentar y controlar las entidades de Home Assistant en una pantalla táctil. Por lo general, las personas usan un televisor o una tablet para mostrar el cuadro de mandos, pero yo he utilizado la LCD 3.5” de HardKernel  (http://www.hardkernel.com/main/products/prdt_info.php?g_code=G147435282441), con un ODROID-C2 como unidad de procesamiento.

Para activar el cuadro de mandos (https://goo.gl/Z8iMW8), deberás añadir la siguiente sección a appdaemon.yaml:

HADashboard:
 dash_url: http://0.0.0.0:5050
 dash_password: !secret api_password
 dash_dir: /home/homeassistant/.homeassistant/dashboards

La directiva dash_password es opcional. Para facilitar el uso, es mejor no utilizar una contraseña, para que los cuadros de mandos puedan cargarse al arrancar sin la intervención del usuario. Necesitarás crear un cuadro de mando de muestra en ~homeassistant/.homeassistant/dashboards. Primero crea el directorio y luego ponle el nombre hello.dash:

$ mkdir ~homeassistant/.homeassistant/dashboards
$ mkdir -p \
 /home/homeassistant/.homeassistant/compiled/javascript/css
$ mkdir -p /home/homeassistant/.homeassistant/compiled/css
$ mkdir -p \
 /home/homeassistant/.homeassistant/compiled/html/default
$ cd ~homeassistant/.homeassistant/dashboards
$ vi hello.dash

hello.dash

#
# Main arguments, all optional
#
title: Hello Panel
widget_dimensions: [120, 120]
widget_margins: [5, 5]
columns: 8

label:
 widget_type: label
 text: Hello World

layout:
 - label(2x2)

Tras reiniciar AppDaemon, podrás acceder a esto en http://[ip-odroid]:5050/hello, donde [ip-odroid] es la dirección IP del ODROID-C2.

Los cuadros de mandos generan dinámicamente páginas web que pueden representar y controlar los estados de las entidades de Home Assistant. La mayoría de las entidades cuentas con los correspondientes fragmentos de configuración del cuadro de mandos, que permiten controlar las apariencias. La documentación de referencia la tienes disponible en https://goo.gl/G6iYib.

Para empezar, debes especificar las dimensiones de la pantalla y pensar en cómo quieres dividir la pantalla en widgets. Normalmente, la pantalla se divide en celdas x*y, y cada celda tiene una anchura y una altura fijas. Dispones de cierta flexibilidad ya que puede combinar celdas para crear una más grande y también puede dejar celdas o filas vacías. El tamaño estándar de la celda es de 120×120 píxeles. Puesto que la pantalla de 3.5" tiene una resolución pequeña (480 × 320), necesitaremos ser creativos e implementar algún tipo de menú para saltar de un panel a otro. También utilizaremos celdas pequeñas, 38×38, con un margen de 1 píxel y las combinaremos para crear widgets más grandes cuando sea necesario. Ten en cuenta que, si utilizas una pantalla lo suficientemente grande puede y deberías usar, tamaños de widget más grandes para evitar así tener problemas con el diseño.

Con respecto a la navegación con menús, HADashboard tiene un widget de navegación que se puede usar para cargar un cuadro de mando diferente. La idea es crear un menú vertical de 8 elementos que aparecerá en todos los cuadros de mandos permitiendo una rápida navegación, luego rellenar los paneles de acuerdo a mis necesidades con datos internos de Home Assistant, sensores, interruptores, reproductores multimedia, cámaras y datos externos tales como gráficos de Netdata o datos meteorológicos online. Uno de los botones puede servir como menú y cargar así un panel diferente con más botones, así que dispones de muchas opciones.

Aquí tienes un ejemplo de encabezado de cuadro de mandos, el cual he duplicado en todos los paneles:

#
# Main arguments, all optional
#
title: 3.5in LCD panel - 480x320 divided into 12x8 cells - Home
widget_dimensions: [38, 38]
widget_margins: [1, 1]
columns: 12
use_gass_icon: 1

Para poner en marcha la navegación, he configurado una lista de "botones" en un archivo diferente llamado ~homeassistant/.homeassistant/dashboards/navigation-definition.yaml, que se incluirá en todos los paneles y que tendrá un aspecto similar al siguiente, solo se muestran algunos elementos para que te hagas una idea:

home:
 widget_type: navigate
 dashboard: "lcd35-hq"
 icon_active: fa-home
 icon_inactive: fa-home
mpd:
 widget_type: navigate
 dashboard: "mpdkitchen"
 icon_active: fa-music
 icon_inactive: fa-music
tv:
 widget_type: navigate
 dashboard: "tv"
 icon_active: mdi-television-classic
 icon_inactive: mdi-television-classic
 icon_style: "font-size: 1.5em !important;"
 …

extendedmenu:
 widget_type: navigate
 dashboard: "extendedmenu"
 args:
 timeout: 10
 return: lcd35-hq
 icon_active: mdi-menu
 icon_inactive: mdi-menu

Puedes conseguir una copia completa del archivo en https://goo.gl/vwYD33. Como puede ver, la mayoría de las entradas son widgets de navegación que incluyen el nombre de archivo del cuadro de mando como parámetro y puede tener un estilo o icono personalizados. El ítem "extendedmenu" hace que este panel se cargue durante 10 segundos, luego se carga el panel "lcd35-hq", si no hay otra acción. Esto te permite simular un menú pop-up que desaparece por sí sólo.

El diseño de los widgets sobre la página se lleva a cabo creando una directiva de diseño con las filas que se detallan a continuación. Para cada celda de una fila, debes escribir el nombre del widget tal y como está definido en el cuadro de mandos o los archivos importados. Los nombres de los widgets pueden tener su tamaño anexado al nombre. Con el fin de reutilizar la configuración tanto como sea posible, también puedes importar definiciones externas desde otros paneles, como el fragmento de navegación anterior. El siguiente fragmento es del cuadro de mandos principal:

layout:
 - include: navigation-definition
 - include: sensors
 - home, clock(4x4), weather(7x4)
 - mpd
 - webcams
 - tv
 - heating, sensorliving(2x4), sensorkids(2x4), heater(2x4), forecast(5x4)
 - cooling
 - blinds
 - extendedmenu

Los elementos más a la izquierda de la lista son los destinos de la navegación definidos en el archivo navigation-definition.yaml. Desafortunadamente, puesto que quería disponer de un menú vertical, necesito añadirlo específicamente a cada cuadro de mando. Si sólo tuviera una fila horizontal, podría haber hecho el diseño dentro del archivo navigation-definition.yaml.

La fila superior empieza con un pequeño widget "home" utilizado para empezar a navegar de nuevo desde aquí, luego un widget de reloj 4×4 y un widget de clima 7×4. La siguiente fila solo muestra "mpd", que forma parte del menú. El resto de la fila está ocupada por los grandes widgets de reloj y clima, de modo que no hay añadido ningún otro elemento más. Usando esta lógica, puedes hacerte una imagen mental de cómo se supone que debería verse. El resto de los elementos están definidos en el cuadro de mando y en el sensors.yaml incluido:

clock:
 widget_type: clock
 time_format: 24hr
 show_seconds: 0
 time_style: "color: yellow; font-size: 40pt; font-weight: bold;"
 date_style: "font-size: 16pt; font-weight: bold;"

weather:
 widget_type: weather
 units: "°C"
 sub_style: "font-size: 110%; font-weight: bold;"
 main_style: "font-size: 75%; font-weight: bold;"
 unit_style: "font-size: 250%;"

forecast:
 widget_type: sensor
 title: Prognoza
 title_style: "font-size: 14pt;"
 text_style: "font-size: 16pt; font-weight: bold;"
 precision: 0
 entity: sensor.dark_sky_forecast_ro

Como puede ver, la mayoría de los widgets requieren una entidad que proporcione el lazo de unión con los elementos de Home Assistant, un “type” y el resto de configuración gestiona las fuentes, los colores y los iconos. Los iconos de los widgets pueden proceder de Home Assistant, aunque pueden sustituirse por iconos de Material Design, https://materialdesignicons.com, con el prefijo mdi, o de Font Awesome, http://fontawesome.io, con el prefijo fa.

Si tuvieras que cargar este cuadro de mandos ahora mismo en un navegador introduciendo http://ip-odroid:5050/lcd35-hq, se vería como en la Figura 4.

Sin embargo, parece haber un problema con el diseño de los widgets de navegación. Si utilizaras las herramientas de desarrollo de tu navegador y analizas el diseño, veras que, aunque los widgets están colocados correctamente, los iconos heredan un estilo CSS que usa un posicionamiento absoluto que desplaza el icono de 43 píxeles hacia abajo. Esto es un problema porque el cuadro de mandos fue diseñado para pantallas más grandes con widgets más grandes. Para evitar este problema, lo mejor es crear un skin que cargue un archivo JavaScript personalizado que restablezca el diseño absoluto de los iconos y también ajuste el tamaño. Para hacer esto, necesitarás algunos conocimientos de Javascript, HTML y CSS, aunque puedes conseguir el skin completo en https://goo.gl/Fwcbti.

$ sudo su - homeassistant
$ cd .homeassistant/
$ mkdir -p custom_css/defaultsmall
$ cd custom_css/defaultsmall
$ wget -O dashboard.css \
 https://raw.githubusercontent.com/mad-ady/home-assistant-customizations/master/appdaemon_skins/defaultsmall/dashboard.css
$ wget -O dashboardsmall.js \
 https://raw.githubusercontent.com/mad-ady/home-assistant-customizations/master/appdaemon_skins/defaultsmall/dashboardsmall.js
$ wget -O variables.yaml \
 https://github.com/mad-ady/home-assistant-customizations/blob/master/appdaemon_skins/defaultsmall/variables.yaml

Ahora, si vuelve a cargar el cuadro de mandos y especificas un skin especifico, conseguirás mejores resultados (http://[ip-odroid]: 5050/Icd35-hq?Skin=defaultsmall)

Ahora puedes echar un vistazo a mis cuadros de mandos. Toda la configuración está en https://goo.gl/VuB9sr. El panel MPD se compone de 3 cuadros de mandos similares en los que puedo desplazarme utilizando los widgets de navegación superiores. Éstos cargan 3 instancias MPD diferentes en la casa. La diferencia entre los paneles únicamente es la instancia cargada (ver mpdkitchen más abajo). El diseño del cuadro de mando es bastante simple:

layout:
 - include: navigation-definition
 - include: mpd
 - home, navigationmpdliving(4x1), navigationmpdkids(4x1), navigationmpdkitchen(3x1)
 - mpd, mpdkitchen(11x7)
 - webcams
 - tv
 - heating
 - cooling
 - blinds
 - extendedmenu

También tengo una vista del cuadro de mandos para controlar mi TV, que fue importada a Home Assistant tal y como se describe en https://magazine.odroid.com/article/home-assistantscripts-customization/. Estamos obteniendo la imagen de un componente de cámara dentro de Home Assistant y usando el Widget de cámara. Los botones se utilizan para controlar el control remoto virtual y conectarse a los componentes del script en Home Assistant, así como a la entidad del script en HADashboard. A continuación, tienes un ejemplo de diseño y de los widgets:

layout:
 - include: navigation-definition
 - home, streamtv(10x8), tv_living_off
 - mpd, tv_living_on
 - webcams, tv_living_source
 - tv, tv_living_mute
 - heating, tv_living_volume_up
 - cooling, tv_living_volume_down
 - blinds, tv_living_ch_up
 - extendedmenu, tv_living_ch_down

streamtv:
 widget_type: camera
 entity_picture: http://192.168.1.4:8123/api/camera_proxy/camera.tv_living_image?token=62f78994c790a89459e2f60cc6ed80bdfce3e9b5ff5473633ba60e3d7089f0a6&api_password=odroid
 refresh: 2

tv_living_off:
 widget_type: script
 entity: script.tv_living_power_off
 icon_on: mdi-power-plug-off
 icon_off: mdi-power-plug-off

tv_living_on:
 widget_type: script
 entity: script.tv_living_power_on
 icon_on: mdi-power
 icon_off: mdi-power

Lo que diferencia al widget de cámara es que necesita una URL a través de la API de Home Assistant. Esta URL debe incluir la clave API y también un token que es visible en Home Assistant -> Entities para la entidad en cuestión. Si también usas una contraseña para acceder a Home Assistant, deberás añadirla a la URL. La figura 7 muestra el resultado final.

Otro cuadro de mandos permite controlar el calentador, manualmente y el termostato. La configuración para el widget del termostato es similar a la que aparece a continuación, y el resultado final lo puedes ven en la Figura 8.

layout:
 - include: navigation-definition
 - include: sensors
 - home, heater(4x4), thermostat(6x8)
 - mpd
 - webcams
 - tv
 - heating, sensorliving(2x4), sensorkids(2x4)
 - cooling
 - blinds
 - extendedmenu

thermostat:
 widget_type: climate
 title: Thermostat
 step: 0.5
 precision: 1
 entity: climate.heater_thermostat
 unit_style: "color: yellow;"
 level_style: "color: yellow; font-size: 48pt;"
 unit2_style: "color: yellow;"
 level2_style: "color: yellow; font-size: 40pt;"
 level_up_style: "font-size: 20pt;"
 level_down_style: "font-size: 20pt;"

Durante el verano, el panel del aíre acondicionado tendrá un cierto uso. Aquí se colocan los sensores, interruptores y temporizadores que controlan el sistema de AC, como se describe en https://magazine.odroid.com/article/home-assistantscripts-customization/. El panel es similar al se muestra en la Figura 9.

El menú extendido no es más que un panel con más widgets de navegación. En él, tengo enlaces a un cuadro de mandos de Netdata y un pronostico meteorológico cada hora e imágenes de mis cámaras web, con espacio para más en el futuro. El panel de pronóstico del tiempo por hora utiliza el widget iframe para cargar una URL, mientras que el Panel de Netdata carga una lista de URLs cada 5 segundos:

mynetdata:
 widget_type: iframe
 refresh: 5
 url_list:
 - http://192.168.1.5:19999/server1.html
 - http://192.168.1.5:19999/server2.html
 - http://192.168.1.5:19999/server3.html
 - http://192.168.1.5:19999/server4.html
 - http://192.168.1.5:19999/server5.html

Ahora que tienes el cuadro de mandos funcionando a tu gusto, tendrás que invertir un poco de tiempo en el tema de la pantalla. Puedes empezar con el script de instalación de @FourDee para la pantalla de https://forum.odroid.com/viewtopic.php?t=24248. También necesitarás activar el acceso automático en lightdm (https://wiki.odroid.com/accessory/display/3.5inch_lcd_shield/autox#auto_login). Una vez hecho esto, es hora de realizar una limpieza. Lo mejor es eliminar aquellos programas que muestran ventanas pop-up en pantalla, como son el gestor de actualizaciones y el protector de pantalla:

$ sudo apt-get remove update-manager gnome-screensaver

También prepararemos un script que ejecute Chromium en modo Kiosco, sin almacenamiento de contraseñas, para que no te solicite contraseña cada vez que se desbloquee. Chromium también se configurará con un parche que hace que se olvide de que se ha bloqueado, por lo que, en caso de un cierre no limpio, no te preguntará si deseas restaurar la sesión anterior. Además de esto, configuraremos el monitor para que siempre esté encendido:

$ cat /usr/local/bin/kiosk-mode.sh
 #!/bin/bash
 /usr/bin/xset s off
 /usr/bin/xset -dpms
 /usr/bin/xset s noblank
 /bin/sed -i 's/"exited_cleanly": false/"exited_cleanly": true/' ~/.config/chromium/Default/Preferences
 dashboard=lcd35-hq
 /usr/bin/chromium-browser --noerrdialogs --incognito --password-store=basic --kiosk http://odroid-ip:5050/$dashboard?skin=defaultsmall
$ sudo chmod a+x /usr/local/bin/kiosk-mode.sh

También puedes añadir la extensión de Scrollbar Anywhere Chrome (https://goo.gl/UD3hDA). Configúrala para que reaccione con el botón izquierdo y active "Use Grab-and-drag style scrolling" para que puedas desplazarte, si fuera necesario, con el dedo sobre el cuadro de mandos.

Comprueba que el script funciona correctamente cuando se inicia desde el entorno gráfico y, cuando esté listo, puedes añadirlo a la lista de aplicaciones que se inician automáticamente en Control Center -> Personal -> Startup Applicat. Simplemente haz clic en "add", usa "Kiosk mode" en el nombre y /usr/local/bin/kiosk-mode.sh como comando. Una vez que reinicies lightdm, deberías ver un panel a pantalla completa.

Lo que muestra la Figura 11 es el resultado final, ejecutándose en una pantalla de 3.5". La pantalla de 3.5 "de Hardkernel es perfecta para un pequeño cuadro de mandos. Los tamaños y colores de fuente utilizados están optimizados para una fácil lectura a una distancia de 2-3 metros y el contraste ayuda a leer desde ángulos más amplios. La baja velocidad de refresco de la pantalla de unos 10 fps no se aprecia con el cuadro de mandos.

Puedes conseguir los archivos de configuración del cuadro de mandos desde proyecto GitHub en https://github.com/mad-ady/home-assistant-customizations, y ver un video de demostración en youtu.be/fEoHs3-_3B0. Pen en cuenta que todo ha sido probado con el appdaemon 2.1.12, puesto que la versión 3 está actualmente en desarrollo,  para cuando pongas en funcionamiento esto, quizás algunas cosas hayan cambiado ligeramente. Está atento al repositorio de GitHub y al hilo de soporte en  https://forum.odroid.com/viewtopic.php?t=27321.