Autonomer Heimassistent-Roboter

Apps und Onlinedienste

	Amazon Alexa Alexa Skills Kit
	Amazon Web Services AWS Lambda
	ROS-Roboter-Betriebssystem
	PubNub Publish/Subscribe-API

Über dieses Projekt

1. Einführung

Treffen Sie O'nine! Ein persönlicher Heimroboter, der sich bewegen, Gegenstände aufnehmen und sich um Ihr Haus kümmern kann. Dank Alexa kann O'nine dich hören und programmierbare Aufgaben wie das Füttern deiner Fische ausführen.

Dieses Projekt hofft, die Fähigkeiten von Alexa durch die Bereitstellung einer skalierbaren und offenen Roboterplattform zu erweitern, die dynamische Aufgaben in einer Smart-Home-Umgebung ausführen kann. Aktuelle Smart-Home-Lösungen erfordern maßgeschneiderte Rigs, die nur für eine bestimmte Funktion entwickelt wurden. O'nine möchte diese Lücke schließen, indem es diese Hardwareanforderungen minimiert und als Alternative Robotik einsetzt. Die Idee ist, eine technologieerprobende Plattform zu schaffen, um die Machbarkeit und Rentabilität des Einsatzes von Robotern als weitere Komponente eines Heimautomatisierungssystems zu testen. Hoffentlich können wir Fragen beantworten wie "Ist es sinnvoll, einen Roboter zum Abschalten der Klimaanlagen zu verwenden, anstatt in jedem Raum Mikrocontroller zu montieren, nur um jede Klimaanlage zu steuern? " denn was früher eine statische Lösung war, kann jetzt mit Hilfe eines Roboters mobil werden.

Hier ist ein Video von O'nine, der meine Fische füttert.

TL;DW (Zeitraffer-Video)

Video in voller Länge.

Sie wollen nach Ihrem Baby sehen oder wer steht vor der Tür? O'nine hat eine eingebaute Kamera, sodass Sie es auch bitten können, ein Foto zu machen.

In diesem Tutorial erfahren Sie, wie Sie den Roboter bauen und wie Sie einen Alexa-Skill erstellen, der dem Roboter befehlen kann, autonome Aufgaben auszuführen.

2. High-Level-Architektur

Zusammengefasst funktioniert die Integration von O'nine - Alexa so:

1. Amazon Echo Dot hört auf Sprachbefehle.

2. Benutzerdefinierter Alexa-Skill erkennt Absicht.

3. Die AWS Lambda-Funktion empfängt eine Anfrage von Amazon Alexa Skill und veröffentlicht sie an den PubNub MQTT-Broker.

4. O'nine erhält Daten, indem es den MQTT-Broker abonniert.

5. O'nine führt die erforderliche Aufgabe selbstständig aus.

3. Hardware

3.1 Roboterbasis

Verdrahten Sie die Komponenten wie unten gezeigt. Diese Schaltung übersetzt alle vom ROS-Navigationsstapel gesendeten Geschwindigkeitsbefehle in Motorbewegungen. Die Firmware enthält einen PID-Regler, um die erforderliche Geschwindigkeit unter Verwendung des Feedbacks der Motor-Encoder aufrechtzuerhalten.

Ein paar Fotos der zusammengebauten Roboterbasis.

Das Roboterchassis ist ein Upcycling-A4-Papier-Blechbehälter. Sie können auch eine alte Kunststoffbox verwenden, um Ihre Komponenten unterzubringen.

In meinem Linorobot-Projekt finden Sie ein umfassendes Tutorial zum Bau von DIY-ROS-kompatiblen Robotern.

3.2 Vertikal Heben Schaltung (Arm Elternteil)

Verdrahten Sie die Komponenten wie unten gezeigt. Diese Schaltung steuert den vertikalen Hub des Arms und übersetzt die erforderliche Höhe, die von http://moveit.ros.org/ gesendet wird, in Schrittbewegungen. Dies ist ein Open-Loop-System, das die aktuelle Höhe des Arms berechnet, indem es die Anzahl der Schritte mit der Distanz in Millimetern korreliert. Der Mikrocontroller leitet auch die von MoveIt gesendeten Daten an den Roboterarm weiter, der auf der beweglichen vertikalen Plattform montiert ist.

Hier sind Fotos der zusammengebauten Schaltung für den Vertikallift.

