Google Assistant en Orange Pi Zero

Google Assistant en Orange Pi Zero (I)

En el artículo de hoy vamos a ver cómo utilizar nuestra Orange Pi Zero [casi] como un dispositivo Google Home por muy poco dinero.

Con la guerra abierta que hay a fecha de hoy con los llamados asistentes virtuales, las empresas competidoras como Amazon, Google, Apple y otras hacen lo posible por imponer su producto como un nuevo estándar en este campo.

En un intento de expandir al máximo su asistente (Google Assistant), Google ha puesto a disposición de la comunidad desarrolladora una serie de APIs y librerías que nos permiten poner en funcionamiento su asistente en cualquier plataforma que cumpla con estos requisitos básicos:

• Un intérprete de Python.
• Una conexión a internet.
• Un altavoz.
• Un micrófono.

Como experimento me planteo montar el asistente en una Orange Pi Zero, que gracias a su bajo precio y pequeño tamaño nos permitirá disponer de un dispositivo eficiente, pequeño y de bajo consumo.

Sin embargo, dados los requerimientos, este artículo se puede aplicar en principio a cualquier otra placa o dispositivo que cumpla con los requisitos especificados: un PC x86, una Raspberry, una Banana Pi, etc.

Básicamente, hay dos enfoques que podemos tomar para montar nuestro asistente, de menor a mayor funcionalidad. Es lo que veremos en los puntos 1 y 2.

Antes, veamos qué necesitamos comprar o tener de antemano:

Requisitos

Para este proyecto necesitaremos los siguientes requisitos:

• Orange Pi Zero.
  Obviamente, necesitaremos una placa de desarrollo. Yo he elegido la Orange Pi Zero por su buena relación potencia/precio y porque ya he usado otras para otros proyectos y me gusta. Hay dos versiones de esta placa: la de 256MB de RAM y la de 512MB. Es muy importante comprar la de 512MB porque la otra es insuficiente. Aún así, para el apartado Opción 2 como veremos en el siguiente artículo, tendremos problemas al tener sólo 512MB de memoria.
  La placa nos podría valer tal cual, ya que dispone de una fila de terminales GPIO donde podríamos conectarle una salida y entrada de audio. No obstante yo recomiendo comprar, además de la placa, una tarjeta de expansión que lleva ya la salida de audio, un micrófono integrado, un receptor de infrarrojos y dos puertos USB adicionales entre otras cosas.
  
  En China podemos encontrar la Orange Pi Zero principalmente en Banggood y en Aliexpress. A continuación pongo un par de enlaces con el paquete completo (placa principal de 512MB + tarjeta de expansión + caja), con los precios a 17/11/2018. Puntualmente se encuentran ofertas mejores, pudiendo salir el paquete completo por unos 14€:
  • Banggood (20,53 €).
  • Aliexpress (19,73 €).
  En teoría, se pueden encontrar también por Amazon, pero el precio sube considerablemente.
• Disipadores.
  La Orange Pi Zero incorpora un procesador Allwinner H2+, y se calienta bastante (en condiciones normales se puede poner en 70ºC perfectamente). Es muy recomendable ponerle un disipador al menos al procesador (hay quien también se lo pone a la memoria).
  
  Aconsejo comprar uno estos kits que traen 3 disipadores y son muy baratos. Hay que tener en cuenta que no es lo mismo tener la placa al aire que metida dentro de una caja tan pequeña. Los disipadores llevan un adhesivo de doble cara y simplemente se pegan sobre el procesador o la memoria, según su tamaño.
  • Banggood (1,09€).
  • Banggood (0,87€). Estos son para Raspberry, pero nos valen perfectamente.
  • Aliexpress (1,54€). Es una sola unidad, en cerámica (supuestamente mayor disipación).
• Micrófono USB.
  Es verdad que, como he dicho antes, la placa de expansión lleva un micrófono integrado, pero al parecer es de muy poca calidad. Yo recomiendo comprar un pequeño micrófono USB que, si bien no es una maravilla, tiene bastante sensibilidad y funciona perfectamente. Además es muy barato:
  • Aliexpress (1,75€)
