Robot assistant domestique autonome

Applications et services en ligne

	Kit de compétences Amazon Alexa Alexa
	Amazon Web Services AWS Lambda
	Système d'exploitation du robot ROS
	API de publication/abonnement PubNub

À propos de ce projet

1. Présentation

Rencontrez O'nine ! Un compagnon robotique personnel pour la maison qui peut se déplacer, ramasser des objets et s'occuper de votre maison. Grâce à Alexa, O'nine peut vous entendre et effectuer des tâches programmables comme nourrir vos poissons.

Ce projet espère étendre les capacités d'Alexa en fournissant une plate-forme robotique évolutive et ouverte qui peut effectuer des tâches dynamiques dans un environnement de maison intelligente. Les solutions de maison intelligente actuelles nécessitent des plates-formes personnalisées conçues uniquement pour une fonction spécifique. O'nine vise à combler cet écart en minimisant ces exigences matérielles et en utilisant la robotique comme alternative. L'idée est de créer une plate-forme de démonstration technologique pour tester la faisabilité et la viabilité de l'utilisation de robots comme autre composant d'un système domotique. Espérons que nous pourrons répondre à des questions telles que "Est-il judicieux d'utiliser un robot pour éteindre les unités AC plutôt que de monter des microcontrôleurs dans chaque pièce juste pour contrôler chaque unité AC ? " car ce qui était autrefois une solution statique peut désormais être mobile à l'aide d'un robot.

Voici une vidéo d'O'nine nourrissant mes poissons.

TL;DW (Vidéo en accéléré)

Vidéo pleine longueur.

Vous voulez surveiller votre bébé ou qui est à la porte ? O'nine a un appareil photo intégré, vous pouvez donc également lui demander de prendre une photo.

Ce didacticiel vous expliquera comment construire le robot et comment créer une compétence Alexa qui peut ordonner au robot d'effectuer des tâches autonomes.

2. Architecture de haut niveau

En résumé, voici comment fonctionne l'intégration O'nine - Alexa :

1. Amazon Echo Dot écoute la commande vocale.

2. La compétence Alexa personnalisée détecte l'intention.

3. La fonction AWS Lambda reçoit la demande d'Amazon Alexa Skill et la publie sur le courtier PubNub MQTT.

4. O'nine reçoit des données en s'inscrivant au courtier MQTT.

5. O'nine exécute la tâche requise de manière autonome.

3. Matériel

Base de robot 3.1

Câblez les composants comme indiqué ci-dessous. Ce circuit traduit toutes les commandes de vitesse envoyées par la pile de navigation ROS en mouvements moteurs. Le micrologiciel comprend un contrôleur PID pour maintenir la vitesse requise en utilisant le retour des encodeurs du moteur.

Quelques photos de la base du robot assemblée.

Le châssis du robot est un conteneur en étain en papier A4 recyclé. Vous pouvez également utiliser une vieille boîte en plastique pour ranger vos composants.

Vous pouvez consulter mon projet Linorobot pour un didacticiel complet sur la façon de construire des robots compatibles DIY ROS.

3.2 Vertical Ascenseur Circuit (Bras Parents)

Câblez les composants comme indiqué ci-dessous. Ce circuit contrôle la levée verticale du bras et traduit la hauteur requise envoyée par http://moveit.ros.org/ en mouvements pas à pas. Il s'agit d'un système en boucle ouverte qui calcule la hauteur actuelle du bras en corrélant le nombre de pas effectués en distance en millimètres. Le microcontrôleur relaie également les données envoyées par MoveIt au bras robotique monté sur la plate-forme verticale mobile.

Voici des photos du circuit assemblé pour l'ascenseur vertical.

Le câble en spirale abrite les fils Tx/Rx pour la communication série entre le circuit de levage vertical et le contrôleur du bras robotique, et une alimentation +12 V CC pour alimenter le bras robotique.

3.3 Robotique Bras Contrôleur ( Bras Enfant )

Câblez les composants comme indiqué ci-dessous après avoir assemblé le bras robotique et empilé son blindage sur Arduino Uno. Ce circuit communique avec le bras parent via une communication série. Les données reçues sont un tableau d'angle requis pour chaque articulation qui est utilisée pour actionner les servomoteurs.

Voici des photos du contrôleur de bras robotique assemblé empilé sur un Arduino Uno.

