Se puede utilizar Fauxmo de Makermusings y una placa de retransmisión para «engañar» a Alexa para que piense que Raspberry Pi es un dispositivo Wemo , y activar y desactivar las cosas. Sin embargo, eso limita uno a configurar todos los dispositivos deseados alrededor de un área única que está cerca de la Raspberry Pi.
Nos gustaria a hacer lo siguiente:
- Dar el comando: «Alexa, enciende la lámpara»
- Alexa envía un comando a Raspberry Pi a través de Fauxmo
- Raspberry Pi enciende un interruptor lejano que puede estar en la cocina, pero usaría algún tipo de interruptor inalámbrico
También puede usar algo como Node-RED (viene preinstalado en raspbian) y node-red-contrib-alexa-home-skill (escribí este nodo) para enviar los mensajes y tener más control que solo las acciones que admite Wemo .
Introducción (skill propia de Alexa y servidor Flas-Ask)
Mediante un dispositivo con Alexa (amazon echo, fire tv cube, etc) podemos controlar y ejecutar acciones (scripts o programas) en una Raspberry Pi (o cualquier otro equipo). Existen numerosas formas de hacer esto, aunque después de probar muchas de ellas (que hacen que la Raspberry Pi se comporte como un dispositivo IOT que Alexa puede encontrar, tales como fauxmo, ha-bridge, etc) y que no me han funcionado, algo muy sencillo y que realmente funciona es crear una custom Skill en la web de developers de Amazon, y ejecutar en la Raspberry Pi (puede ser otro equipo) un servidor web preparado para las Skills de Alexa, en concreto Flask-Ask, (extensión del servidor Flask de python) el cual ya puede ejecutar cualquier tarea en la Raspberry Pi mediante instrucciones en python, o bien llamando directamente a ejecución de scripts, lo que abre un mundo de posibilidades. En mi caso, lo usaré para encender/apagar el aire acondicionado con la Raspberry Pi, que tiene un módulo de Infrarrojos (emisor/receptor) acoplado en los pines GPIO.
https://github.com/johnwheeler/flask-ask
https://pythonprogramming.net/intro-alexa-skill-flask-ask-python-tutorial/
Para que todo funcione correctamente, es necesaria una salida a internet real del servidor Flask-Ask. Una opción es usar ngrok en la Raspberry Pi, para probar, y finalmente, usar un dominio propio (o un ddns) que apunte a nuestro router, en el cual será necesaria una redirección de puertos (abrir puertos) del https (puerto 443 requerido por los Skills de Alexa) hacia el servidor Flask-Ask que se ejecuta en la Raspberry Pi (bajo el puerto 5000 por defecto). Es decir, en el router, tendremos que añadir una regla (servidor virtual, redirección de puertos, abrir puerto) del tipo:
puerto 443 -> Ip Raspberry pi puerto 5000.
(Nota: el ngrok hay que ejecutarlo en la Raspberry Pi especificando exactamente lo mismo, redirigiendo hacia el puerto 5000, ngrok ofrece dos direcciones, una http y otra https, siendo esta última la obligada por Amazon para las skills)
También puede hacerse, y es como lo he hecho yo y voy a mostrar, mediante un proxy inverso con nginx que se ejecuta (en mi caso en otro ordenador, y así no exponemos la Raspberry Pi a internet, sino el ordenador donde se ejecuta el nginx, algo más fortificado, el nginx también podría ponerse en la Raspberry Pi), tal como se muestra en el esquema siguiente:
El proceso es el siguiente (siguiendo los números del esquema):
- Se indica al dispositivo Alexa que invoque nuestra skill y lo que queremos que dicha skill haga (conocido como intent). En este tipo de skills, que no están publicadas en Amazon, y que son de uso particular, hay que decir algo del tipo «Alexa dile a XXX que YYY», donde XXX es el nombre de la Skill e YYY es el nombre de la acción que va a realizar (Intent), otras formas pueden ser: «Alexa di a XXX YYY», «Alexa pide a XXX que YYY»… etc, lo que he comprobado es que cuanto más sencilla sea la orden, mejor (cuantos menos artículos o determinantes se usen, mejor)
- El dispositivo Alexa se va a los servicios en la nube de Amazon, busca nuestra skill (imprescindible que la cuenta de inicio de sesión en Amazon Developers y el dispositivo Alexa sea la misma, si no es así. la skill no la encontrará)
- La Skill se comunica con un «endpoint» o servidor, que puede estar en la nube de Amazon, o en otro sitio, y tiene que ser obligatoriamente una dirección https. En nuestro caso, está en un equipo nuestro, en nuestra red local. Hay múltiples posibilidades para esto, en particular consideramos dos, una para pruebas, y otra ya definitiva. En ambos casos, exponemos el servicio de Flask Ask a internet mediante una dirección (url) https.
- ngrok (camino de color rojo en la figura anterior): lo que hace es ofrecer temporalmente una dirección de internet para el equipo donde se ejecuta (http y https), y evidentemente hay que redirigirla a un servicio de ese equipo, para ofrecer dicho servicio por internet (en nuestro caso Flask-Ask) (nota: ngrok ofrece permanencia de sus servicios mediante suscripción)
- Servidor web y reverse proxy con nginx (camino de color naranja): este caso es cuando queremos todo definitivo, y para ello exponemos a internet mediante redirección de puertos de nuestro router (abrir puerto 443 https) a otro equipo, con un servidor web y reverse proxy a la Raspberry Pi y el Flask Ask.
- La petición que hace la Skill a nuestro Flask-Ask se procesa con dicho Flask Ask, y ejecuta las acciones que hayamos programado, sean comandos directamente, la ejecución de un script, etc.
- En mi caso, Flask Ask va a ejecutar el script encender.sh o apagar.sh en función de lo que le hayamos dicho a Alexa. Estos scripts están en el post de este blog de controlar el aire acondicionado con la RPi (más abajo, en el punto siguiente). Estos scripts envían una secuencia de códigos mediante el emisor infrarrojo, que activan el receptor del aire acondicionado.
- En nuestras acciones de Flask Ask, podemos hacer que nuestro dispositivo Alexa responda con frases o pregunte otras cosas (que pueden lanzar nuevas acciones, y abriendo un mundo de posibilidades)
Lista de requerimientos necesarios
No voy a explicar en detalle cómo efectuar los siguientes pasos, ya que las referencias y tutoriales proporcionados al principio lo hacen perfectamente y con todo detalle.
- Cuenta en Amazon Developers: la misma que la que tenemos en el dispositivo Alexa (echo, fire Tv, fire Cube…) ya que es la única manera de que nuestro dispositivo Alexa «vea» el Skill que vamos a crear (https://developer.amazon.com/)
- Raspberry Pi con Flask-Ask instalado, donde vamos a ejecutar el servicio (programa) que contendrá las acciones a realizar por la Raspberry Pi cuando interprete una orden correcta dada por Alexa (y adicionalmente con el módulo de infrarrojos y toda la condfiguración necesaria para que todo funcione previamente)
- Salida a Internet del servidor Flask-Ask, para las pruebas, con ngrok. Para el uso definitivo, bien una redirección de puertos en el Router, o bien un web proxy intermediario (nginx en otro PC, o en la propia Raspberry Pi)
La configuración para usar la Raspberry Pi para controlar el Aire Acondicionado con el módulo de infrarrojos está detallada en esta entrada:
Componentes necesarios
- Skill de Alexa en amazon developers: cosas a tener en cuenta con los intents (creados por defecto)
- Aplicación Flask-Ask, que es la que va a ejecutar acciones en función de las peticiones de AWS
- Pruebas con ngrok (instalado directamente en la Raspberry Pi), con el simulador de Amazon Developers
Skill de Alexa
Existe multitud de maneras de definir un Skill de Alexa, pero básicamente consiste en tener un conjunto de acciones (Intents) que se corresponden con ciertas órdenes o palabras por voz. Esto es, al decir una palabra o frase al dispositivo Alexa, que habremos definido en la skill, se asociará al Intent correspondiente (con los valores correspondientes). Es importante tenerlos bien definidos y tmar nota de los nmbres, que se tendrán que corresponder exactamente con lo que implementemos en la aplicación de Flask-Ask.
Desde la consola de Amazon Developers creamos una nueva Skill
Tenemos que seleccionar un nombre (da igual, es simplemente para identificarla), el idioma, el tipo (por defecto aparece «Custom» y es la que usaré, y dónde van a estar alojados los recursos, que seleccionaremos nuestros propios recursos (endpoint), que aparece por defecto seleccionada.
Pulsamos el botón «crear Skill», justo arriba de la página
Ahora nos preguntará una plantilla y seleccionamos la vacía (por defecto)
Ya tenemos la Skill creada, y si accedemos a la aplicación de Alexa en nuestro dispositivo móvil, o bien a través d ela Web, ya vemos allí que tenemos la Skill de desarrollador recién creada:
La Skill «Mi primera Skill« ha sido simplemente como ejemplo, a partir de ahora, veremos la Skill RPi control, que es la que usaremos y programaremos para ejecutar cosas en la Raspberry Pi.
Una de las primeras cosas a hacer en la Skill recién creada es observar los Intents creados por defecto:
Como vemos, nos crea unos Intents requeridos que no podemos borrar, y uno por defecto llamado «HelloWorld», que tenemos que borrar, salvo que lo implementemos en nuestra aplicación Flask Ask.
Esto fue uno de mis primeros errores, como se ve en el log de la apliación Flask-Ask en la RPi:
raise NotImplementedError('Intent "{}" not found and no default intent specified.'.format(intent.name))
NotImplementedError: Intent "HelloWorldIntent" not found and no default intent specified.
Sin embargo, los Intents requeridos no los podemos eliminar, y en mi caso particular, el intent AMAZON.StopIntent me dio mucho la lata dado que, al decir «apaga», «apagar», parece ser que los servicios de Amazon lo asocian a este intent y no al mío personalizado, por lo que tenía un error similar al anterior:
Por tanto, para evitar este problema, simplemente basta con implementar en la aplicación Flask-Ask este intent requerido de Amazon para que ejecute exactamente lo mismo que el nuestro propio al escuchar «apagar» o similares.
Skill RPi control
Primero, necesitamos al menos dos palabras para invocar al Skill , yo he elegido «raspberry pi»
Muy importante y a tener en cuenta, es que, en este tipo de Skills personales, cuando hablamos al dispositivo Alexa, hay que hacerlo de la siguiente manera:
Alexa, di a XX XX que YYY, Alexa dile a XX XXX YYY, Alexa pide a XX XXX que YYY…
dado que al no estar publicado, no puede hacerse de otra forma (XX XX son las dos palabras de invocación,e YYY es la frase o utterance que hemos indicado para el Intent o Acción. Amazon así lo advierte:
Más sobre esto en https://developer.amazon.com/en-US/docs/alexa/custom-skills/understanding-how-users-invoke-custom-skills.html seleccionando las pestañas «Spanish»
No obstante, desde el simulador de la web de Amazon Developers, al testear el Skill, sí que se permiten las frases de activación usuales para skills publicados (pero que no van a funcionar al hablarle a nuestro dispositivo, p.ej. en mi caso: Alexa activa Raspberry pi, Alexa pon raspberry pi funcionará en el simulador, pero no en el dispositivo real)
Vistas las consideraciones anteriores, el Skill es extremadamente sencillo, sólo tiene una acción o Intent llamada «Aire«
con dos posibles palabras de activación (utterances), que son encender y apagar (podrían haberse hecho dos intents diferentes, etc)
Para definir este tipo de intent, primero hay que definir un «slot», que se asociará al intent. El slot simplemente contiene los valores que luego vamos a interpretar con la aplicación Flask-Ask y las frases para activarlo, así como los sinónimos:
En este caso he seguido al pie de la letra los tutoriales indicados al inicio, y tengo un slot llamado status
Tiene dos valores definidos, y ciertos sinónimos que interpretará también el Intent asignándoles el valor correspondiente (es decir, para que se interprete el valor «apagar», se pueden decir las palabras «apagar»,»quite»,»apague»,»quita»,»apaga»
Ahora puede crearse el Intent Aire y asociarlo a este slot (es sencillo, está todo guiado). Además pueden escribirse la frases (utterances) de activación de este intent añadiendo el nombre del slot (entre llaves) que se interpretarán según lo que acabamos de ver (unas palabras se asociarán a encender y otras a apagar)
Y ya está, ya tenemos nuestra Skill creada y definida. A la hora del paso siguiente, la programación de la aplicación Flask-Ask, tenemos que quedarnos con que tenemos que implementar el intent «Aire», el «AMAZON.StopIntent» y que para el intent «Aire» tendremos que implementar acciones según sea el valor de ese intent (encender o apagar)
La vista en JSON permite ver todo más claro:
{
"interactionModel": {
"languageModel": {
"invocationName": "raspberry pi",
"intents": [
{
"name": "AMAZON.CancelIntent",
"samples": []
},
{
"name": "AMAZON.HelpIntent",
"samples": []
},
{
"name": "AMAZON.StopIntent",
"samples": []
},
{
"name": "AMAZON.NavigateHomeIntent",
"samples": []
},
{
"name": "Aire",
"slots": [
{
"name": "status",
"type": "status"
}
],
"samples": [
"que {status} el aire",
" {status} el aire"
]
}
],
"types": [
{
"name": "status",
"values": [
{
"name": {
"value": "apagar",
"synonyms": [
"quite",
"apague",
"quita",
"apaga"
]
}
},
{
"name": {
"value": "encender",
"synonyms": [
"ponga",
"encienda",
"pon",
"enciende"
]
}
}
]
}
]
}
}
}
Aplicación Flask-Ask
Ahora le toca el turno a instalar en la Raspberry Pi el servidor Flask Ask y programar (python) el programa que interpretará las órdenes que le envíen los Servicios de Amazon al traducir nuestras órdenes de voz a peticiones al servidor endpoint (nuestro Flask Ask)
NOTA: en los tutoriales para instalar Flask-Ask se indica que se use una versión previa del módulo cryptography de python, porque si no se dan problemas con el SSL (ver p.ej. https://stackoverflow.com/questions/49375054/alexa-skill-development-using-flask-ask-and-ngrok). En mi caso, uso una versión de Raspbian Buster con Kernel 4.9.X porque es la única manera de que funcione el módulo de infrarrojos. La versión cryptography de este Raspbian es antigua y no da problemas.
De nuevo, siguiendo los tutoriales y adaptándolo a nuestro uso, es algo muy sencillo. Como vimos en el post d ela Raspberry Pi y el Aire acondicionado con el emisor de infrarrojos, simplemente se trata de ejecutar los scripts «encender.sh» y «apagar.sh» según corresponda.
El código es el siguiente y es trivial. Simplemente hay que tener en cuenta los valores sinónimos para tener en cuenta todos los valores posibles que ejecuten las sentencias de nuestro programa. Para cada intent (el nombre tiene que ser el mismo que hemos puesto en la Skill) se tiene que definir una etiqueta @ask.intent y a continuación una función (de nombre el que sea) que incluye lo que se va a hacer (como parámetro puede admitir los valores del slot (mismos nombres) (en mi caso el mapping es redundante y podría eliminarse, se usa cuando el nombre del slot y el tipo son distintos).
La función launch sirve para cuando se activa simplemente el Skill, y funciona desde la web de amazon developers (al decir «Alexa activa raspberry Pi» o similares, se implementa una acción de respuesta que nos pregunta qué hacer, pero esto sólo funciona en el simulador). El intent Ayuda (que era requerido) podemos indicar que haga algo, en este caso decirnos una frase (para invocarlo: «Alexa dile a Raspberry Pi ayuda«)
import logging
import os
from flask import Flask
from flask_ask import Ask, request, session, question, statement
app = Flask(__name__)
ask = Ask(app, "/")
logging.getLogger('flask_ask').setLevel(logging.DEBUG)
STATUSON = ["encender", "enciende", "pon","encienda","ponga"] # all values that are defined as synonyms in type
STATUSOFF = ["apagar", "apaga", "quita","apague","quite"]
@ask.launch
def launch():
speech_text = '¿qué quieres hacer?, ¿encender o apagar el aire?'
return question(speech_text).reprompt(speech_text).simple_card('Poner Aire Skill','Se ha iniciado')
@ask.intent('Aire', mapping = {'status':'status'})
def Aire_Intent(status):
if status in STATUSON:
os.system('./encender.sh')
return statement('El aire se va a encender')
elif status in STATUSOFF:
os.system('./apagar.sh')
return statement('El aire se va a apagar')
else:
return statement('Lo siento, no puedo hacer eso con el aire.')
@ask.intent('AMAZON.StopIntent')
def apagar():
os.system('./apagar.sh')
return statement('El aire se va a apagar')
@ask.intent('AMAZON.HelpIntent')
def help():
speech_text = 'Control Aire con la Raspberry pi!'
# return question(speech_text).reprompt(speech_text).simple_card('HelloWorld', speech_text)
return statement(speech_text)
@ask.session_ended
def session_ended():
return "{}", 200
if __name__ == '__main__':
if 'ASK_VERIFY_REQUESTS' in os.environ:
verify = str(os.environ.get('ASK_VERIFY_REQUESTS', '')).lower()
if verify == 'false':
app.config['ASK_VERIFY_REQUESTS'] = False
app.run(host='0.0.0.0',debug=True)
Evidentemente, se puede mejorar y diseñar la skill de otra manera, pero es totalmente funcional.
En muchos tutoriales, la ejecución de Flask se hace en el interfaz localhost (127.0.0.1), es decir, el servicio sólo es visible en la raspberry Pi, y esto no es problema si usamos ngrok, pero si queremos exponer el servicio a intenet ya sea mediante redirección de puertos en el router, o con el reverse proxy nginx, entonces tendremos que ejecutar la aplicación para que escuche en todos los interfaces o bien en la ip de la raspberry pi, indicando la ip ‘0.0.0.0’
app.run(host='0.0.0.0',debug=True)
Ejecutamos la aplicación en la raspbery pi y ya tenemos el servidor Flask-Ask esperando peticiones desde internet.
Para dejarlo ejecutándose en segund plano y poder cerrar la terminal (sesión ssh) basta el comando siguiente (redirigiendo la salida a un archivo de texto, para ver los logs)
nohup python3 aire.py > flask-ask.log &
Los archivos que hay en mi Raspberry Pi son los siguientes, los scripts y archivos necesarios para encender/apagar el aire acondicoinado con el módulo ir (utilidad irr.py y asociados), ngrok y la aplicación aire.py
Podemos comprobar que está funcionando correctamente accediendo desde un navegador web a la ip de la Rasperry Pi y el puerto 5000. El resultado con el error 405 es correcto:
Pruebas con ngrok
En la definición del Skill en la web de Amazon Developers, nos faltaba algo muy importante, y es indicar el «endpoint» de nuestro Skill, que en este caso es el servicio Flask-Ask (la aplicación aire.py) que se está ejecutando en la Raspberry Pi
Instalar ngrok es trivial, simplemente se descarga de su web, se descomprime y se ejecuta, redirigiendo http al puerto 5000 que es donde se está ejecutándose la aplicación de Flask-Ask aire.py.
ngrok http 5000
Con ambas aplicaciones ejecutándose, vamos a la web de Developer de Amazon y le indicamos a nuestra skill que el endpoint es la dirección http que nos proporciona ngrok, y que el certificado es el de un subdominio (tenemos que poner la dirección que nos da ngrok, en la imagen siguiente se pone una de ejemplo):
Una vez guardado todo, llega el momento de compilar la Skill, dando al menú Build en la consola de Amazon Developer. Cuando nos avise de que ya está, podemos ir a la pestaña de test y empezar a comprobar si funciona o tenemos errores (hay que ver los logs en la consola de developer y los de Flask-Ask y ngrok en la Raspberry Pi)
Usar la consola de test es muy sencillo. POdemos usar el micrófono del PC o bien escribirlo, el PC nos responderá como si fuera el dispositivo Alexa. Una vez solucionados los posibles errores, ya puede uno dirigirse directamente al dispositivo Alexa con la voz.
Voy a mostrar algunas capturas del proceso y las comprobaciones de cómo funcionan las cosas (algún error también se muestra de mis pruebas)
Enviar una instrucción al skill (vemos la respuesta satisfactoria)
El log muestra que se ha capturado ese texto (comando por voz), que se envía a nuestro endpoint, y cómo se interpreta y trduce en parámetros de la skill (intent, slot y valor):
A continuación, se muestra el log de cómo se ha interpretado correctamente la orden, y traducido a parámetros de ls¡a Skill, que el programa Flas-Ask va a usar.
Un ejemplo de cómo en la consola de Developer de Amazon funciona invocar el Skill directamente (que lanza la función @launch de la aplicación Flask-Ask). Pero esto no funciona en el dispositivo real (Alexa nos contestará que no encuentra a Raspberry PI, o bien, en mi caso que es un Fire Cube, conectado a la TV, me hace una búsqueda en la TV)
NGINX y Reverse Proxy (dominio particular)
Ahora se trata de sustituir la funcionalidad de ngrok por nuestro propio dominio, certificado SSL (en mi caso uno autofirmado) y nginx como reverse proxy para redirigir el tráfico https al puerto 5000 donde está ejecutándose Flask-Ask.
El proceso es muy sencillo, el habitual para usar nginx como reverse proxy.
Necesario:
- Dominio propio (o bien un DDNS) que resuelve a nuestra ip pública
- Redirección del puerto https (443) en nuestro router a la ip de la Raspberry Pi en el puerto 5000 (abrir puerto 443 en el router)
- certificado SSL autofirmado (o bien uno tipo Let’s Encrypt, que será aceptado por Amazon).
- Configurar el Skill para que use como endpoint nuestro dominio, y como certificado SSL, subirle el nuestro autofirmado.
La configuración de nginx es simple (hay muchos tutoriales en internet), en mi caso, nginx configura los distintos «sitios» en los archivos en «sites-enabled» (en particular el default)
Tan sólo hay que tener en cuenta el nombre de nuestro dominio, la ip local de la Raspberry Pi (192.168.1.99 en mi caso), y dónde hemos guardado los archivos con las claves pública y privada del certificado SSL (ver notas SSL a continuación)# Default server configuration # server { listen 443 ssl; server_name XXXXXXXXXXXXXXXXX.es; ssl_certificate /XXX/XXX/certificate.pem; ssl_certificate_key /XXX/XXX/private-key.pem; ssl_protocols TLSv1.2; ssl_ciphers HIGH:!aNULL:!eNULL:!EXPORT:!CAMELLIA:!DES:!MD5:!PSK:!RC4; ssl_prefer_server_ciphers on; location / { proxy_pass http://192.168.1.99:5000/; # Flask-Ask en RPi proxy_http_version 1.1; proxy_set_header Upgrade $http_upgrade; proxy_set_header Connection ‘upgrade’; proxy_set_header Host $host; proxy_cache_bypass $http_upgrade; proxy_read_timeout 120s; } }
Notas sobre SSL
The SSL handshake to endpoint Resource [https://XXXXXXX.es], Type [HTTP], Region [DEFAULT] failed. Please check that your java keystore is correctly configured"
En el caso de certificado autofirmado es necesario seguir lo indicado en la propia web de AMazon Developers: https://developer.amazon.com/en-US/docs/alexa/custom-skills/configure-web-service-self-signed-certificate.html. Yo tuve que cambiar el certificado que tenía por un problema en el mismo, que hacía que el Skill no funcionara. Obtenía el siguiente error:
Una comprobación que realicé fue con el servicio que proporciona qualys ssl labs (https://www.ssllabs.com/ssltest/) y me daba el siguiente error con el certificado SSL autofirmado que tenía previamente:
Una vez seguidos los pasos que indica Amazon (ver enlace anterior), el mismo test ya no da error, y el Skill funciona. La clave estaba en el parámetro «Alternative names»
Configurar el Skill
Simlemente volvemos a la consola de Developers de Amazon y cambiamos el Endpoint, seleccionamos certificado autofirmado. Guardamos, y una vez guardado , nos pide subir el certificado autofirmado. Todo explicado en el enlace anterior de SSL.
Ahora se vuleve a compilar la Skill (Build) y ya podemos probar que las cosas van bien (nuevo endpoint a nuestro dominio)
Mas información en https://abrazalaweb.net/2021/07/controlar-raspberry-pi-con-alexa/
Soloelectronicos.com 
Debe estar conectado para enviar un comentario.