Autonomer Hausassistent-Roboter bauen: Komplette Teileliste & Setup-Anleitung

Komponenten und Zubehör

Bauteil	Menge
Arduino UNO	1
Arduino Braccio Roboterarm	1
Odroid XU4 (ARM Board)	1
SparkFun EasyDriver (Schrittmotor-Treiber)	1
Schrittmotor	1
L298 Motortreiber	1
DC-Motor (generic)	4
GY-85 IMU	1
Mecanum-Räder (omnidirektional)	1 Satz
5V USB-Hub	1
Microsoft Kinect Sensor (v1)	1
OpenBuilds V-Slot Linear Rail	2
OpenBuilds V-Slot Gantry Plates	1
OpenBuilds Solid V Wheel Kit	4
0,8 m Trapezgewindespindel (Acme)	1
6mm auf 8mm Wellenkupplung	1
8mm Lagerbock	1
1,2 m Federdraht (Spiralkabel)	1
Endschalter (Limit Switch)	1
5V BEC (Spannungsregler)	1
Variable DC-DC Wandler	2
12V Akku 5000 mAh	1

Apps und Online-Dienste

• Amazon Alexa Skills Kit
• AWS Lambda
• ROS (Robot Operating System)
• PubNub Publish/Subscribe API

Über dieses Projekt

1. Einführung

Treffen Sie O'nine! Einen persönlichen Hausroboter, der sich bewegt, Objekte greift und das Haus überwacht. Dank Alexa-Integration hört er Befehle und führt programmierbare Aufgaben aus (z. B. Fische füttern).

Ziel: Alexas Fähigkeiten durch eine skalierbare, offene Roboterplattform erweitern, die dynamische Aufgaben im Smart Home übernimmt. Statt für jede Funktion eigene Hardware (Mikrocontroller pro Raum) zu installieren, übernimmt ein mobiler Roboter diese Aufgaben.

Fragen wie: „Macht es Sinn, einen Roboter zum Abschalten von Klimaanlagen zu nutzen, statt in jedem Raum Mikrocontroller zu verbauen?“ sollen beantwortet werden.

Video: O'nine füttert Fische (Time-Lapse & Full Length).
Kamera an Bord: Per Sprachbefehl Fotos machen („Wer ist an der Tür?“).

Dieses Tutorial führt durch: Roboterbau + Alexa Skill für autonome Aufgaben.

2. Hochlevel-Architektur

1. Amazon Echo Dot hört Sprachbefehl.
2. Custom Alexa Skill erkennt Intent.
3. AWS Lambda empfängt Request, publiziert an PubNub MQTT Broker.
4. O'nine abonniert MQTT, empfängt Daten.
5. O'nine führt Aufgabe autonom aus.

3. Hardware

3.1 Roboter-Basis

Übersetzt ROS-Navigationsbefehle in Motorbewegungen. Firmware mit PID-Regler für Geschwindigkeitsregelung via Encoder-Feedback.

Chassis: Upcycling A4-Papierkarton / Kunststoffbox. Siehe auch Linorobot Project für ROS-kompatible DIY-Roboter.

3.2 Vertikaler Lift (Arm-Elternteil)

Steuert vertikale Hubbewegung des Arms. Open-Loop: Höhe über Schrittzähler berechnet. Leitet MoveIt-Daten an Arm-Controller (Kind) weiter.

Spiralkabel: Tx/Rx (Serial) + 12V Versorgung für Roboterarm.

3.3 Roboterarm-Controller (Arm-Kind)

Kommuniziert seriell mit Eltern-Lift. Empfängt Winkel-Array für jedes Gelenk, steuert Servos.

3.4 Alle Schaltungen integrieren

Zeigt Stromversorgung aller Teilschaltungen.

4. Software

Benötigt zwei Linux-Maschinen (Ubuntu 14.04/16.04): Entwicklung (MoveIt, Rviz) + Roboter (ARM Board, Navigation, Treiber). ROS-kompatible Boards (bevorzugt 2GB RAM): ROS Supported Boards.

4.1 ROS Installation

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

Installer erkennt OS/Architektur automatisch.

4.2 ROS Pakete

Entwicklungs-Maschine:

cd ~/catkin_ws/src
git clone https://github.com/linorobot/lino_pid
git clone https://github.com/linorobot/lino_msgs
git clone https://github.com/linorobot/lino_visualize
cd .. && catkin_make

Roboter-Basis (Linorobot):

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

O'nine Paket (beide Maschinen):

git clone https://github.com/grassjelly/onine_install
cd onine_install
./install

alexa_tasker:

cd ~/onine_ws/src
git clone https://github.com/grassjelly/onine_alexa
cd ..
catkin_make

Enthält MQTT-Client (Link Alexa↔Roboter) und NodeJS App für AWS Lambda (als ZIP).

5. Software-Setup

5.1 Alexa Skill einrichten