• Alimentación.
  Finalmente, nos hará falta alimentar la placa. La toma de alimentación es microUSB, de manera que podremos hacerlo con cualquier alimentador de móvil o tablet más o menos potente. Lo recomendable es un alimentador de 2A o superior. De todos modos, yo tengo una Orange alimentada en un puerto USB de un router desde hace 2 años sin problemas…

Preparación del altavoz

Instalación del Sistema Operativo.

Lo primero que haremos es instalar un sistema operativo para la Orange Pi. Recomiendo encarecidamente que instaléis armbian. Se trata de una distribución Linux basada en debian para dispositivos ARM de todo tipo, con procesadores Allwinner, Rockchip, FreeScale, etc.

Descarga de armbian

La página de descarga, donde podéis buscar una distribución para vuestro dispositivo específico, es la siguiente:

https://www.armbian.com

Grabación en SD

Una vez descargada la imagen, la grabamos en una tarjeta microSD por medio del programa Etcher (si trabajamos desde WIndows). En caso de trabajar desde Linux podemos hacer lo mismo con las herramientas del sistema o por medio del comando dd.

Instalación del sistema

Con nuestra microSD grabada, la introducimos en la Orange y arrancamos. Ya que la Orange Pi Zero no tiene salida de vídeo HDMI, no podremos conectarle un teclado y empezar a teclear comandos. Yo lo que hago en estos casos es lo siguiente:

• Le conecto un cable de red a la toma ethernet RJ45 para conectarla a la red.
• En el móvil, utilizo la app Fing para comprobar qué dirección IP le ha asignado el router.
• Una vez que tengo la IP, desde cualquier ordenador accedo mediante protocolo ssh con algún programa como putty o Xshell (gratuíto para usuarios domésticos y escolares).
• El usuario a utilizar es root, y la contraseña 1234.

La primera vez que arranca, armbian nos pedirá que cambiemos la contraseña de root y nos pedirá los datos de un usuario normal (no root) que creará con privilegios de sudo.

Configuración básica

Una vez iniciado por primera vez el sistema, recomiendo configurar lo siguiente:

• Conexión WIFI
  Podemos tener un altavoz inteligente conectado a una toma de red, pero la mayoría de la gente normalmente querrá tenerlo conectado de forma inalámbrica a la WIFI. Por tanto, lo más fácil será ejecutar el comando:

  nmtui
  

  Elegiremos la opción “Activate a connection”
  
  y después elegiremos la red a la que nos queremos conectar. Una vez seleccionada, nos pedirá la contraseña .
  
• Personalización.
  Finalmente, ejecutamos:

  sudo armbian-config
  

  
  entramos en la opción “Personal” y configuramos cosas básicas como:
  • La zona horaria. Normalmente elegiríamos Europe/Madrid.
  • Los locales. Normalmente añadiríamos aquí es_ES.utf8, fijándolo por defecto para que nos salgan los mensajes y otras cosas en español.
  • La disposición del teclado. Elegimos uno con caracteres españoles.
  • El hostname. Por defecto es orangepizero, podríamos cambiarlo por el que queramos.
  Y ya está todo configurado.

Creación del proyecto de Google.

Una vez que tenemos la placa ya configurada, vamos a entrar en materia. Este tutorial está parcialmente basado en las guías que Google publica en su página para desarrolladores:

https://developers.google.com/assistant/sdk/

Lo primero que necesitaremos es crear un proyecto en la nube de Google Actions. Para ello, en nuestro navegador vamos a la siguiente dirección:

https://console.actions.google.com/

En esta página pulsamos “Add/import project“ y rellenamos el nombre del proyecto, el idioma (Spanish) y el país (Spain).

Una vez creado el proyecto, nos vamos a la parte inferior de la página y pulsamos el botón “Device Registration“.

Dejamos la página actual tal cual sin cerrar porque después tendremos que volver a ella.

Credenciales de acceso

Ahora abrimos otra pestaña en el navegador y nos vamos a la consola para desarrolladores de Google:

