Ajouter un contrôle Alexa personnalisé au projet Raspberry Pi : 5 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:06

Ce projet est destiné à tous ceux qui ont un projet Raspberry Pi qui utilise Python et qui souhaitent ajouter un contrôle vocal via leurs appareils Amazon Echo existants. Vous n'avez pas besoin d'être un programmeur expérimenté, mais vous devez être à l'aise avec la ligne de commande et l'adaptation du code existant à vos besoins.

J'ai initialement lancé un projet pour permettre à mon Raspberry Pi d'être contrôlé par la voix avec Alexa afin qu'il puisse chauffer l'eau dans une bouilloire à une température spécifique. Bien que l'interaction que je voulais soit assez simple (passer un numéro d'Alexa au Raspberry Pi), il a fallu beaucoup de travail pour arriver à cet état à partir des tutoriels existants. J'espère que ce tutoriel rendra ce processus aussi rapide que possible pour les autres.

Dans mon exemple, je commence avec un Raspberry Pi Zero W avec Raspbian. J'ai un programme Python3 sur mon Pi qui est capable d'écrire du texte sur un écran SPI, et j'ai une sonde de thermomètre que je peux lire. Pour vous, ce programme peut être presque n'importe quoi, mais l'idée est que vous puissiez avoir des périphériques d'entrée que vous souhaitez lire via Alexa et/ou des périphériques de sortie que vous souhaitez contrôler à l'aide d'Alexa.

Le but est de passer d'un programme basique tel que celui décrit ci-dessus à un appareil que vous pouvez facilement contrôler avec mon Echo. En supposant que vous ayez déjà ce matériel, ce projet ne devrait pas vous coûter d'argent. En fin de compte, vous arriverez au point où vous pourrez dire des choses comme:

Moi: "Alexa, demande à mon gadget de vérifier la température sur le capteur 1."

Réponse d'Alexa: « La sonde indique 72,31 degrés. »

ou

Moi: "Alexa, dis à mon gadget d'écrire George Washington"

Réponse: L'écran connecté à mon Raspberry Pi indique désormais "George Washington"

Dans la section suivante, je décrirai ce qui doit se passer dans les coulisses pour que cela fonctionne. Si vous voulez juste que cela fonctionne sur votre projet et que vous ne vous souciez pas de la façon dont cela fonctionne, n'hésitez pas à l'ignorer (bien que cela puisse rendre les choses plus difficiles si quelque chose ne va pas).

Étape 1: Contexte

