Autonome Home Assistant-robot

Over dit project

1. Inleiding

Ontmoet O'nine! Een persoonlijke robot voor thuis die zich kan verplaatsen, voorwerpen kan oppakken en voor je huis kan zorgen. Dankzij Alexa kan O'nine je horen en programmeerbare taken uitvoeren, zoals het voeren van je vissen.

Dit project hoopt de mogelijkheden van Alexa uit te breiden door een schaalbaar en open robotplatform te bieden dat dynamische taken kan uitvoeren in een slimme thuisomgeving. Huidige smart home-oplossingen vereisen op maat gemaakte rigs die speciaal zijn ontworpen voor een specifieke functie. O'nine wil deze kloof overbruggen door deze hardwarevereisten te minimaliseren en robotica als alternatief te gebruiken. Het idee is om een ​​technologisch bewezen platform te creëren om de haalbaarheid en levensvatbaarheid te testen van het gebruik van robots als een ander onderdeel van een domoticasysteem. Hopelijk kunnen we vragen beantwoorden als "Heeft het zin om een ​​robot te gebruiken om AC-units uit te schakelen in plaats van microcontrollers in elke kamer te monteren om elke AC-unit te besturen? " omdat wat vroeger een statische oplossing was, nu mobiel kan zijn met behulp van een robot.

Hier is een video van O'nine die mijn vissen voedt.

TL;DW (Time-Lapse-video)

Volledige video.

Wil je kijken bij je baby of wie er voor de deur staat? O'nine heeft een ingebouwde camera, dus je kunt hem ook vragen om een ​​foto te maken.

In deze tutorial leer je hoe je de robot bouwt en hoe je een Alexa Skill maakt die de robot kan bevelen om autonome taken uit te voeren.

2. Architectuur op hoog niveau

Samengevat, hier is hoe O'nine - Alexa-integratie werkt:

1. Amazon Echo Dot luistert naar spraakopdrachten.

2. Aangepaste Alexa-vaardigheid detecteert intentie.

3. De AWS Lambda-functie ontvangt een verzoek van Amazon Alexa Skill en publiceert deze naar de PubNub MQTT-makelaar.

4. O'nine ontvangt gegevens door zich te abonneren op de MQTT-makelaar.

5. O'nine voert de vereiste taak autonoom uit.

3. Hardware

3.1 Robotbasis

Sluit de componenten aan zoals hieronder getoond. Dit circuit vertaalt alle snelheidscommando's die door ROS Navigation Stack worden verzonden in motorbewegingen. De firmware bevat een PID-controller om de vereiste snelheid te handhaven met behulp van de feedback van de motor-encoders.

Een paar foto's van de geassembleerde robotbasis.

Het robotchassis is een upcycled A4 blikken container. Je kunt ook een oude plastic container gebruiken om je componenten in op te bergen.

Je kunt mijn Linorobot-project bekijken voor een uitgebreide tutorial over het bouwen van DIY ROS-compatibele robots.

3.2 Verticaal Optillen Circuit (Arm Ouder)

Sluit de componenten aan zoals hieronder getoond. Dit circuit regelt de verticale lift van de arm en vertaalt de vereiste hoogte die door http://moveit.ros.org/ wordt verzonden in stappen van de stappen. Dit is een Open-Loop-systeem dat de huidige hoogte van de arm berekent door het aantal uitgevoerde stappen in millimeters te correleren met de afstand. De microcontroller geeft ook de gegevens door die door MoveIt zijn verzonden naar de robotarm die op het bewegende verticale platform is gemonteerd.

Hier zijn foto's van het gemonteerde circuit voor de verticale lift.

De spiraalkabel bevat de Tx/Rx-draden voor seriële communicatie tussen het verticale liftcircuit en de robotarmcontroller, en +12V DC-voeding om de robotarm te voeden.

3,3 Robot Arm Controller ( Arm Kind )

Sluit de componenten aan zoals hieronder getoond na het monteren van de robotarm en het stapelen van het schild op Arduino Uno. Dit circuit communiceert met de ouderarm via seriële communicatie. De ontvangen gegevens zijn een reeks vereiste hoeken voor elke verbinding die wordt gebruikt om de servomotoren aan te drijven.

Hier zijn foto's van de geassembleerde robotarmcontroller gestapeld op een Arduino Uno.

En nog een paar om de rest van O'nine's mechanische onderdelen te laten zien.

3.4 Integreer alle circuits