https://console.developers.google.com

En esta página, antes que nada, nos aseguraremos de que tenemos seleccionado el proyecto que hemos creado en Google Actions. Una vez seleccionado el proyecto, nos vamos a la opción Biblioteca (en la parte izquierda) y localizamos “Google Assistant API”. Nos aparecerá una página tal como esta:

En dicha página pulsaremos el botón Habilitar.

Una vez habilitada, hay que crear unas credenciales de acceso. Para ello, en la parte izquierda pulsamos en Credenciales y después en la pestaña “Pantalla de consentimiento de OAuth“.

En esta pantalla básicamente rellenaremos el nombre de la aplicación o proyecto y el email de contacto. Una vez rellenos estos datos guardamos la credencial pulsando el botón Guardar que está al final de la página.

Acceso a tu actividad

Para poder utilizar el asistente, es necesario que activemos la compartición de la actividad asociada a nuestra cuenta de Google. Para ello, nos vamos a la siguiente dirección:

https://myaccount.google.com/activitycontrols

e iniciamos sesión con nuestra cuenta de Google. En esta página nos aseguraremos de tener marcadas las siguientes opciones:

• Actividad en la Web y en Aplicaciones.
• Incluye el historial de Chrome y la actividad que se realiza en sitios web, aplicaciones y dispositivos que utilizan los servicios de Google.
• Información del dispositivo.
• Actividad de Voz y Audio.

Registro del dispositivo

Volvemos a la pestaña que dejamos abierta antes (la de Google Actions) y vamos a asociar un dispositivo al proyecto. Para ello pulsamos el botón Register Model.

En esta ventana, rellenaremos un nombre para el dispositivo, el fabricante (cualquiera vale) y el tipo de dispositivo. En mi caso, siempre elijo Speaker puesto que se trata de un altavoz.

Pulsamos de nuevo el botón Register Model y avanzamos a la siguiente ventana, donde deberemos pulsar el botón Download OAuth 2.0 credentials. Al pulsar dicho botón descargaremos un fichero en formato json con las credenciales del dispositivo que acabamos de registrar. Lo guardaremos a buen recaudo porque más tarde lo necesitaremos.

Finalmente, avanzamos y en la siguiente ventana pulsamos el botón Save Traits.

Con esto queda toda la preparación terminada.

En el siguiente artículo veremos cómo poner en marcha el asistente, con dos opciones en función de nuestras necesidades.

Acceso mediante SSH sin contraseña

Una de las cosas que más veces he tenido que hacer, dado que soy un forofo de la automatización, es poder entrar desde una máquina a otra de forma automática.

SSH

El protocolo SSH (Secure SHell) nos permite entrar en una máquina remota de forma segura (a diferencia de su hermano mayor, telnet) mediante una línea de comandos sobre una red no necesariamente segura.

Los datos que se envían y se reciben por medio de este protocolo se encriptan mediante un par de claves pública y privada, de manera que aunque alguien “esnife” nuestra red, no podrá interpretar qué comandos estamos lanzando ni qué resultados nos devuelve la máquina remota.

Para conectar desde una máquina A a otra máquina B, necesitamos en A un cliente de SSH y en B un servicio de servidor de SSH. Si nuestros sistemas no traen de serie estas utilidades, deberíamos poder instralarlas mediante el correspondiente sistema de paquetes (openssh-client y openssh-server respectivamente).

Normalmente, accederemos a la máquina remota de forma interactiva, tecleando un usuario y una contraseña, de la misma manera que lo haríamos si utilizásemos una consola local en dicha máquina. Para ello, lógicamente, deberemos utilizar las credenciales de un usuario existente.

Automatización

Pero ¿qué pasa si lo que queremos es entrar de forma “no interactiva” en la máquina remota?. SSH nos obliga siempre a teclear al menos una contraseña, aunque podemos evitar teclear el usuario de la siguiente forma:

$ ssh usuario@maquinaremota

La única solución viable que tenemos es utilizar claves criptográficas en lugar de usuarios para acceder. El principio es el siguiente:

1. En la máquina A nos creamos una pequeña infraestructura PKI con un par de claves: privada y pública.
2. Compartimos con la máquina B nuestra clave pública.
3. Accedemos de A a B encriptando ciertos datos por medio de nuestra clave privada.
4. La máquina B intenta desencriptar mediante la clave pública que le proporcionamos inicialmente los datos que acabamos de encriptar por medio de nuestra clave privada.
5. Si la desencriptación tiene éxito, se nos concede el acceso.

Secuencia

Esta forma de acceder mediante ssh está ampliamente documentada literalmente en miles de páginas de internet, pero de lo que se trata es de tener un pequeño “chuletario” rápido para tenerlo aquí para cuando nos haga falta.

La secuencia de comandos a utilizar, suponiendo que estamos en una máquina A y queremos acceder a otra máquina remota B, es la siguiente:

1. Generar una pareja de claves criptográficas.
   En la máquina A generamos un par de claves con el siguiente comando:

   $ ssh-keygen -t rsa
   

   El comando tardará un rato en generar el par de claves y nos pedirá dos veces que especifiquemos una contraseña, que dejaremos en blanco (pulsando enter) ambas veces.
   El parámetro -t especifica el tipo de encriptación que utilizaremos. Pueden ser otros como dsa, ecdsa, etc, pero lo más normal es utilizar rsa.
   Este comando nos va a crear en el directorio home del usuario actual (/home/usuario en caso de un usuario normal o /root en caso del usuario superadministrador) un directorio oculto de nombre .ssh con el siguiente contenido:

   id_rsa
   id_rsa.pub
   

   El primero es nuestra nueva clave privada, y el segundo la clave pública. Ambas claves criptográficas nos permiten cifrar con una y descifrar con la otra.
2. Copiar la clave pública.
   Nuestra clave privada permanecerá siempre guardada en nuestra máquina A, pero la pública tenemos que trasladarla a la máquina de destino a la que querremos conectar.
   Para ello, primero haremos lo siguiente:

   $ ssh usuarioB@maquinaB
   

   Con esto estamos accediendo a la máquina B con el usuario usuarioB de forma interactiva. Se nos pedirá la contraseña del usuarioB y a continuación nos aseguraremos de que tenemos un directorio .ssh en su home:

   $ mkdir .ssh
   $ chmod 700 .ssh
   $ exit
   

   Una vez creado el directorio (hemos vuelto a A con el exit), copiamos nuestra clave pública concatenándola con lo que haya en el fichero authorized_keys de dicho directorio de B:

   $ cat id_rsa.pub | ssh usuarioB@maquinaB 'cat >> .ssh/authorized_keys'
   

   Este fichero contendrá todas las claves públicas autorizadas a entrar en esta máquina y este usuario sin contraseña.
3. Entrar sin contraseña.
   Una vez que hemos hecho lo anterior, ya podemos entrar desde A a B utilizando de nuevo el sigiuiente comando:

   $ ssh usuarioB@maquinaB
   

A partir de ahora ya no nos pedirá contraseña.

Instalación de HomeAssistant mediante PyEnv

Cuando uno empieza a entrar en el mundo de la domótica “casera” (nunca mejor dicho), no a base de utilizar productos comerciales sino haciéndolo todo uno mismo, lo primero que piensa es en la Raspberry Pi.

Yo, sin embargo, en mi afán de gastar lo mínimo posible comprando productos en China, decidí en un principio utilizar la Orange Pi Zero como mi controlador principal para HomeAssistant, como vimos en un artículo anterior.

Problemática

En realidad, uno puede instalar HomeAssistant en cualquier ordenador o controlador: un equipo Mac, Windows, Linux, un core I7 de última generación o un ARM con 256 MB de RAM, siempre y cuando sea posible instalarle Python.

Sin embargo, apartarse del estándar utilizado por la mayoría tiene su penalización.

Si tienes una Raspberry PI, basta con acudir a la página de HomeAssistant y bajarte una distribución de Linux especial personalizada (hass.io o hassbian) y grabarla en tu tarjeta SD para salir andando. Ambas distribuciones están pensadas para que el usuario trabaje lo mínimo, sea fácil actualizar, esté todo optimizado, etc.