Et quelques autres pour montrer le reste des pièces mécaniques d'O'nine.

3.4 Intégrer tous les circuits

Enfin, connectez tous les circuits que vous avez précédemment câblés comme indiqué ci-dessous. Le schéma montre également comment alimenter chaque circuit :

4. Logiciel

Notez que ce projet doit être exécuté sur deux machines Linux (Ubuntu 14.04 ou 16.04). Une machine de développement pour exécuter MoveIt et la visualisation des données (Rviz) et une autre machine (carte de développement ARM) pour exécuter le package de navigation du robot et les pilotes matériels/capteurs.

Cliquez ici pour les cartes de développement prises en charge par ROS que vous pouvez utiliser pour le robot (de préférence 2 Go de RAM).

Installation ROS 4.1

Installez ROS sur les deux machines :

git clone https://github.com/linorobot/rosmecd rosme./install 

Le programme d'installation détecte automatiquement le système d'exploitation et l'architecture de la machine afin que vous n'ayez pas à vous soucier de la version de ROS à installer.

4.2 ROS Forfaits Installation

4.2.1 Installez les éléments suivants sur la machine de développement :

cd ~/catkin_ws/srcgit clone https://github.com/linorobot/lino_pidgit clone https://github.com/linorobot/lino_msgsgit clone https://github.com/linorobot/lino_visualizecd .. &&catkin_make 

4.2.2 Installer Linrobot sur l'ordinateur du robot (base du robot) :

git clone https://github.com/linorobot/lino_installcd lino_install./install mecanum kinect 

Cela installe le micrologiciel de la base du robot, le logiciel de navigation et les pilotes matériels/capteurs.

4.2.3 Installer le package O'nine sur les deux machines :

clone cdgit https://github.com/grassjelly/onine_installcd onine_install./install 

Cela installe le micrologiciel du bras robotique, le solveur cinématique et les tâches autonomes d'Onine.

4.2.4 Installer alexa_tasker :

cd ~/onine_ws/srcgit clone https://github.com/grassjelly/onine_alexacdcatkin_make 

Cela télécharge le client MQTT qui relie O'nine et Alexa. Le package contient également l'application NodeJS qui sera compressée sous forme de fichier zip et chargée dans AWS Lambda.

5. Configuration du logiciel

Paramètre 5.1 En haut Compétence Alexa

5.1.1 S'inscrire et se connecter

Créez un compte développeur Alexa ici et cliquez sur 'Démarrer un Compétence' :

Saisissez votre adresse e-mail et votre mot de passe :

5.1.2 Démarrer une Skill Alexa

Cliquez sur 'Obtenir Démarré' Sous le kit de compétences Alexa.

Cliquez sur 'Ajouter un Nouveau Compétence' à le haut droit de le fenêtre :

5.1.3 Informations sur les compétences

Cochez 'Personnalisé Interaction Modèle' sous Type de compétence.

Saisissez le nom de votre compétence (éventuellement le nom de votre robot) sous 'Nom'.

Saisissez le nom d'invocation de votre skill (nom pour activer votre skill) sous 'Invocation Nom'.

Cliquez sur 'Suivant'.

5.1.4 Modèle d'interaction

Copiez et collez les codes de https://github.com/grassjelly/onine_alexa/blob/master/lamda/assets/schema.json vers 'Intent Schema' .

Copiez et collez les codes de https://github.com/grassjelly/onine_alexa/blob/master/lamda/assets/utterances.txt vers 'Sample Énoncés'.

Cliquez sur 'Suivant'.

5.1.5 Configuration des compétences

Copiez votre App Skill ID dans le coin supérieur gauche et passez à l'étape 5.2 pour créer une fonction Lambda. Prenez note du nom de la ressource Amazon une fois que vous avez terminé de créer la fonction.

Cochez 'AWS Lambda ARN' et saisissez votre ARN dans l'onglet par défaut.

Cliquez sur 'Suivant'.

5.1.6 Tester la compétence

Saisissez la commande vocale sous 'Entrée Énoncé' et cliquez sur ' Demander '

Vous pouvez vérifier si votre Skill fonctionne s'il y a une réponse sous 'Service Réponse'.

5.2 Paramètre Fonction Up Lambda

5.2.1 S'inscrire et se connecter