1. Alexa Developer Account erstellen → „Start a Skill“
2. Skill Type: Custom Interaction Model
3. Name & Invocation Name (z. B. „o nine“) vergeben
4. Interaction Model: schema.json & utterances.txt aus GitHub kopieren
5. AWS Lambda ARN eintragen (siehe 5.2)
6. Testen im Developer Console

5.2 AWS Lambda Function

1. AWS Console → Create Function
2. Runtime: Node.js 4.3, Role: lambda_basic_execution
3. Trigger: Alexa Skills Kit → Skill ID eintragen
4. Code: PubNub Keys in ~/onine_ws/src/onine_alexa/lambda/app eintragen → npm install && ./zipme → ZIP hochladen

5.3 PubNub Account

1. Account erstellen → New App
2. Publish & Subscribe Keys notieren → in Lambda & Robot-Code eintragen

5.4 Pushover Notifications (für Fotos)

1. Account & App erstellen
2. User Key & API Token notieren → in snaptask eintragen

5.5 Firmwares flashen

uDev Rules für stabile Gerätenamen:

rosrun lino_udev lino_udev.py
# Teensy (Basis) → "linobase"
# Teensy (Lift) → "oninearm"
# Strg+C zum Speichern
sudo cp 58-lino.rules /etc/udev/rules.d/58-lino.rules
sudo service udev reload && sudo service udev restart
ls /dev/linobase && ls /dev/oninearm

Firmwares hochladen (PlatformIO):

# Roboter-Basis (Teensy)
roscd linorobot/firmware/teensy
platformio run --target upload

# Vertikaler Lift (Teensy)
platformio run --target upload

# Arm-Controller (Arduino Uno)
platformio run --target upload
# Uno danach abziehen! (Daten laufen über Lift-Teensy)

5.6 Linorobot Codes anpassen

In bringup.launch nach bestimmter Zeile einfügen (Serial Node für Arm + Robot Description):

<node pkg="rosserial_python" name="rosserial_onine" type="serial_node.py" output="screen">
  <param name="port" value="/dev/oninearm" />
  <param name="baud" value="115200" />
</node>
<param name="robot_description" textfile="$(find onine_description)/urdf/onine.urdf"/>
<node name="robot_state_publisher" pkg="robot_state_publisher" type="robot_state_publisher" respawn="true" output="screen" />

Weitere Anpassungen: base_link_to_laser Transform, pointcloud_to_laserscan Node, Referenzframe base_link → base_footprint in diversen Dateien. Dann catkin_make.

5.7 Objekterkennung (AR-Tags)

Für Pick & Place: AR-Tags (2cm×2cm) auf Objekte kleben. Erkennung via ar_track_alvar. Alternativen: find_object_2d, tabletop_object_detector.

6. Demo ausführen

6.1 Karte erstellen (SLAM)

# Roboter-Computer (Terminal 1)
roslaunch linorobot bringup.launch
# Roboter-Computer (Terminal 2)
roslaunch linorobot slam.launch

# Dev-Computer (Terminal 1)
rosrun teleop_twist_keyboard teleop_twist_keyboard.py
# Dev-Computer (Terminal 2)
roscd lino_visualize/rviz && rviz -d slam.rviz

Roboter per Tastatur fahren → Karte aufbauen → speichern:

rosrun map_server map_saver -f ~/linorobot_ws/src/linorobot/maps/map
# map.yaml in navigate.launch auf 'map.yaml' ändern

6.2 Zielkoordinaten ermitteln

# Roboter: bringup.launch + navigate.launch
# Dev: rviz -d navigate.rviz
# Neues Terminal:
rostopic echo move_base_simple/goal

In Rviz: 2D Nav Goal setzen (~1m vor Ziel, Richtung angeben) → Koordinaten kopieren → in fishtask.py (Point & Quaternion) eintragen.

6.3 O'nine starten

# Dev Terminal 1
roscore
# Dev Terminal 2-4: SSH zu Roboter
# Roboter Term 1
roslaunch linorobot bringup.launch
# Roboter Term 2
roslaunch linorobot navigate.launch
# Roboter Term 3
roslaunch onine_apps ar_tracker.launch

# Dev Term 5
roslaunch onine_moveit_config demo.launch
# Dev Term 6
rosrun onine_alexa alexa_tasker.py

In Rviz: „2D Pose Estimate“ → Roboterposition auf Karte setzen → Fertig! Alexa-Befehle funktionieren nun.

7. Zukünftige Arbeiten

• Gazebo Simulation: Hardware-freies Testen von O'nine & Alexa Skill.
• Mehr Rechenleistung: Jetson TK1 → Odroid XU4 (5V, kompakt). Nächstes Ziel: Rock64 (4GB RAM) für parallele Anwendungen ohne Offloading auf Laptop.

Code-Repositories

• O'nine Software: Navigation, Kinematik, Pick&Place
• Alexa-Robot Integration: Lambda App, PubNub Client, Tasker
• Roboter-Basis (Linorobot): Open Source ROS Roboter Suite

Schaltpläne