Sluit ten slotte alle circuits aan die u eerder met elkaar hebt verbonden, zoals hieronder wordt weergegeven. Het diagram laat ook zien hoe elk circuit van stroom moet worden voorzien:

4. Software

Houd er rekening mee dat dit project op twee Linux-machines moet worden uitgevoerd (Ubuntu 14.04 of 16.04). Eén ontwikkelmachine om MoveIt en datavisualisatie (Rviz) uit te voeren en een andere machine (ARM-ontwikkelbord) om het navigatiepakket en de hardware-/sensorstuurprogramma's van de robot uit te voeren.

Klik hier voor door ROS ondersteunde ontwikkelborden die je voor de robot kunt gebruiken (bij voorkeur 2GB RAM).

4.1 ROS-installatie

Installeer ROS op beide machines:

git-kloon https://github.com/linorobot/rosmecd rosme./install 

Het installatieprogramma detecteert automatisch het besturingssysteem en de architectuur van de machine, zodat u zich geen zorgen hoeft te maken welke versie van ROS u moet installeren.

4.2 ROS Pakketten Installatie

4.2.1 Installeer het volgende op de ontwikkelmachine:

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

4.2.2 Linorobot installeren op de computer van de robot (robotbasis):

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

Hiermee worden de firmware, navigatiesoftware en hardware-/sensorstuurprogramma's van de robotbasis geïnstalleerd.

4.2.3 Installeer het pakket van O'nine op beide machines:

cdgit-kloon https://github.com/grassjelly/onine_installcd onine_install./install 

Hiermee worden de firmware van de robotarm, de kinematica-oplosser en de autonome taken van Onine geïnstalleerd.

4.2.4 Installeer alexa_tasker:

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

Hiermee wordt de MQTT-client gedownload die de O'nine en Alexa met elkaar verbindt. Het pakket bevat ook de NodeJS-app die wordt gecomprimeerd als een zipbestand en wordt geüpload in AWS Lambda.

5. Software-instelling

5.1 Instelling Omhoog Alexa-vaardigheid

5.1.1 Aanmelden en inloggen

Maak hier een Alexa-ontwikkelaarsaccount aan en klik op 'Start een Vaardigheid' :

Toets uw e-mailadres en wachtwoord in:

5.1.2 Een Alexa-vaardigheid starten

Klik op 'Ophalen Begin' Onder Alexa Skills-kit.

Klik op 'Toevoegen een Nieuw Vaardigheid' om de boven goed van de venster:

5.1.3 Vaardigheidsinformatie

Vink 'Aangepast aan Interactie Model' onder Vaardigheidstype.

Toets de naam van je vaardigheid in (optioneel je robotnaam) onder 'Naam'.

Toets de aanroepnaam van je vaardigheid in (naam om je vaardigheid te activeren) onder 'Aanroep Naam'.

Klik op 'Volgende'.

5.1.4 Interactiemodel

Kopieer en plak de codes van https://github.com/grassjelly/onine_alexa/blob/master/lamda/assets/schema.json naar 'Intent Schema' .

Kopieer en plak de codes van https://github.com/grassjelly/onine_alexa/blob/master/lamda/assets/utterances.txt naar 'Sample Uitingen'.

Klik op 'Volgende'.

5.1.5 Vaardigheidsconfiguratie

Kopieer uw App Skill ID uit de linkerbovenhoek en ga naar stap 5.2 om een ​​Lambda-functie te maken. Noteer de Amazon-bronnaam zodra u klaar bent met het maken van de functie.

Vink 'AWS . aan Lambda ARN' en toets uw ARN in op het standaardtabblad.

Klik op 'Volgende'.

5.1.6 De vaardigheid testen

Toets het spraakcommando in onder 'Enter Uiting' en klik op ' Vraag '

U kunt controleren of uw vaardigheid werkt als er een antwoord is onder 'Service Reactie'.

5.2 Instelling Lambda-functie omhoog

5.2.1 Aanmelden en inloggen

Maak hier een AWS Lamda-account aan en klik op 'Ondertekenen In naar Console' om de boven goed van de venster :

Toets je e-mailadres en wachtwoord in.

5.2.2 Lambda-functie maken

Klik op 'Maken Functie' rechtsboven in het venster om de Lambda-functie te maken.

Kies 'NodeJS 4.3' onder Runtime*.

Kies 'Kies een bestaand rol' onder Rol*.

Kies 'lambda_basic_execution' onder Bestaande rol*.

Klik op 'Functie maken' .

5.2.3 Alexa koppelen

Voeg een trigger toe en kies 'Alexa Vaardigheden Kit'