Das Spiralkabel beherbergt die Tx/Rx-Drähte für die serielle Kommunikation zwischen dem vertikalen Hubschaltkreis und der Steuerung des Roboterarms sowie eine +12-V-DC-Versorgung, um den Roboterarm aufzuladen.

3.3 Roboter Arm Verantwortlicher ( Arm Kind )

Verdrahten Sie die Komponenten wie unten gezeigt, nachdem Sie den Roboterarm zusammengebaut und seine Abschirmung auf Arduino Uno gestapelt haben. Diese Schaltung kommuniziert mit dem Elternarm durch serielle Kommunikation. Die empfangenen Daten sind ein Array von erforderlichen Winkeln für jedes Gelenk, das verwendet wird, um die Servomotoren zu betätigen.

Hier sind Fotos des zusammengebauten Roboterarm-Controllers, der auf einem Arduino Uno gestapelt ist.

Und noch ein paar mehr, um den Rest von O'nines mechanischen Teilen zu zeigen.

3.4 Alle Schaltkreise integrieren

Schließen Sie abschließend alle zuvor verdrahteten Stromkreise wie unten gezeigt an. Das Diagramm zeigt auch, wie jeder Stromkreis mit Strom versorgt wird:

4. Software

Beachten Sie, dass dieses Projekt auf zwei Linux-Rechnern (Ubuntu 14.04 oder 16.04) ausgeführt werden muss. Eine Entwicklungsmaschine zum Ausführen von MoveIt und Datenvisualisierung (Rviz) und eine andere Maschine (ARM-Entwicklungsplatine) zum Ausführen des Navigationspakets und der Hardware-/Sensortreiber des Roboters.

Klicken Sie hier für von ROS unterstützte Entwicklungsboards, die Sie für den Roboter verwenden können (vorzugsweise 2 GB RAM).

4.1 ROS-Installation

Installieren Sie ROS auf beiden Computern:

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

Das Installationsprogramm erkennt automatisch das Betriebssystem und die Architektur des Computers, sodass Sie sich keine Gedanken darüber machen müssen, welche Version von ROS Sie installieren möchten.

4.2 ROS Pakete Installation

4.2.1 Installieren Sie Folgendes auf dem Entwicklungscomputer:

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

4.2.2 Linorobot auf dem Computer des Roboters installieren (Roboterbasis):

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

Dadurch werden die Firmware, die Navigationssoftware und die Hardware-/Sensortreiber der Roboterbasis installiert.

4.2.3 Installieren Sie das Paket von O’nine auf beiden Maschinen:

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

Dadurch werden die Firmware des Roboterarms, der Kinematik-Solver und die autonomen Aufgaben von Onine installiert.

4.2.4 alexa_tasker installieren:

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

Dadurch wird der MQTT-Client heruntergeladen, der O'nine und alexa verbindet. Das Paket enthält auch die NodeJS-App, die als ZIP-Datei komprimiert und in AWS Lambda hochgeladen wird.

5. Software-Setup

5.1 Einstellung Nach oben Alexa-Fähigkeit

5.1.1 Registrieren und einloggen

Erstellen Sie hier ein Alexa-Entwicklerkonto und klicken Sie auf 'Start a Fähigkeit' :

Geben Sie Ihre E-Mail-Adresse und Ihr Passwort ein:

5.1.2 Einen Alexa Skill starten

Klicken Sie auf 'Holen Angefangen' Unter Alexa Skills Kit.

Klicken Sie auf 'Hinzufügen a Neu Fähigkeit' bei die oben richtig von die Fenster:

5.1.3 Skill-Informationen

Kreuzen Sie 'Benutzerdefiniert . an Interaktion Modell' unter Fertigkeitstyp.

Geben Sie den Namen Ihres Skills (optional Ihren Roboternamen) unter 'Name' ein.

Geben Sie den Aufrufnamen Ihres Skills (Name zum Aktivieren Ihres Skills) unter 'Aufruf . ein Name'.

Klicken Sie auf 'Weiter'.

5.1.4 Interaktionsmodell

Kopieren Sie die Codes von https://github.com/grassjelly/onine_alexa/blob/master/lamda/assets/schema.json und fügen Sie sie in 'Intent Schema' ein .