Créez un compte AWS Lamda ici et cliquez sur 'Signer Dans à Console' à le haut droit de le fenêtre :

Saisissez votre adresse e-mail et votre mot de passe.

5.2.2 Créer une fonction Lambda

Cliquez sur 'Créer Fonction' en haut à droite de la fenêtre pour commencer à faire la fonction Lambda.

Choisissez 'NodeJS 4.3' sous Runtime*.

Choisissez 'Choisir un existant rôle' sous Rôle*.

Choisissez 'lambda_basic_execution' sous Rôle existant*.

Cliquez sur 'Créer une fonction' .

5.2.3 Relier Alexa

Ajoutez un déclencheur et choisissez 'Alexa Compétences Kit'

Saisissez votre identifiant de compétence Alexa Skill sous ID de compétence.

puis cliquez sur 'Ajouter'.

5.2.4 Télécharger l'application

Avant de créer la fonction, copiez et collez les clés Pub-Sub de votre PubNub dans le code de la fonction.

cd ~/onine_ws/src/onine_alexa/lambda/appnano 

Générez maintenant le fichier zip qui sera chargé sur AWS Lambda :

cd ~/onine_ws/src/onine_alexa/lambda/appnpm install./zipme 

Cela compressera la fonction lambda et les node_modules requis dans un fichier .zip

Sur Function Code, choisissez 'Upload un .ZIP Fichier' sous Type d'entrée de code.

Cliquez sur 'Télécharger' et choisissez Onine.zip qui a été créé précédemment pour le téléchargement.

Cliquez sur 'Enregistrer' à le haut droit de le fenêtre.

Votre fonction Lambda est maintenant terminée.

5.3 Création d'un compte PubNub

5.3.1 S'inscrire et se connecter

Créez un compte PubNub ici.

Saisissez votre e-mail et votre mot de passe :

5.3.2 Créer une nouvelle application PubNub

Cliquez sur 'Créer Nouveau APP' à le haut droit de le fenêtre :

Saisissez le nom de votre application sous "App Nom' :

5.3.3 Enregistrez vos clés de publication et d'abonnement.

5.3.4 Saisissez vos clés de publication et d'abonnement sur ces lignes.

5.4 Création Pusover Notifications

O'nine utilise Pushover pour envoyer des photos sur le téléphone de l'utilisateur. Créez un compte ici et téléchargez l'application pour pouvoir recevoir des photos d'O'nine lorsque vous lui demandez de vérifier quelque chose dans la maison.

5.4.1 Connectez-vous à Pushover

et saisissez votre e-mail et votre mot de passe :

Enregistrez votre clé d'utilisateur une fois que vous vous êtes connecté avec succès.

5.4.2 Créer une candidature

Cliquez sur 'Applications et plugins' en haut de la fenêtre. Cliquez sur 'Créer un Nouveau Candidature / Jeton API' .

Saisissez le nom de l'Application sous 'Nom' .

Choisissez 'Application' sous 'Type'.

Saisissez une description de l'application.

Cliquez sur 'Créer Application'.

Une fois cela fait, enregistrez votre jeton API.

5.4.3 Copiez et collez votre jeton d'application et votre clé utilisateur dans la « snaptask » d'O'nine.

5.5 Installation le firmwares

5.5.1 Règles uDev

Les ports série des microcontrôleurs sont définis à l'aide de leurs noms statiques sur les fichiers roslaunch. Pour que les ports série soient mémorisés et liés à ses noms statiques, une règle uDev doit être créée. Exécutez l'outil uDev sur l'ordinateur du robot.

 rosrun lino_udev lino_udev.py 

Branchez la carte Teensy de la base du robot et entrez "linobase". Faites la même chose pour le circuit de levage vertical et nommez-le « oninearm ». Enregistrez vos règles uDev en appuyant sur CTRL+C.

Copiez les règles udev enregistrées dans /etc/udev/rules.d :

sudo cp 58-lino.rules /etc/udev/rules.d/58-lino.rules 

Redémarrer udev :

sudo service udev reloadsudo service udev redémarrage 

Confirmez si les règles uDev ont fonctionné :

ls /dev/linobasels /dev/oninearm 

Si les ports n'ont pas été détectés, redémarrez l'ordinateur du robot et vérifiez à nouveau.