Sur cette image (crédit: https://developer.amazon.com/en-US/docs/alexa/alex… on peut voir l'architecture générale des Alexa Gadgets.

Lorsque vous dites quelque chose à votre appareil Echo, il envoie l'audio à Alexa Cloud, où il est traité et où une réponse est générée pour vous répondre. Lorsque vous demandez quel temps il fait, ce ne sont que ces deux-là en communication. Supposons maintenant que vous souhaitiez ajouter le contrôle vocal à l'un de vos petits projets sur un Raspberry Pi. Tout traiter à bord nécessiterait un matériel important et une base de code très sophistiquée pour faire avancer les choses. Une meilleure solution serait de tirer parti d'Alexa Cloud, qui est très sophistiqué et est devenu très efficace pour gérer des modèles de parole complexes. Les gadgets Alexa vous offrent un bon moyen de le faire.

Un gadget Alexa communique avec un appareil Echo via Bluetooth. Une fois cette connexion établie, les deux se transmettent des messages en utilisant le codage UTF-8. Lorsque l'Echo transmet quelque chose au gadget, cela s'appelle une directive. L'autre direction est appelée événement. Avant d'entrer dans le flux exact de tout cela, nous devons introduire un autre élément clé: les compétences Alexa personnalisées.

Alexa permet aux développeurs de créer leurs propres compétences personnalisées, ce qui leur permet de concevoir leurs propres interactions et comportements à utiliser sur tous les appareils Echo. Par exemple, un développeur pourrait créer une compétence personnalisée pour vous indiquer la distance entre deux aéroports aux États-Unis. Un utilisateur dirait: "Alexa, demande à mon calculateur de distance personnalisé quelle est la distance entre LAX et JFK" et il pourrait répondre par "2475 miles". Comment fait-il cela ? Lorsqu'un développeur crée une compétence personnalisée, il définit ce qu'on appelle des « intentions personnalisées » avec des « exemples d'énoncés » contenant des « emplacements ». Par exemple, dans cette compétence, je pourrais avoir l'intention "calc_dist" pour calculer la distance entre deux points. Un exemple d'énoncé serait « quelle est la distance entre {slot1} et {slot2} » ou « à quelle distance entre {slot1} et {slot2} ». Les fentes indiquées entre parenthèses ont des types spécifiques. Dans ce cas, ces types seraient des codes d'aéroport tels que LAX, JFK, BOS, ATL. Lorsqu'un utilisateur demande la compétence personnalisée, Alexa Cloud essaie de faire correspondre ce que l'utilisateur dit à une intention personnalisée à l'aide des exemples d'énoncés fournis et essaie de trouver des valeurs d'emplacement valides pour cette demande. Dans cet exemple, il trouverait que l'utilisateur voulait l'intention "calc_dist" et que slot1 est LAX et slot2 est JFK. À ce stade, Alexa Cloud transmet le travail au propre code du développeur. Fondamentalement, il indique au code des développeurs quelle intention il a reçue et quelles étaient toutes les valeurs d'emplacement, entre autres détails.

Le développeur peut décider où réside son code, mais une option très populaire consiste à utiliser une fonction AWS Lambda. Si vous ne savez pas ce que c'est, il s'agit essentiellement d'un service qui vous permet de télécharger du code pouvant être exécuté à tout moment, puis vous facture uniquement le temps d'exécution de votre code. Si nous continuons avec notre exemple, le code du développeur peut être une fonction Python qui reçoit les deux codes d'aéroport, recherche leurs emplacements, calcule les distances, puis renvoie une réponse à Alexa Cloud pour dire quelque chose à l'utilisateur. Alexa Cloud renverrait ensuite ces informations vocales à l'appareil de l'utilisateur et celui-ci obtiendrait la réponse.

Maintenant, nous pouvons revenir au gadget. Nous pouvons créer des compétences personnalisées conçues pour fonctionner spécifiquement avec les gadgets. Un développeur peut écrire une compétence qui envoie une directive à un gadget connecté. Cette directive a une charge utile qui peut être utilisée selon les besoins du gadget. Cette compétence peut également envoyer une directive, puis écouter un événement du gadget afin que le code de compétence puisse avoir accès aux informations envoyées depuis le gadget.

L'établissement de ce flux permet de créer un outil très puissant car des gadgets peu coûteux peuvent avoir la capacité de communiquer avec le code dans le cloud et de répondre aux commandes vocales en utilisant certaines des meilleures reconnaissances vocales disponibles.

Il est à noter que la plupart des compétences permettent différentes manières d'interagir avec elles. Par exemple, un utilisateur peut sauter directement dans une intention en disant "Alexa, demande à mon calculateur de distance personnalisé quelle est la distance entre LAX et JFK" (appelé une invocation unique) ou il peut simplement utiliser une intention de lancement: "Alexa, ouvrir mon calculateur de distance personnalisé". Ce dernier exemple serait généralement suivi par Alexa répondant avec une invite pour plus d'informations. Ce tutoriel omet intentionnellement la prise en charge de ce dernier. Plus précisément, sans modifier la fonction Lambda, vous ne pouvez appeler la compétence qu'à l'aide d'un appel unique. Ce choix de conception permet au modèle d'être plus simple (ne doit pas prendre en charge les intentions de lancement ou le flux de conversation), et j'ai découvert que je souhaitais généralement interagir avec mes gadgets à l'aide d'appels ponctuels de toute façon, car ils sont généralement plus rapides.

Étape 2: Enregistrez le gadget sur Alexa Voice Service Developer Console

Ce qui suit est une description des étapes nécessaires. J'ai créé une vidéo équivalente qui montre comment faire toutes ces étapes. Vous pouvez utiliser l'un ou l'autre, ou les deux, pour terminer cette étape.

1. Accédez à
2. Si vous n'avez pas encore de compte gratuit, créez-en un
3. Cliquez sur "Produits"
4. Remplissez les étiquettes et sélectionnez "Alexa Gadget"
5. Remplissez ce que vous voulez pour le reste des champs
6. Cliquez sur Terminer

Étape 3: créer une fonction AWS Lambda et une compétence personnalisée

Créer une compétence personnalisée sur la console de développement du kit de compétences Alexa

Le code de ce tutoriel est disponible ici

Avant de terminer cette étape, vous devrez créer un fichier.zip qui contient le package de déploiement pour la fonction AWS Lambda, comme indiqué dans le didacticiel ici.

1. Téléchargez le dossier "lambda" de mon Github qui contient "lambda_function.py" et "requirements.txt"
2. Ouvrez le terminal et modifiez le répertoire actuel pour qu'il se trouve dans ce dossier.
3. Exécutez la séquence suivante:

pip install -r requirements.txt -t skill_env

cp lambda_function.py skill_env cd skill_env zip -r../../skill-code.zip

Votre fichier.zip sera désormais situé dans le répertoire où se trouvait le dossier lambda et s'appellera "skill-code.zip".

Une note sur le coût de l'hébergement sur AWS: Ce tutoriel nécessite que vous ayez un compte AWS (gratuit à créer). Les fonctions Lambda coûtent de l'argent, cependant, leur prix actuel dans la région de la Virginie du Nord est de 0,000000208 $ par 100 ms d'utilisation avec 128 Mo de mémoire. Pour référence, chaque invocation de ma compétence facture environ 800 ms d'utilisation à ce niveau. Pour accumuler une facture de 1,00 USD, vous devrez appeler cette fonction environ 600 000 fois, ce qui (si cela vous prend 5 secondes par appel) vous prendrait plus de 34 jours d'appel ininterrompu à votre fonction. Le coût ne devrait pas être un problème important à moins que vous ne publiiez votre compétence et qu'un grand nombre de personnes commencent à l'utiliser. Si vous craignez de recevoir des factures sur AWS, envisagez de configurer des alarmes d'utilisation qui vous avertissent si l'utilisation dépasse un seuil défini.

Ce qui suit est une description des étapes nécessaires. J'ai créé une vidéo équivalente qui montre comment faire toutes ces étapes. Vous pouvez utiliser l'un ou l'autre ou les deux pour terminer cette étape.

1. Accédez à https://aws.amazon.com/ et connectez-vous à la console ou créez un compte gratuit si vous n'en avez pas
2. Recherchez et cliquez sur Lambda sous services
3. Cliquez sur "Créer une fonction"
4. Sélectionnez "Auteur à partir de zéro", donnez-lui un nom et choisissez la dernière version de Python 3 pour l'exécution
5. Remplacez "modifier le code en ligne" par "télécharger un fichier.zip" et sélectionnez le fichier.zip créé ci-dessus
6. Dans une nouvelle fenêtre, accédez à https://developer.amazon.com/alexa/console/ask et connectez-vous
7. Cliquez sur "Créer une compétence"
8. Étiquetez-le, choisissez le modèle « Personnalisé » et « Fournissez le vôtre » et cliquez sur « Créer une compétence »
9. Cliquez sur "Démarrer à partir de zéro" et cliquez sur "Choisir"
10. Sous "Intents", cliquez sur "Ajouter"
11. Créez une intention personnalisée appelée "alexa_to_pi" et remplissez "write {person}" comme exemple d'énoncé
12. Créez un emplacement d'intention appelé « personne » avec le type « AMAZON. Personne »
13. Créez une intention personnalisée appelée "pi_to_alexa" et remplissez "vérifier la température du capteur {sensor_num}
14. Créez un emplacement d'intention appelé "sensor_num" avec le type "AMAZON. NUMBER"
15. Sous Interfaces, activez "Custom Interface Controller"
16. Sous Endpoint, sélectionnez "AWS Lambda ARN" et copiez le "Your Skill ID"
17. Revenez à la console AWS
18. Cliquez sur "Ajouter un déclencheur"
19. Sélectionnez "Alexa Skills Kit", cochez "Activer" sous Vérification de l'ID de compétence, collez l'ID de compétence que vous venez de copier et cliquez sur Ajouter
20. Copiez l'ARN Lambda dans le coin supérieur droit
21. Revenez à la console développeur Alexa et collez l'ARN Lambda dans le champ "Région par défaut"
22. Sous Appel, définissez le nom d'appel de compétence sur "mon gadget"
23. Cliquez sur "Enregistrer le modèle" puis sur "Créer le modèle"
24. Cliquez sur "Test" dans les onglets supérieurs et changez le sélecteur de "Désactivé" à "Développement"
25. Notez que les journaux de la fonction Lambda se trouvent dans le service « CloudWatch » sur AWS.

Étape 4: Configurez le code sur votre Raspberry Pi

Pour que votre Raspberry Pi communique avec l'appareil Alexa, il a besoin d'un code pour faciliter la transmission d'informations via Bluetooth et le maintien de cette connexion, en plus de quelques autres fichiers. Le moyen le plus simple de commencer avec les fichiers les plus récents d'Amazon est de cloner leur référentiel Raspberry Pi Gadgets. Accédez au répertoire de votre projet actuel et exécutez

git clone

Cela chargera tout leur référentiel avec tout le code nécessaire sur votre Pi. Il contient quelques exemples de projets qui montrent certaines des capacités d'Alexa Gadgets. Si vous souhaitez plus d'informations, consultez le fichier readme sur leur page Github.

Exécutez leur fonction de configuration pour tout configurer.

cd /home/pi/Alexa-Gadgets-Raspberry-Pi-Samples

sudo python3 launch.py --setup

Suivez les invites et répondez « y » lorsqu'on vous demande si vous souhaitez configurer à l'aide de vos informations d'identification Gadget. Rappelez-vous l'ID Amazon et le secret du gadget lors de la configuration de votre gadget sur la console du développeur, car ils vous seront demandés ici. J'ai choisi le mode de transmission "bt" pour mon Raspberry Pi Zero W. BLE n'est pas pris en charge par tous les anciens appareils Echo, mais vous pouvez rechercher de quoi votre matériel est capable. Si vous utilisez votre Pi en mode bureau, Amazon vous recommande de cliquer avec le bouton droit sur l'icône Bluetooth en haut à droite et de cliquer sur "Supprimer "Bluetooth" du panneau" pour éviter les problèmes de connectivité.

Remarque: cette étape peut prendre un certain temps en fonction de la quantité à installer.

Vous aurez maintenant tous les fichiers de support nécessaires pour revenir à votre projet et commencer à ajouter les fonctions permettant la communication avec votre Echo.

Si vous le souhaitez, vous pouvez supprimer le dossier "examples" dans "Alexa-Gadgets-Raspberry-Pi-Samples/src"

Vous pouvez avoir votre code de projet où vous voulez, mais je vais créer un dossier dans le répertoire de base pour cela, vous pouvez également télécharger le dossier avec le code depuis mon Github, assurez-vous simplement de modifier les fichiers.ini comme décrit ci-dessous.

cd /accueil/pi

mkdir mon_projet cd mon_projet touchez mon_gadget.py touchez mon_gadget.ini

J'ai maintenant créé deux fichiers dans un dossier appelé "my_project". Le fichier.ini est important. Assurez-vous qu'il contient les éléments suivants et remplacez-le dans votre identifiant Amazon et votre secret de gadget:

[Paramètres Gadget]

amazonId = INSERT_AMAZON_ID_HERE alexaGadgetSecret = INSERT_ALEXA_GADGET_SECRET_HERE [GadgetCapabilities] Custom. MyGadget = 1.0

Maintenant, regardons le fichier python avant d'entrer dans les détails:

importer json

depuis agt importer AlexaGadget

classe MonGadget(AlexaGadget):

def _init_(self):

super()._init_()

def on_custom_mygadget_alexatopi(self, directive):

payload = json.loads(directive.payload.decode("utf-8")) print("Données reçues: " + str(payload)) write_text(str(payload['data']['person']['value ']))

def on_custom_mygadget_pitoalexa(self, directive):

payload = json.loads(directive.payload.decode("utf-8")) print("Received data: " + str(payload)) payload = {'data': "La sonde lit " + str(get_temp(payload ['data'] ['sensor_num']['value'])) + " degrés."} self.send_custom_event('Custom. MyGadget', 'PiToAlexa', payload) MyGadget().main()

Vous remarquerez d'abord qu'il appelle deux fonctions: write_text() et get_temp(). Dans mon code, je définis ces fonctions dans le même fichier, mais elles dépendent de mon matériel donc j'ai choisi de les omettre. J'ai joint ce fichier avec les fonctions définies pour simplement imprimer et renvoyer des données factices au cas où vous voudriez exécuter ce code exact. Je suggérerais de tester avec ce code exact avant de le modifier pour qu'il fonctionne avec votre projet. J'ai également joint le fichier.ini, mais assurez-vous d'entrer et de modifier l'ID et le secret du gadget. La fonction supérieure reçoit les données transmises par Alexa. La fonction inférieure reçoit des données dans le même format, mais l'appareil Alexa attendra cinq secondes pour qu'un événement soit renvoyé avec sa propre charge utile. Cette charge utile est spéciale en ce que l'appareil Alexa dira son contenu.

Une fois que vous avez ces fichiers, accédez au dossier "my_project" et exécutez le fichier python.

redémarrage sudo

cd /home/pi/my_project sudo python3./my_gadget.py

Si c'est la première fois que vous exécutez le programme, vous devrez le coupler à votre appareil Echo. Assurez-vous que votre appareil Echo est à proximité du Raspberry Pi, car nous devons autoriser une connexion Bluetooth.

Dans l'application Alexa sur votre appareil mobile, cliquez sur « appareils » dans le coin inférieur droit.

Cliquez sur "Echo & Alexa" en haut à gauche.

Cliquez sur votre appareil Echo.

Sous "SANS FIL", appuyez sur "Périphériques Bluetooth".

Appuyez sur « ASSOCIER UN NOUVEL APPAREIL » et vous devriez voir votre gadget dans la liste.

Appuyez sur votre gadget. Vous devriez voir le rapport Pi indiquant qu'il s'est jumelé avec succès.

Tout en regardant la sortie sur votre Pi, essayez de donner une commande vocale à l'Echo:

Vous: "Alexa, demande à mon gadget de vérifier la température du capteur un"

Si tout a fonctionné correctement, vous devriez entendre:

Echo: « La sonde indique 120 505 degrés. »

Vous: "Alexa, dis à mon gadget d'écrire à George Washington."

Le Pi doit imprimer:

Données reçues: {'data': {'person': {'name': 'person', 'value': 'George Washington', 'confirmationStatus': 'NONE'}}}

George Washington"

Étape 5: Conclusion

La vidéo présentée ici est un exemple du gadget fonctionnant avec la lecture de la température (la même sonde en F vs. C) et l'écriture des noms sur un affichage simple.

Maintenant que vous avez, espérons-le, quelque chose qui fonctionne, vous devriez essayer de le personnaliser pour rendre votre propre projet plus performant. N'oubliez pas que vous pouvez facilement modifier les intentions dans la console développeur Alexa et que tous les emplacements que vous utilisez seront transmis à votre Pi dans la charge utile. De plus, vous pouvez demander à Alexa de dire tout ce que vous voulez en modifiant simplement la charge utile que vous renvoyez dans l'événement à partir de votre code Raspberry Pi.

Veuillez noter que ce didacticiel n'est pas destiné à être la solution finale pour toutes les fonctionnalités que vous pourriez souhaiter avec un gadget Alexa. Il est intentionnellement limité à vous donner deux fonctions simples pour transmettre des données dans chaque direction entre Alexa et un gadget. Si vous souhaitez créer des modèles d'interaction plus sophistiqués, je vous encourage à lire tous les fichiers readme sur https://github.com/alexa/Alexa-Gadgets-Raspberry-P… et à essayer tous les exemples qu'ils fournissent. Je vous suggère également de lire la documentation de la boîte à outils Alexa Gadgets et de la trousse de compétences Alexa.