Kopieren Sie die Codes von https://github.com/grassjelly/onine_alexa/blob/master/lamda/assets/utterances.txt und fügen Sie sie in 'Beispiel . ein Äußerungen'.

Klicken Sie auf 'Weiter'.

5.1.5 Skill-Konfiguration

Kopieren Sie Ihre App-Skill-ID aus der oberen linken Ecke und fahren Sie mit Schritt 5.2 fort, um eine Lambda-Funktion zu erstellen. Notieren Sie sich den Amazon-Ressourcennamen, wenn Sie die Funktion erstellt haben.

Kreuzen Sie 'AWS . an Lambda ARN' und geben Sie Ihren ARN auf dem Standard-Tab ein.

Klicken Sie auf 'Weiter'.

5.1.6 Fertigkeit testen

Geben Sie den Sprachbefehl unter 'Enter . ein Aussage' und klicke auf ' Fragen '

Ob dein Skill funktioniert, kannst du bei einer Antwort unter 'Service . überprüfen Antwort'.

5.2 Einstellung Up Lambda-Funktion

5.2.1 Registrieren und einloggen

Erstellen Sie hier ein AWS Lamda-Konto und klicken Sie auf 'Signieren In zu Konsole' bei die oben richtig von die Fenster :

Geben Sie Ihre E-Mail-Adresse und Ihr Passwort ein.

5.2.2 Lambda-Funktion erstellen

Klicken Sie auf 'Erstellen Funktion' oben rechts im Fenster, um mit der Erstellung der Lambda-Funktion zu beginnen.

Wählen Sie 'NodeJS 4.3' unter Laufzeit*.

Wählen Sie 'Wählen ein vorhanden Rolle' unter Rolle*.

Wählen Sie 'lambda_basic_execution' unter Vorhandene Rolle*.

Klicken Sie auf 'Funktion erstellen' .

5.2.3 Alexa verknüpfen

Füge einen Auslöser hinzu und wähle 'Alexa Fähigkeiten Kit'

Geben Sie Ihre Alexa-Skill 'Skill-ID' ein unter Skill-ID.

klicken Sie dann auf 'Hinzufügen'.

5.2.4 App hochladen

Kopieren Sie vor dem Erstellen der Funktion die Pub-Sub-Schlüssel Ihres PubNubs und fügen Sie sie in den Funktionscode ein.

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

Generieren Sie nun die ZIP-Datei, die in AWS Lambda hochgeladen wird:

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

Dadurch werden die erforderliche Lambda-Funktion und die erforderlichen node_modules in eine ZIP-Datei komprimiert

Wählen Sie im Funktionscode 'Hochladen a .ZIP Datei' unter Codeeingabetyp.

Klicken Sie auf 'Hochladen' und wählen Sie Onine.zip, das zuvor zum Hochladen erstellt wurde.

Klicken Sie auf 'Speichern' bei die oben richtig von die Fenster.

Jetzt ist Ihre Lambda-Funktion fertig.

5.3 PubNub-Konto erstellen

5.3.1 Registrieren und einloggen

Erstellen Sie hier ein PubNub-Konto.

Geben Sie Ihre E-Mail-Adresse und Ihr Passwort ein:

5.3.2 Erstellen Sie eine neue PubNub-App

Klicken Sie auf 'Erstellen Neu APP' bei die oben richtig von die Fenster :

Geben Sie den Namen Ihrer App unter "App . ein Name' :

5.3.3 Notieren Sie Ihre Veröffentlichungs- und Abonnementschlüssel.

5.3.4 Geben Sie Ihre Veröffentlichungs- und Abonnementschlüssel in diese Zeilen ein.

5.4 Erstellen Pusover Benachrichtigungen

O'nine verwendet Pushover, um Fotos an das Telefon des Benutzers zu senden. Melden Sie sich hier für ein Konto an und laden Sie die App herunter, damit Sie Fotos von O'nine erhalten, wenn Sie ihn bitten, etwas im Haus zu überprüfen.

5.4.1 Bei Pushover anmelden

und geben Sie Ihre E-Mail-Adresse und Ihr Passwort ein:

Notieren Sie Ihren Benutzerschlüssel, sobald Sie sich erfolgreich angemeldet haben.

5.4.2 Anwendung erstellen

Klicken Sie auf 'Apps &Plugins' oben im Fenster. Klicken Sie auf 'Erstellen a Neu Bewerbung / API-Token' .

