Controlar Raspberry Pi con Alexa

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.

Las referencias y tutoriales seguidos son los siguientes, aunque describiré algunos problemillas y cosas a tener en cuenta:

https://tutorials-raspberrypi.com/develop-your-own-raspberry-pi-alexa-skill-and-control-pi-remotely/

https://developer.amazon.com/blogs/post/Tx14R0IYYGH3SKT/Flask-Ask-A-New-Python-Framework-for-Rapid-Alexa-Skills-Kit-Development

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:

Esquema de los dispositivos
Esquema de los dispositivos

El proceso es el siguiente (siguiendo los números del esquema):

  1. 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)
  2. 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á)
  3. 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.
  4. 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.
  5. 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.
  6. 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:

Raspberry Pi: controlar Aire acondicionado con infrarrojos

Pasos necesarios

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)

Test en la consola de Amazon Developers

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):

endpoint
Mensaje recibido por Amazon

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:

Error del certificado autofirmado previo

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)

Vídeo demo

Vídeo del uso real (usando nginx), uno para encender y otro para apagar, el pitido es la respuesta del receptor del aire acondicionado, se aprecia también el led de dicho receptor como se enciende y se apaga también. Se muestra también el log de Flask Ask y nginx

Lo mejor es usar palabras de activación lo más sencillas posibles…

Encender
apagar

5 Comments

  1. Alejandro Fernandez · martes, 6 septiembre, 2022 Reply

    Buenos días @abrazalaweb,
    Estoy intentando crear una skill con ayuda de tus pasos y ya la tengo desarrollada desde el lado de alexa y desde el lado de la raspberrypi. Cuando ejecuto un comando de voz con alexa la acción correspondiente se ejecuta en la raspberry, sin embargo alexa responde «Se ha producido un error con la respuesta de la Skill que has pedido» aunque la raspberry ejecute la acción y envíe una respuesta.
    Sospecho que el JSON de respuesta que se envía desde la rasberry por medio de invocar statement esta mal conformado.
    Puedes ayudarme con este problema?

    • abrazalaweb · martes, 6 septiembre, 2022 Reply

      Hola,
      No es fácil saber qué está pasando, pero el que Alexa haya entendido la orden y la RPi la haya ejecutado es un logro. Tendrás que debuggear qué está pasando. En la RPI, en el código de la aplicación python tendrás que revisar las instrucciones que aparecen después de que se ejecute la acción, lo mejor es dejar las mínimas posibles hasta dar con la que falla (p.ej tras la acción ejecutada poner una del tipo return statement(«lo que sea…») para ir comprobando si Alexa va terminando bien o no.

      También hay que ir debuggeando a la vez lo que hace Alexa, para ello lo único disponible es la consola de desarrolladores (que imagino que estarás usando). Es mejor ir probando desde ella en lugar de hablarle al dispositivo Alexa, la consola permite escribir las cosas y obteniendo las respuestas y viendo lo que va recibiendo Alexa. Para ver lo que va haciendo el skill, en la pantalla de la consola de desarrolladores hay que marcar el cuadradillo que pone «Device Log», y así se va mostrando el log de las acciones que va tomando la Skill con una marca de tiempo. Ahí hay que buscar la que contiene el error (del tipo Directive: SkillDebugger.CaptureError y las siguientes), y ver el JSON, que proporciona la información del error, y con ello, ya se puede tratar de resolver (también se puede comprobar mirando los JSON lo que va haciendo el Skill)

      En el post, la captura de pantalla https://abrazalaweb.net/myBlog/wp-content/uploads/2021/07/image-27.png muestra la consola de desarrollador, pero la casilla o cuadradillo de de Device Log (en la parte de arriba), está desmarcada, hay que marcarla para obtener todo lo que va haciendo Alexa y ver dónde se produce el error.

      Espero que esto te pueda servir de ayuda, si no, pregunta de nuevo.

      • Alejandro · miércoles, 7 septiembre, 2022 Reply

        Muchas gracias por responder!

        El device log lo tenía habilitado. Tengo un código muy sencillo que únicamente invoca un statement con un texto, desde la raspberry se envía este json de respuesta:

        {«response»: {«outputSpeech»: {«text»: «La estufa se va a encender», «type»: «PlainText»}, «shouldEndSession»: true}, «sessionAttributes»: {}, «version»: «1.0»}
        127.0.0.1 – – [07/Sep/2022 13:25:47] «POST / HTTP/1.1» 200 –

        Me parece que no coincide en forma con el que te sale a tí en la captura.

        Desde el device log el puedo ver dos capture error. El primero se produce al poco de enviar la resquest e indica lo siguiente:
        «code»: «INVALID_SKILL_RESPONSE»

        El segundo capture error tarda un poco mas en aparecer y alexa lo envía a la raspberry:
        «code»: «INVALID_RESPONSE»

        Por eso creo que es un error de como se construye el json de respuesta. Puede haber un bug en la librería flask-ask?

        • Alejandro · miércoles, 7 septiembre, 2022 Reply

          Hola de nuevo @abrazalaweb,
          He conseguido solucionarlo, parece que hay un error en la librería flask-ask y construye mal la respuesta, lo he solucionado creando el json de respuesta de acuerdo al formato que aparece en la ducumentacuión de amazon developers y usando la función de flask jsonify que devuelve un tipo response con el diccionario que le pasas como parámetro.
          Con esto simplemente en el return en lugar de llamar a un statement llamo a la función jsonify para que construya el json.

          • abrazalaweb · miércoles, 7 septiembre, 2022

            Vaya, pues me alegro un montón de que lo hayas podido solucionar. La verdad es que versiones distintas de software introduzcan errores es un fastidio (quizá alguna actualización de flask-ask produce este error)

Responder a Alejandro Cancelar la respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Este sitio usa Akismet para reducir el spam. Aprende cómo se procesan los datos de tus comentarios.