Pero ¿qué pasa cuando tu distribución, que no es la estándar, se queda anticuada y los requerimientos de versiones de HomeAssistant van subiendo y no tienes posibilidad de actualizar?. De todos es sabido que las distribuciones de Linux tienen una gran ventaja que son los repositorios de software (debian, ubuntu, rpm, etc) desde los que el usuario siempre puede instalarse el software sin tener que buscar en ningún sitio más. Esta gran ventaja sin embargo se convierte en un gran inconveniente cuando los paquetes del repositorio se quedan antiguos y no se pueden actualizar más.

Tal es el caso de la Orange Pi Zero, para la cual disponemos de varias versiones (aquí y aquí) de Linux pero todas ellas basadas en un repositorio de Debian que no es el más nuevo.

Esto es un problema cuando los requerimientos de HomeAssistant subieron por ejemplo de Python 3.4 a Python 3.5.3. Este cambio que en principio puede parecer mínimo hace que por ejemplo en la versión de Ubuntu 16.04.04 LTS que es la que yo uso no pueda instalar versiones recientes de HomeAssistant puesto que la versión máxima de Python que hay en los repositorios es la 3.5.2. Lo mismo nos pasaría si tuviésemos un Debian Jessie que no podamos actualizar.

Por tanto, no podemos utilizar versiones “oficiales” de Python. ¿Qué soluciones nos quedan?

A bote pronto, se me ocurren tres:

• Utilizar un repositorio PPA.
  He consultado varios y o bien no contienen software para procesadores ARM o bien no funcionan con mi distribución.
• Compilar Python 3.5. desde *código fuente.
  Es una posibilidad, pero bastante engorrosa.
• Utilizar PyEnv.
  Este entorno nos permite tener múltiples instalaciones de Python en paralelo sin interferir con los paquetes “oficiales” del sistema.

Por tanto, elegiremos la tercera opción por ser la menos “invasiva” para no liarla con el sistema.

Guía de instalación

Esta guía está pensada para instalar la última versión de HomeAssistant desde cero, en un sistema (Debian Jessie, Ubuntu 16.04, etc) que no soporte de forma nativa la última versión de Python. En caso de tener ya un sistema con HomeAssistant instalado, habría que saltarse algunos pasos.

Crear el usuario homeassistant

Lo primero que necesitaremos (si no lo tenemos ya) es crear un usuario específico para ejecutar HomeAssistant. En los ejemplos de este artículo lo denominamos homeassistant, pero el nombre es lo de menos.

Para ello, seguiremos los siguientes pasos:

1. Entramos como root en el sistema y creamos un nuevo usuario:

   # adduser homeassistant
   

2. Lo añadimos al grupo sudo:

   # apt-get install sudo
   # usermod -aG sudo homeassistant
   

Instalar PyEnv

PyEnv nos permite instalar (compilándola) cualquier versión de python de forma no intrusiva en el sistema,
y nos permite especificar con qué versión queremos trabajar de forma global para todo el sistema o para
una aplicación concreta.

Para instalarlo seguiremos los siguientes pasos:

1. Iniciamos sesión con el nuevo usuario homeassistant.
2. Descargamos pyenv desde su proyecto en GitHub, creando un directorio .pyenv en el home del usuario:

   $ git clone https://github.com/pyenv/pyenv.git .pyenv
   

3. Lo hacemos accesible desde el login, añadiendo al fichero .bashrc las siguientes líneas:

   export PYENV_ROOT="$HOME/.pyenv"
   export PATH="$PYENV_ROOT/bin:$PATH"
   if command -v pyenv 1>/dev/null 2>&1; then
    eval "$(pyenv init -)"
   fi
   

4. Salimos del shell (logout o exit) e iniciamos sesión de nuevo con el usuario homeassistant para que se ejecuten los cambios.
5. Instalamos una serie dependencias necesarias. HomeAssistant requiere en principio compilar python con soporte para SQLite3:

   $ sudo apt-get install libsqlite3-dev
   