5.5.2 Télécharger le firmware de la base du robot

Avant de télécharger le firmware de la base du robot, vous devez définir les spécifications de vos composants comme le diamètre de la roue, le PPR de l'encodeur, etc. Cliquez ici pour configurer votre robot.

Branchez la carte Teensy de la base du robot à l'ordinateur du robot et exécutez :

roscd linorobot/firmware/teensyplatformio run --target upload 

5.5.3 Télécharger le firmware de l'ascenseur vertical

Branchez la carte Teensy de l'ascenseur vertical à l'ordinateur du robot et exécutez :

cdplatformio run --target upload 

5.5.4 Télécharger le firmware du contrôleur de robot

Branchez l'Arduino Uno sur l'ordinateur du robot et exécutez :

cdplatformio run --target upload 

N'oubliez pas de débrancher l'Arduino Uno après avoir téléchargé les codes car les données reçues sont relayées via la carte Teensy de Vertical Lift à l'aide d'une communication série.

5.6 Modification Linorobot codes

Vous devez éditer quelques lignes dans les fichiers de lancement de Linorobot (base du robot) pour ajouter les pilotes nécessaires au fonctionnement d'Onine.

5.6.1 Ajoutez ce qui suit après cette ligne dans bringup.launch.

Cela ajoute le progiciel requis pour parler au microcontrôleur de l'ascenseur vertical et Onine définit les transformations d'Onine (emplacement des pièces mécaniques d'Onine dans l'espace 3D).

5.6.2 Remplacez cette ligne par :

Il s'agit de créer un cadre virtuel qui sera utilisé pour traduire les données de nuage de points lues à partir du Kinect en données de balayage laser 2D.

5.6.3 Commentez cette ligne car les transformations de ce lien sont déjà définies dans le fichier URDF d'Onine.

5.6.4 Remplacer les lignes suivantes par :

Cela exécute le progiciel pour traduire les données de nuage de points lues à partir du Kinect en données de numérisation laser 2D.

5.6.5 Remplacer le cadre de référence de base de Linorobot de base_link à base_footprint :

Changer de 'base_link ' à 'base_footprint ' sur ce qui suit :

linorobot/launch/amcl.launch

linorobot/launch/slam.launch

linorobot/param/navigation/global_costmap_params.yaml

linorobot/param/navigation/local_costmap_params.yaml

linorobot/src/lino_base_node.cpp - ligne 90

linorobot/src/lino_base_node.cpp - lino 111

5.6.6 Recompiler le nœud d'odométrie :

cd ~/linorobot_wscatkin_make 

5.7 Paramètre haut O'nine's objet détecteur

Pour faciliter la détection d'objets par O'nine, il utilise des balises AR pour distinguer les objets d'intérêt lors de l'exécution de tâches de prélèvement et de placement. Concept similaire à ces robots :

Imprimez l'image ci-dessous et collez-la sur l'objet que vous souhaitez qu'O'nine récupère. La dimension de l'image doit être de 2 cm x 2 cm. Ces chiffres sont arbitraires, n'oubliez pas de modifier la dimension sur le fichier de lancement du tracker d'Onine.

Le logiciel de perception utilisé est http://wiki.ros.org/ar_track_alvar . Cela peut être facilement remplacé si vous préférez utiliser votre propre logiciel de détection d'objets ou utiliser d'autres packages compatibles ROS tels que :

http://wiki.ros.org/find_object_2d

http://wiki.ros.org/tabletop_object_detector

6. Lancer la démo

Assurez-vous de configurer votre réseau avant de commencer la démo. Consultez ce réseau ROS pour un didacticiel plus complet.

6.1 Création le carte

O'nine utilise une carte pré-créée pour se localiser et planifier son chemin lors de la navigation dans la maison. Exécutez la commande suivante pour créer une carte :

Sur l'ordinateur du robot, ouvrez 2 nouvelles fenêtres de terminal. Exécutez bringup.launch :

roslaunch linorobot bringup.launch 

Exécutez slam.launch :

roslaunch linorobot slam.launch 

Sur votre ordinateur de développement, ouvrez 2 nouvelles fenêtres de terminal :Exécutez teleop_twist_keyboard :

rosrun teleop_twist_keyboard teleop_twist_keyboard.py 

Exécutez rviz :