Toets je Alexa Skill 'vaardigheids-ID' in onder Vaardigheids-ID.

klik vervolgens op 'Toevoegen'.

5.2.4 Upload de app

Kopieer en plak de Pub-Sub-sleutels van uw PubNub in de functiecode voordat u de functie maakt.

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

Genereer nu het zip-bestand dat naar AWS Lambda wordt geüpload:

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

Dit comprimeert de lambda-functie en node_modules die nodig zijn in een .zip

Kies bij Functiecode 'Uploaden een .ZIP Bestand' onder Code-invoertype.

Klik op 'Uploaden' en kies Onine.zip dat eerder is gemaakt om te uploaden.

Klik op 'Opslaan' om de boven goed van de venster.

Nu is je Lambda-functie klaar.

5.3 PubNub-account aanmaken

5.3.1 Aanmelden en inloggen

Maak hier een PubNub-account aan.

Voer uw e-mailadres en wachtwoord in:

5.3.2 Een nieuwe PubNub-app maken

Klik op 'Maken Nieuw APP' om de boven goed van de venster :

Toets de naam van uw app in onder 'App Naam' :

5.3.3 Neem uw publicatie- en abonnementssleutels op.

5.3.4 Voer op deze regels uw publish- en subscribe-sleutels in.

5.4 Creëren Pusover Meldingen

O'nine gebruikt Pushover om foto's naar de telefoon van de gebruiker te sturen. Meld u hier aan voor een account en download de app zodat u foto's van O'nine kunt ontvangen als u hem vraagt ​​om iets in huis te controleren.

5.4.1 Inloggen bij Pushover

en toets je e-mailadres en wachtwoord in:

Noteer uw gebruikerssleutel zodra u succesvol bent ingelogd.

5.4.2 Een applicatie maken

Klik op 'Apps &plug-ins' aan de bovenkant van het venster. Klik op 'Maken een Nieuw Toepassing / API-token' .

Toets de naam van de applicatie in onder 'Naam' .

Kies 'Toepassing' onder 'Type'.

Voer een beschrijving van de toepassing in.

Klik op 'Maken Toepassing'.

Als u klaar bent, noteert u uw API-token.

5.4.3 Kopieer en plak uw app-token en gebruikerssleutel in O'nine's 'snaptask'.

5,5 Installeren de firmwares

5.5.1 uDev-regels

De seriële poorten van de microcontrollers worden gedefinieerd met behulp van de statische namen in de roslaunch-bestanden. Om ervoor te zorgen dat de seriële poorten worden onthouden en gekoppeld aan de statische namen, moet een uDev-regel worden gemaakt. Voer de uDev-tool uit op de computer van de robot.

 rosrun lino_udev lino_udev.py 

Sluit het Teensy-bord van de robotbasis aan en toets "linobase" in. Doe hetzelfde voor het verticale liftcircuit en noem het "oninearm". Sla uw uDev-regels op door op CTRL+C te drukken.

Kopieer de opgeslagen udev-regels naar /etc/udev/rules.d:

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

Start udev opnieuw:

sudo-service udev opnieuw ladensudo-service udev opnieuw opstarten 

Bevestig of de uDev-regels werkten:

ls /dev/linobasels /dev/oninearm 

Als de poorten niet zijn gedetecteerd, start u de computer van de robot opnieuw op en controleert u opnieuw.

5.5.2 Firmware van robotbasis uploaden

Voordat u de firmware van de robotbasis uploadt, moet u de specificaties van uw componenten definiëren, zoals de wieldiameter, de PPR van de encoder, enz. Klik hier om uw robot te configureren.

Sluit het Teensy-bord van de robotbasis aan op de computer van de robot en voer het volgende uit:

roscd linorobot/firmware/teensyplatformio run --target upload 

5.5.3 Firmware van verticale lift uploaden

Sluit het Teensy-bord van de verticale lift aan op de computer van de robot en voer het volgende uit:

cdplatformio run --target upload 

5.5.4 Firmware van robotcontroller uploaden

Sluit de Arduino Uno aan op de computer van de robot en voer het volgende uit:

cdplatformio run --target upload 

Vergeet niet om de Arduino Uno los te koppelen na het uploaden van de codes, aangezien de ontvangen gegevens worden doorgegeven via het Teensy-bord van de Vertical Lift met behulp van seriële communicatie.

5.6 Bewerken Linorobot's codes

Je moet een paar regels in de startbestanden van Linorobot (robotbasis) bewerken om de stuurprogramma's toe te voegen die nodig zijn om Onine uit te voeren.