Geben Sie den Namen der Anwendung unter 'Name' ein .

Wählen Sie 'Bewerbung' unter 'Typ'.

Geben Sie eine beliebige Beschreibung der Anwendung ein.

Klicken Sie auf 'Erstellen Bewerbung'.

Wenn Sie fertig sind, notieren Sie Ihr API-Token.

5.4.3 Kopieren Sie Ihr App-Token und Ihren Benutzerschlüssel und fügen Sie sie in O'nines 'Snaptask' ein.

5.5 Installation die Firmware

5.5.1 uDev-Regeln

Die seriellen Ports der Mikrocontroller werden mit ihren statischen Namen in den Roslaunch-Dateien definiert. Damit die seriellen Ports gespeichert und mit ihren statischen Namen verknüpft werden, muss eine uDev-Regel erstellt werden. Führen Sie das uDev-Tool auf dem Computer des Roboters aus.

 rosrun lino_udev lino_udev.py 

Stecken Sie das Teensy-Board der Roboterbasis ein und geben Sie "linobase" ein. Machen Sie dasselbe für den vertikalen Hubkreislauf und nennen Sie ihn "oninearm". Speichern Sie Ihre uDev-Regeln, indem Sie STRG+C drücken.

Kopieren Sie die gespeicherten udev-Regeln nach /etc/udev/rules.d:

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

udev neu starten:

sudo service udev reloadsudo service udev neustart 

Bestätigen Sie, ob die uDev-Regeln funktioniert haben:

ls /dev/linobasels /dev/oninearm 

Wenn die Ports nicht erkannt wurden, starten Sie den Computer des Roboters neu und überprüfen Sie es erneut.

5.5.2 Firmware der Roboterbasis hochladen

Bevor Sie die Firmware der Roboterbasis hochladen, müssen Sie die Spezifikationen Ihrer Komponenten wie Raddurchmesser, PPR des Encoders usw. definieren. Klicken Sie hier, um Ihren Roboter zu konfigurieren.

Schließen Sie das Teensy-Board der Roboterbasis an den Computer des Roboters an und führen Sie Folgendes aus:

roscd linorobot/firmware/teensyplatformio run --target upload 

5.5.3 Firmware des Vertikallifts hochladen

Schließen Sie das Teensy-Board des Vertikallifts an den Computer des Roboters an und führen Sie Folgendes aus:

cdplatformio run --target upload 

5.5.4 Firmware der Robotersteuerung hochladen

Schließen Sie das Arduino Uno an den Computer des Roboters an und führen Sie Folgendes aus:

cdplatformio run --target upload 

Denken Sie daran, das Arduino Uno nach dem Hochladen der Codes zu trennen, da die empfangenen Daten über das Teensy-Board des Vertical Lifts über serielle Kommunikation übertragen werden.

5.6 Bearbeiten Linoroboter Codes

Sie müssen einige Zeilen in den Startdateien von Linorobot (Roboterbasis) bearbeiten, um die Treiber hinzuzufügen, die zum Ausführen von Onine erforderlich sind.

5.6.1 Fügen Sie nach dieser Zeile in bringup.launch Folgendes hinzu.

Dadurch wird das Softwarepaket hinzugefügt, das erforderlich ist, um mit dem Mikrocontroller des vertikalen Lifts zu kommunizieren und Onines die Transformationen des Onine zu definieren (Position der mechanischen Teile von Onine im 3D-Raum).

5.6.2 Ändern Sie diese Zeile in:

Dies dient dazu, einen virtuellen Rahmen zu erstellen, der verwendet wird, um die vom Kinect gelesenen Punktwolkendaten in 2D-Laserscandaten zu übersetzen.

5.6.3 Kommentieren Sie diese Zeile aus, da die Transformationen für diesen Link bereits in der URDF-Datei von Onine definiert sind.

5.6.4 Ersetzen Sie die folgenden Zeilen durch:

Dadurch wird das Softwarepaket ausgeführt, um die vom Kinect gelesenen Punktwolkendaten in 2D-Laserscandaten zu übersetzen.

5.6.5 Ersetzen Sie den Basisreferenzrahmen von Linorobot von base_link zu base_footprint:

Wechsel von 'base_link ' bis 'base_footprint ' auf folgendem:

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

linorobot/src/lino_base_node.cpp - lino 111