6. Instalamos la versión requerida de Python. Lo que hace PyEnv es descargarse los fuentes de la versión requerida de Python y compilarla de forma transparente para el usuario. En este ejemplo instalaremos la versión 3.5.5:

   $ pyenv install 3.5.5
   

7. Establecemos la versión global de python del sistema
   Para ver qué versión de python utiliza el sistema, utilizaremos este comando:

   $ pyenv global
   

   Para ver qué versiones hay instaladas, utilizaremos este otro:

   $ pyenv versions
   

   Para establecer la versión 3.5.5 como global, utilizaremos este:

   $pyenv global 3.5.5
   

Configurar entorno virtual

Una vez que tenemos nuevo python en la oficina, lo más apropiado sería crearnos un entorno virtual para la instalación y ejecución de HomeAssistant.

El entorno virtual nos permite independizar las librerías y ejecutables asociadas a un programa del resto del entorno de python del sistema. Una especie de “caja negra” en la que entraremos cada vez que queramos ejecutar la aplicación.

Para este cometido, existe un plugin para PyEnv que se denomina virtualenv:

1. Instalamos el plugin virtualenv:

   $ git clone https://github.com/pyenv/pyenv-virtualenv.git $(pyenv root)/plugins/pyenv-virtualenv
   

2. Creamos un entorno virtual de python para HomeAssistant:

   $ pyenv virtualenv 3.5.5 home-assistant
   

   El entorno virtual residirá en el directorio /home/homeassistant/.pyenv/versions/home-assistant
3. Activamos el entorno recién creado:

   $ pyenv activate home-assistant
   

   Tras hacer esto, en el prompt se nos indica el entorno en el que estamos trabajando:

   (home-assistant) homeassistant@mi-servidor:~$
   

   Todos los comandos relativos a python que se ejecuten a partir de ahora sólo afectarán al entorno activo.

Instalar HomeAssistant

Para instalar HomeAssistant en el entorno virtual de Python activo hacemos lo siguiente:

1. Instalar paquetes adicionales:
   Serán necesarios los siguientes paquetes antes de nada:
   
   

   $ sudo apt-get install libssl-dev openssl libmariadb-dev
   $ sudo apt-get install libncursesw5-dev libgdbm-devlibc6-dev
   $ sudo apt-get install libffi-dev zlib1g-dev bzip2 libbz2-dev libreadline-de

2. Instalar librerías necesarias de forma manual. Estas dos librerías nos harán falta para ejecutar HomeAssistant:

   $ pip3 install mysqlclient
   $ pip3 install pyserial
   

3. Instalar el paquete:

   $ pip3 install homeassistant
   

4. Instalar dependencias automáticas:
   Una vez instalado el paquete, lanzaremos el ejecutable por primera vez para que se autoinstalen las dependencias de python adicionales necesarias. Este proceso puede tardar un rato y nos presenta el log por la salida estandar:

   $ hass
   

   Una vez que el proceso ha acabado, podemos probar que todo ha ido bien accediendo mediante un navegador a la siguiente URL:
   http://[DIR_SERVIDOR]:8123