5.6.1 Voeg het volgende toe na deze regel in bringup.launch.

Dit voegt het softwarepakket toe dat nodig is om met de microcontroller van de verticale lift te praten en dat van Onine de transformaties van Onine definieert (locatie van de mechanische onderdelen van Onine in de 3D-ruimte).

5.6.2 Verander deze regel in:

Dit is om een ​​virtueel frame te maken dat zal worden gebruikt om de puntenwolkgegevens die van de Kinect zijn gelezen te vertalen naar een 2D-laserscangegevens.

5.6.3 Geef commentaar op deze regel, aangezien de transformaties voor deze link al zijn gedefinieerd in het URDF-bestand van Onine.

5.6.4 Vervang de volgende regels door:

Dit voert het softwarepakket uit om de pointcloud-gegevens die van de Kinect zijn gelezen te vertalen naar een 2D-laserscangegevens.

5.6.5 Vervang het basisreferentieframe van Linorobot van base_link naar base_footprint:

Wijzigen van 'base_link ' naar 'base_footprint ' op het volgende:

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 - regel 90

linorobot/src/lino_base_node.cpp - lino 111

5.6.6 Het odometrieknooppunt opnieuw compileren:

cd ~/linorobot_wscatkin_make 

5.7 Instelling omhoog O'nine's voorwerp detector

Om het voor O'nine gemakkelijker te maken om objecten te detecteren, gebruikt het AR-tags om interessante objecten te onderscheiden bij het uitvoeren van pick-and-place-taken. Soortgelijk concept als deze robots:

Druk de onderstaande afbeelding af en plak deze op het object dat u door O'nine wilt laten ophalen. De afmeting van de afbeelding moet 2 cm x 2 cm zijn. Deze getallen zijn willekeurig, vergeet niet om de dimensie in het startbestand van Onine's tracker te wijzigen.

De gebruikte perceptiesoftware is http://wiki.ros.org/ar_track_alvar . Dit kan eenvoudig worden vervangen als u liever uw eigen objectdetectiesoftware gebruikt of andere ROS-compatibele pakketten gebruikt, zoals:

http://wiki.ros.org/find_object_2d

http://wiki.ros.org/tabletop_object_detector

6. De demo uitvoeren

Zorg ervoor dat u uw netwerk configureert voordat u de demo start. Bekijk dit ROS-netwerk voor een uitgebreidere zelfstudie.

6.1 Creëren de kaart

O'nine gebruikt een vooraf gemaakte kaart om zichzelf te lokaliseren en zijn pad te plannen wanneer hij door het huis navigeert. Voer het volgende uit om een ​​kaart te maken:

Open op de computer van de robot 2 nieuwe terminalvensters. Voer bringup.launch uit:

roslaunch linorobot bringup.launch 

Voer slam.launch uit:

roslaunch linorobot slam.launch 

Open op uw ontwikkelcomputer 2 nieuwe terminalvensters:Voer teleop_twist_keyboard uit:

rosrun teleop_twist_keyboard teleop_twist_keyboard.py 

Voer rviz uit:

roscd lino_visualize/rvizrviz -d slam.rviz 

Gebruik teleop_twist_keyboard om de robot rond het gebied te rijden dat je in kaart wilt brengen.

Als u klaar bent met in kaart brengen, slaat u de kaart op door map_server op de computer van de robot uit te voeren:

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

Controleer of map.pgm en map.yaml zijn opgeslagen:

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

Change the invoked map on navigate.launch to load your own map. Change 'house.yaml' to 'map.yaml' .

6.2 Getting target goal coordinates

When you ask O'nine to perform a task that requires autonomous navigation within the house, it has to know the coordinates of the point where it has to do the job.

You can echo these coordinates by subscribing to move_base_simple/goal and pointing the target location in Rviz.

SSH to the robot computer and run the following:

Run bringup.launch:

roslaunch linorobot bringup.launch 

On another terminal run the navigation stack:

roslaunch linorobot navigate.launch 

Run Rviz on your development computer:

roscd lino_visualize/rvizrviz -d navigate.rviz 

Open another terminal on your development computer and run:

rostopic echo move_base_simple/goal 

This will echo the coordinates and heading of the target pose that you will click on Rviz.

On Rviz, click the point that is approximately 1 meter away from where you want the robot to perform the task and drag towards where the robot is supposed to face when it has reached it's goal. (1 box in Rviz is equals to 1 square meter).

Copy the coordinates on the window where you echo '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.

Schema's