roscd lino_visualize/rvizrviz -d slam.rviz 

À l'aide de teleop_twist_keyboard, conduisez le robot autour de la zone que vous souhaitez cartographier.

Une fois la cartographie terminée, enregistrez la carte en exécutant map_server sur l'ordinateur du robot :

rosrun map_server map_saver -f ~/linorobot_ws/src/linorobot/maps/map 

Vérifiez si map.pgm et map.yaml ont été enregistrés :

roscd linorobot/mapsls -a map.pgm map.yaml 

Modifiez la carte invoquée sur naviga.launch pour charger votre propre carte. Changez 'house.yaml' vers 'map.yaml' .

6.2 Obtenir les coordonnées de l'objectif cible

Lorsque vous demandez à O'nine d'effectuer une tâche qui nécessite une navigation autonome au sein de la maison, il doit connaître les coordonnées du point où il doit effectuer le travail.

Vous pouvez faire écho à ces coordonnées en vous abonnant à move_base_simple/goal et en pointant l'emplacement cible dans Rviz.

Connectez-vous en SSH à l'ordinateur du robot et exécutez la commande suivante :

Exécutez bringup.launch :

roslaunch linorobot bringup.launch 

Sur un autre terminal, exécutez la pile de navigation :

roslaunch linorobot naviga.launch 

Exécutez Rviz sur votre ordinateur de développement :

roscd lino_visualize/rvizrviz -d naviga.rviz 

Ouvrez un autre terminal sur votre ordinateur de développement et exécutez :

rostopic echo move_base_simple/goal 

Cela fera écho aux coordonnées et au cap de la pose cible sur laquelle vous cliquerez sur Rviz.

Sur Rviz, cliquez sur le point situé à environ 1 mètre de l'endroit où vous souhaitez que le robot exécute la tâche et faites-le glisser vers l'endroit où le robot est censé faire face lorsqu'il a atteint son objectif. (1 case dans Rviz équivaut à 1 mètre carré).

Copiez les coordonnées sur la fenêtre où vous faites écho 'move_base_simple/goal '

Edit onine/onine_apps/scripts/fishtask.py and replace Point(x,y,z) with position/x position/y, and position/z from the echoed values. Replace Quaternion(x,y,z,w) with orientation/x, orientation/y, orientation/z, and orientation/w from the echoed values.

6.3 Running O'nine

6.3.1 Open a new terminal on the development computer and run the ROSCORE:

roscore 

Open three new terminals on the development computer and SSH to the robot computer.

6.3.2 Run robot base's and robotic arm's driver:

roslaunch linorobot bringup.launch 

6.3.3 Run the navigation software on the second terminal:

roslaunch linorobot navigate.launch 

6.3.4 Run the object detection software on the third terminal:

roslaunch onine_apps ar_tracker.launch 

On the development computer open two new terminals.

6.3.5 Run MoveIt software:

roslaunch onine_moveit_config demo.launch  

This will run all the software required to move the robotic arm and open Rviz for data visualization.

6.3.6 Run the PubNub client which launches the autonomous task upon voice command through Amazon Echo Dot:

rosrun onine_alexa alexa_tasker.py 

6.3.7 Before talking to executing voice commands, you have to help O'nine localize relative to the map.

On Rviz, click '2D Post Estimate' and click on the map the approximate location of the robot and drag towards O'nine's current heading.

Once O'nine is localized, you're now ready to command Alexa to ask Onine to perform tasks.

Have fun with your new personal home assistant robot!

7. Future Works

7.1 O'nine simulation model

Building the hardware can be time consuming and tedious. I'm planning to create a Gazebo simulation model so that users can play around with O'nine without the need of a hardware. This way, O'nine's Alexa Custom skill can be tried purely with software.

7.2 Better computing power

The first ARM board I used to run O'nine was an Nvidia Jetson TK1 which comes in nifty for computer vision applications. Due to power reasons I replaced it with an Odroid XU4 as it only requires 5V and has a smaller form factor. I'm currently eyeing on a Rock64 board which has 4GB of RAM and hopefully get more juice to run more applications concurrently. The current setup requires to offload some of the applications to my laptop and has to be hardwired to the dev board (ethernet cable) as there's a huge stream of data running across both machines.

Code

O'nine Software

Alexa - Robot integration

Robot Base

Schémas