5. Instalar el servicio. Para facilitarnos la vida, vamos a crearnos un servicio para poder iniciar y detener a nuestra voluntad el HomeAssistant. Para ello:
   1. Copiamos el siguiente texto en el fichero /etc/init.d/hass:

      #!/bin/sh
      ### BEGIN INIT INFO
      # Provides:          hass
      # Required-Start:    $local_fs $network $named $time $syslog
      # Required-Stop:     $local_fs $network $named $time $syslog
      # Default-Start:     2 3 4 5
      # Default-Stop:      0 1 6
      # Description:       Home\ Assistant
      ### END INIT INFO
      
      # /etc/init.d Service Script for Home Assistant
      
      RUN_AS="homeassistant"
      export PYENV_ROOT="/home/$RUN_AS/.pyenv"
      HASS_ROOT="$PYENV_ROOT/versions/home-assistant"
      PRE_EXEC="$HASS_ROOT/bin/python3"
      HASS_BIN="$HASS_ROOT/bin/hass"
      PID_DIR="/tmp"
      PID_FILE="$PID_DIR/hass.pid"
      CONFIG_DIR="/var/lib/home-assistant"
      LOG_DIR="/var/log"
      LOG_FILE="$LOG_DIR/hass.log"
      FLAGS="-v --config $CONFIG_DIR --pid-file $PID_FILE --log-file $LOG_FILE --daemon"
      
      start() {
      if [ -f $PID_FILE ] && kill -0 $(cat $PID_FILE) 2> /dev/null; then
        echo 'Service already running' >&2
        return 1
      fi
      echo -n 'Starting service' >&2
      local CMD="$PRE_EXEC $HASS_BIN $FLAGS;"
      su -s /bin/bash --preserve-environment -c "$CMD" $RUN_AS
      if [ $? -ne 0 ]; then
        echo "Failed" >&2
      else
        echo "Done" >&2
      fi
      }
      
      stop() {
      if [ ! -f "$PID_FILE" ] || ! kill -0 $(cat "$PID_FILE") 2> /dev/null; then
        echo 'Service not running' >&2
        return 1
      fi
      echo -n 'Stopping service' >&2
      kill $(cat "$PID_FILE")
      while ps -p $(cat "$PID_FILE") > /dev/null 2>&1; do sleep 1;done;
      rm -f $PID_FILE
      echo 'Done' >&2
      }
      
      install() {
      echo "Installing Home Assistant Daemon (hass)"
      update-rc.d hass defaults
      mkdir -p $CONFIG_DIR
      chown $RUN_AS $CONFIG_DIR
      mkdir -p $LOG_DIR
      chown $RUN_AS $LOG_DIR
      }
      
      uninstall() {
      echo "Are you really sure you want to uninstall this service? The INIT script will"
      echo -n "also be deleted! That cannot be undone. [yes|No] "
      local SURE
      read SURE
      if [ "$SURE" = "yes" ]; then
        stop
        echo "Notice: The config directory has not been removed"
        echo $CONFIG_DIR
        echo "Notice: The log directory has not been removed"
        echo $LOG_DIR
        update-rc.d -f hass remove
        rm -fv "$0"
        echo "Home Assistant Daemon has been removed. Home Assistant is still installed."
      fi
      }
      
      case "$1" in
      start)
        start
        ;;
      stop)
        stop
        ;;
      install)
        install
        ;;
      uninstall)
        uninstall
        ;;
      restart)
        stop
        start
        ;;
      *)
        echo "Usage: $0 {start|stop|restart|install|uninstall}"
      esac
      

   2. Le damos permisos de ejecución:

      $ sudo chmod +x /etc/init.d/hass
      

   3. Iniciamos el servicio, inicializando previamente el fichero de log:

      $ sudo touch /var/log/hass.log
      $ sudo chown homeassistant:homeassistant /var/log/hass.log
      $ sudo service hass start
      

   4. Una vez probado que funciona correctamente (ver el log en /var/log/hass.log), activamos el arranque automático del servicio, bien mediante la herramienta rcconf o bien mediante el propio servicio:

      $ sudo service hass install
      

Configuración

La configuración y el directorio de trabajo configurados por defecto están en la ruta:

/home/homeassistant/.homeassistant

El fichero de configuración principal se denomina configuration.yaml.

Actualizaciones

Con este pequeño tutorial hemos instalado la última versión de HomeAssistant en nuestro sistema. En caso de que aparezcan nuevas versiones, siempre y cuando no aumente la versión requerida de Python, podremos actualizar nuestra instalación siempre de esta manera:

1. Iniciamos sesión con el usuario homeassistant.
2. Activamos el entorno virtual de python:

   $ pyenv activate home-assistant
   

3. Actualizamos a la última versión, deteniendo previamente el servicio e iniciándolo después:

   $ sudo service hass stop
   $ pip3 install --upgrade homeassistant
   $ sudo service hass start