5.6.6 Neukompilieren des Odometrieknotens:

cd ~/linorobot_wscatkin_make 

5.7 Einstellung nach oben O'nine's Objekt Detektor

Um es O'nine zu erleichtern, Objekte zu erkennen, verwendet es AR-Tags, um interessante Objekte bei der Ausführung von Pick-and-Place-Aufgaben zu unterscheiden. Ähnliches Konzept wie diese Roboter:

Drucken Sie das Bild unten aus und kleben Sie es auf das Objekt, das O'nine aufheben soll. Die Größe des Bildes sollte 2 cm x 2 cm betragen. Diese Zahlen sind willkürlich, denken Sie nur daran, die Dimension in der Tracker-Startdatei von Onine zu ändern.

Die verwendete Wahrnehmungssoftware ist http://wiki.ros.org/ar_track_alvar . Dies kann leicht ersetzt werden, wenn Sie es vorziehen, Ihre eigene Objekterkennungssoftware zu verwenden oder andere ROS-kompatible Pakete zu verwenden, wie zum Beispiel:

http://wiki.ros.org/find_object_2d

http://wiki.ros.org/tabletop_object_detector

6. Ausführen der Demo

Stellen Sie sicher, dass Sie Ihr Netzwerk konfigurieren, bevor Sie mit der Demo beginnen. In diesem ROS-Netzwerk finden Sie ein umfassenderes Tutorial.

6.1 Erstellen die Karte

O'nine verwendet eine vorgefertigte Karte, um sich selbst zu lokalisieren und seinen Weg zu planen, wenn er im Haus navigiert. Führen Sie Folgendes aus, um eine Karte zu erstellen:

Öffnen Sie auf dem Computer des Roboters 2 neue Terminalfenster. Führen Sie bringup.launch aus:

roslaunch linorobot bringup.launch 

slam.launch ausführen:

roslaunch linorobot slam.launch 

Öffnen Sie auf Ihrem Entwicklungscomputer 2 neue Terminalfenster:Führen Sie teleop_twist_keyboard aus:

rosrun teleop_twist_keyboard teleop_twist_keyboard.py 

rviz ausführen:

roscd lino_visualize/rvizrviz -d slam.rviz 

Fahren Sie den Roboter mit teleop_twist_keyboard um den Bereich, den Sie kartieren möchten.

Wenn Sie mit dem Mapping fertig sind, speichern Sie die Karte, indem Sie map_server auf dem Computer des Roboters ausführen:

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

Überprüfen Sie, ob map.pgm und map.yaml gespeichert wurden:

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

Ändern Sie die aufgerufene Karte in navigation.launch, um Ihre eigene Karte zu laden. 'house.yaml' ändern zu 'map.yaml' .

6.2 Zielkoordinaten abrufen

Wenn Sie O'nine bitten, eine Aufgabe auszuführen, die eine autonome Navigation innerhalb des Hauses erfordert, muss es die Koordinaten des Punktes kennen, an dem es die Arbeit erledigen soll.

Sie können diese Koordinaten wiedergeben, indem Sie move_base_simple/goal abonnieren und auf den Zielort in Rviz zeigen.

SSH mit dem Robotercomputer und führen Sie Folgendes aus:

Führen Sie bringup.launch aus:

roslaunch linorobot bringup.launch 

Führen Sie auf einem anderen Terminal den Navigationsstack aus:

roslaunch linorobot navigation.launch 

Führen Sie Rviz auf Ihrem Entwicklungscomputer aus:

roscd lino_visualize/rvizrviz -d navigation.rviz 

Öffnen Sie ein anderes Terminal auf Ihrem Entwicklungscomputer und führen Sie Folgendes aus:

rostopisches Echo move_base_simple/goal 

Dadurch werden die Koordinaten und die Überschrift der Zielpose wiedergegeben, auf die Sie auf Rviz klicken.

Klicken Sie auf Rviz auf den Punkt, der ungefähr 1 Meter von der Stelle entfernt ist, an der der Roboter die Aufgabe ausführen soll, und ziehen Sie ihn dorthin, wo der Roboter sein Ziel erreicht hat. (1 Kiste in Rviz entspricht 1 Quadratmeter).

Kopieren Sie die Koordinaten in das Fenster, in dem Sie 'move_base_simple/goal . wiedergeben '

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

Schaltpläne