Robot Asisten Rumah Otonom

Tentang proyek ini

1. Pendahuluan

Temui O'nine! Pendamping robot rumah pribadi yang dapat bergerak, mengambil benda, dan menjaga rumah Anda. Berkat Alexa, O'nine dapat mendengar Anda dan melakukan tugas yang dapat diprogram seperti memberi makan ikan Anda.

Proyek ini berharap dapat memperluas kemampuan Alexa dengan menyediakan platform robot yang dapat diskalakan dan terbuka yang dapat melakukan tugas dinamis di lingkungan rumah pintar. Solusi rumah pintar saat ini memerlukan rig khusus yang dirancang hanya untuk fungsi tertentu. O'nine bertujuan untuk menjembatani kesenjangan ini dengan meminimalkan persyaratan perangkat keras ini dan menggunakan robotika sebagai alternatif. Idenya adalah untuk membuat platform pembuktian teknologi untuk menguji kelayakan dan kelayakan menggunakan robot sebagai komponen lain dari sistem otomasi rumah. Semoga kita dapat menjawab pertanyaan seperti "Apakah masuk akal menggunakan robot untuk mematikan unit AC daripada memasang mikrokontroler di setiap ruangan hanya untuk mengontrol setiap unit AC? " yang dulunya solusi statis sekarang bisa mobile dengan bantuan robot.

Berikut video O'nine memberi makan ikan saya.

TL;DW (Video Selang Waktu)

Video berdurasi penuh.

Anda ingin memeriksa bayi Anda atau siapa yang ada di pintu? O'nine memiliki kamera internal sehingga Anda juga dapat memintanya untuk mengambil gambar.

Tutorial ini akan memandu Anda tentang cara membuat robot dan cara membuat Keterampilan Alexa yang dapat memerintahkan robot untuk melakukan tugas mandiri.

2. Arsitektur Tingkat Tinggi

Singkatnya, inilah cara kerja O'nine - integrasi Alexa:

1. Amazon Echo Dot mendengarkan perintah suara.

2. Keterampilan Alexa Khusus mendeteksi Intent.

3. Fungsi AWS Lambda menerima permintaan dari Amazon Alexa Skill dan memublikasikannya ke broker PubNub MQTT.

4. O'nine menerima data dengan berlangganan broker MQTT.

5. O'nine menjalankan tugas yang diperlukan secara mandiri.

3. Perangkat Keras

3.1 Basis Robot

Hubungkan komponen seperti yang ditunjukkan di bawah ini. Sirkuit ini menerjemahkan semua perintah kecepatan yang dikirim dari ROS Navigation Stack ke dalam gerakan motor. Firmware termasuk pengontrol PID untuk mempertahankan kecepatan yang diperlukan menggunakan umpan balik dari encoder motor.

Beberapa foto dari basis robot yang dirakit.

Sasis robot adalah wadah kaleng kertas A4 yang didaur ulang. Anda juga dapat menggunakan kotak wadah plastik bekas untuk menampung komponen Anda.

Anda dapat melihat proyek Linorobot saya untuk tutorial lengkap tentang cara membuat robot DIY yang kompatibel dengan ROS.

3.2 Vertikal Angkat Sirkuit (Lengan Orangtua)

Hubungkan komponen seperti yang ditunjukkan di bawah ini. Sirkuit ini mengontrol pengangkatan vertikal lengan dan menerjemahkan ketinggian yang diperlukan yang dikirim oleh http://moveit.ros.org/ ke dalam gerakan stepper. Ini adalah sistem Loop Terbuka yang menghitung tinggi lengan saat ini dengan mengkorelasikan jumlah langkah yang dilakukan dengan jarak dalam milimeter. Mikrokontroler juga menyampaikan data yang dikirim dari MoveIt ke lengan robot yang dipasang pada platform vertikal yang bergerak.

Berikut adalah foto rangkaian rakitan untuk pengangkatan vertikal.

Kabel spiral menampung kabel Tx/Rx untuk komunikasi serial antara sirkuit pengangkat vertikal dan pengontrol lengan robot, dan suplai DC +12V untuk memperkuat lengan robot.

3.3 Robotik Lengan Pengontrol ( Lengan Anak )

Hubungkan komponen seperti yang ditunjukkan di bawah ini setelah merakit lengan robot dan menumpuk perisainya ke Arduino Uno. Sirkuit ini berkomunikasi dengan lengan induk melalui komunikasi serial. Data yang diterima adalah array sudut yang diperlukan untuk setiap sambungan yang digunakan untuk menggerakkan motor servo.

Berikut adalah foto-foto pengontrol lengan robot rakitan yang ditumpuk di Arduino Uno.

Dan beberapa lagi untuk menunjukkan bagian mekanis O'nine lainnya.

3.4 Integrasikan semua sirkuit

Terakhir, hubungkan semua sirkuit yang telah Anda sambungkan sebelumnya seperti yang ditunjukkan di bawah ini. Diagram juga menunjukkan cara memberi daya pada setiap sirkuit:

4. Perangkat Lunak

Perhatikan bahwa proyek ini harus dijalankan pada dua mesin Linux (Ubuntu 14.04 atau 16.04). Satu mesin pengembangan untuk menjalankan MoveIt dan visualisasi data (Rviz) dan mesin lain (papan pengembang ARM) untuk menjalankan paket navigasi robot dan driver perangkat keras/sensor.

Klik di sini untuk papan dev yang didukung ROS yang dapat Anda gunakan untuk robot (sebaiknya RAM 2 GB).

4.1 Instalasi ROS

Instal ROS di kedua mesin:

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

Penginstal secara otomatis mendeteksi sistem operasi dan arsitektur mesin sehingga Anda tidak perlu khawatir versi ROS mana yang akan diinstal.

4.2 ROS Paket Pemasangan

4.2.1 Instal yang berikut ini pada mesin pengembangan:

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 Instal Linorobot di komputer robot (basis robot):

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

Tindakan ini akan menginstal firmware basis robot, perangkat lunak navigasi, dan driver perangkat keras/sensor.

4.2.3 Instal paket O'nine di kedua mesin:

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

Tindakan ini akan menginstal firmware lengan robot, pemecah kinematika, dan tugas otonom Onine.

4.2.4 Instal alexa_tasker:

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

Ini mengunduh klien MQTT yang menghubungkan O'nine dan alexa. Paket tersebut juga berisi aplikasi NodeJS yang akan dikompresi sebagai file zip dan diunggah di AWS Lambda.

5. Pengaturan Perangkat Lunak

5.1 Setelan Naik Keterampilan Alexa

5.1.1 Daftar dan Masuk

Buat Akun Pengembang Alexa di sini dan klik 'Mulai a Keterampilan' :

Masukkan alamat email dan kata sandi Anda:

5.1.2 Memulai Keterampilan Alexa

Klik 'Dapatkan Mulai' Di bawah Alexa Skills kit.

Klik 'Tambah a Baru Keterampilan' di yang atas benar dari yang jendela:

5.1.3 Informasi Keterampilan

Centang 'Kustom Interaksi Model' di bawah Jenis Keterampilan.

Masukkan nama keahlian Anda (opsional nama robot Anda) di bawah 'Nama'.

Masukkan nama panggilan keahlian Anda (nama untuk mengaktifkan keahlian Anda) di bawah 'Doa Nama'.

Klik 'Selanjutnya'.

5.1.4 Model Interaksi

Salin dan tempel kode dari https://github.com/grassjelly/onine_alexa/blob/master/lamda/assets/schema.json ke 'Intent Schema' .

Salin dan tempel kode dari https://github.com/grassjelly/onine_alexa/blob/master/lamda/assets/utterances.txt ke 'Contoh Ucapan'.

Klik 'Berikutnya'.

5.1.5 Konfigurasi Keterampilan

Salin ID Keterampilan Aplikasi Anda dari sudut kiri atas dan lewati ke langkah 5.2 untuk membuat Fungsi Lambda. Catat Nama Sumber Daya Amazon setelah Anda selesai membuat fungsi.

Centang 'AWS Lambda ARN' dan masukkan ARN Anda pada tab default.

Klik 'Selanjutnya'.

5.1.6 Menguji keterampilan

Masukkan perintah suara di bawah 'Enter Ucapan' dan klik ' Tanya '

Anda dapat memeriksa apakah Keterampilan Anda berfungsi jika ada balasan di bawah 'Layanan Tanggapan'.

5.2 Setelan Fungsi Lambda Naik

5.2.1 Daftar dan Masuk

Buat akun AWS Lamda di sini dan klik 'Masuk Dalam ke Konsol' di yang atas benar dari yang jendela :

Masukkan alamat email dan kata sandi Anda.

5.2.2 Membuat Fungsi Lambda

Klik 'Buat Fungsi' di kanan atas jendela untuk mulai membuat fungsi Lambda.

Pilih 'NodeJS 4.3' di bawah Waktu Proses*.

Pilih 'Pilih sebuah sudah ada peran' di bawah Peran*.

Pilih 'lambda_basic_execution' di bawah Peran yang Ada*.

Klik 'Buat Fungsi' .

5.2.3 Tautkan Alexa

Tambahkan pemicu dan Pilih 'Alexa Keterampilan Perlengkapan

Masukkan Skill Alexa Anda 'skill id' di bawah ID Keterampilan.

lalu klik 'Tambah'.

5.2.4 Unggah aplikasi

Sebelum membuat fungsi, salin dan tempel kunci Pub-Sub PubNub Anda ke kode fungsi.

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

Sekarang buat file zip yang akan diunggah ke AWS Lambda:

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

Ini akan memampatkan fungsi lambda dan node_modules yang diperlukan menjadi .zip

Pada Kode Fungsi, pilih 'Unggah a .ZIP File' di bawah Jenis entri kode.

Klik 'Unggah' dan pilih Onine.zip yang sudah dibuat tadi untuk diupload.

Klik 'Simpan' di yang atas benar dari yang jendela.

Sekarang fungsi Lambda Anda selesai.

5.3 Membuat Akun PubNub

5.3.1 Daftar dan Masuk

Buat Akun PubNub di sini.

Masukkan email dan kata sandi Anda:

5.3.2 Buat Aplikasi PubNub baru

Klik 'Buat Baru APLIKASI' di yang atas benar dari yang jendela :

Masukkan nama aplikasi Anda di bawah 'Aplikasi Nama' :

5.3.3 Rekam kunci publikasi dan berlangganan Anda.

5.3.4 Masukkan kunci publikasikan dan berlangganan Anda pada baris ini.

5.4 Membuat Pusover Pemberitahuan

O'nine menggunakan Pushover untuk mengirim foto ke ponsel pengguna. Daftar akun di sini dan unduh aplikasinya sehingga Anda dapat menerima foto dari O'nine saat Anda memintanya untuk memeriksa sesuatu di dalam rumah.

5.4.1 Masuk ke Pushover

dan masukkan email dan kata sandi Anda:

Catat kunci pengguna Anda setelah Anda berhasil masuk.

5.4.2 Membuat aplikasi

Klik 'Aplikasi &Plugin' di bagian atas jendela. Klik 'Buat a Baru Aplikasi / Token API' .

Masukkan nama Aplikasi di bawah 'Nama' .

Pilih 'Aplikasi' di bawah 'Jenis'.

Masukkan deskripsi aplikasi apa pun.

Klik 'Buat Aplikasi'.

Setelah selesai, catat token API Anda.

5.4.3 Salin dan tempel token aplikasi dan kunci pengguna Anda ke 'snaptask' O'nine.

5.5 Memasang yang firmware

5.5.1 Aturan uDev

Port serial mikrokontroler didefinisikan menggunakan nama statisnya pada file roslaunch. Agar port serial diingat dan ditautkan ke nama statisnya, aturan uDev harus dibuat. Jalankan alat uDev di komputer robot.

 rosrun lino_udev lino_udev.py 

Pasang papan Teensy basis robot dan masukkan "linobase". Lakukan hal yang sama untuk rangkaian pengangkat vertikal dan beri nama "oninearm". Simpan aturan uDev Anda dengan menekan CTRL+C.

Salin aturan udev yang disimpan ke /etc/udev/rules.d:

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

Mulai ulang udev:

sudo service udev reloadsudo service udev restart 

Konfirmasikan apakah aturan uDev berfungsi:

ls /dev/linobasels /dev/oninearm 

Jika port tidak terdeteksi, mulai ulang komputer robot dan periksa lagi.

5.5.2 Unggah firmware basis robot

Sebelum mengunggah firmware basis robot, Anda harus menentukan spesifikasi komponen Anda seperti diameter roda, PPR encoder, dll. Klik di sini untuk mengonfigurasi robot Anda.

Pasang papan Teensy basis robot ke komputer robot dan jalankan:

roscd linorobot/firmware/teensyplatformio run --target upload 

5.5.3 Unggah firmware pengangkatan vertikal

Pasang papan Teensy lift vertikal ke komputer robot dan jalankan:

cdplatformio run --target upload 

5.5.4 Unggah firmware pengontrol robot

Colokkan Arduino Uno ke komputer robot dan jalankan:

cdplatformio run --target upload 

Ingatlah untuk mencabut Arduino Uno setelah mengunggah kode karena data yang diterima diteruskan melalui papan Teensy Lift Vertikal menggunakan komunikasi serial.

5.6 Mengedit Linorobot kode

Anda harus mengedit beberapa baris di file peluncuran Linorobot (basis robot) untuk menambahkan driver yang diperlukan untuk menjalankan Onine.

5.6.1 Tambahkan baris berikut setelah baris ini di bringup.launch.

Ini menambahkan paket perangkat lunak yang diperlukan untuk berbicara dengan mikrokontroler pengangkat vertikal dan Onine mendefinisikan transformasi Onine (lokasi komponen mekanis Onine dalam ruang 3D).

5.6.2 Ubah baris ini menjadi:

Ini menjalankan paket perangkat lunak untuk menerjemahkan data pointcloud yang dibaca dari Kinect menjadi data pemindaian laser 2D.

5.6.5 Ganti kerangka acuan dasar Linorobot dari base_link ke base_footprint:

Ubah dari 'base_link ' ke 'base_footprint ' berikut ini:

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

linorobot/src/lino_base_node.cpp - lino 111

5.6.6 Kompilasi ulang simpul odometri:

cd ~/linorobot_wscatkin_make 

5.7 Setelan naik O'nine's objek detektor

Untuk memudahkan O'nine mendeteksi objek, O'nine menggunakan tag AR untuk membedakan objek yang diinginkan saat melakukan tugas memilih dan menempatkan. Konsep serupa dengan robot ini:

Cetak gambar di bawah ini dan tempelkan pada objek yang ingin Anda ambil oleh O'nine. Dimensi gambar harus 2cm x 2cm. Angka-angka ini berubah-ubah, ingatlah untuk mengubah dimensi pada file peluncuran pelacak Onine.

Perangkat lunak persepsi yang digunakan adalah http://wiki.ros.org/ar_track_alvar. Ini dapat dengan mudah diganti jika Anda lebih suka menggunakan perangkat lunak pendeteksi objek Anda sendiri atau menggunakan beberapa paket lain yang kompatibel dengan ROS seperti:

http://wiki.ros.org/find_object_2d

http://wiki.ros.org/tabletop_object_detector

6. Menjalankan demo

Pastikan Anda mengkonfigurasi jaringan Anda sebelum memulai demo. Lihat jaringan ROS ini untuk tutorial yang lebih komprehensif.

6.1 Membuat yang peta

O'nine menggunakan peta yang telah dibuat sebelumnya untuk melokalisasi dirinya dan merencanakan jalurnya saat bernavigasi di sekitar rumah. Jalankan perintah berikut untuk membuat peta:

Di komputer robot, buka 2 jendela terminal baru. Jalankan Bringup.launch:

roslaunch linorobot bringup.launch 

Jalankan slam.launch:

roslaunch linorobot slam.launch 

Di komputer pengembangan Anda, buka 2 jendela terminal baru:Jalankan teleop_twist_keyboard:

rosrun teleop_twist_keyboard teleop_twist_keyboard.py 

Jalankan rviz:

roscd lino_visualize/rvizrviz -d slam.rviz 

Menggunakan teleop_twist_keyboard, kendarai robot di sekitar area yang ingin Anda petakan.

Setelah Anda selesai memetakan, simpan peta dengan menjalankan map_server di komputer robot:

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

Periksa apakah map.pgm dan map.yaml telah disimpan:

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

Ubah peta yang dipanggil di navigasi.launch untuk memuat peta Anda sendiri. Ubah 'house.yaml' ke 'map.yaml' .

6.2 Mendapatkan koordinat sasaran target

Ketika Anda meminta O'nine untuk melakukan tugas yang memerlukan navigasi otonom di dalam rumah, ia harus mengetahui koordinat titik di mana ia harus melakukan pekerjaan itu.

Anda dapat menggemakan koordinat ini dengan berlangganan move_base_simple/goal dan mengarahkan lokasi target di Rviz.

SSH ke komputer robot dan jalankan perintah berikut:

Jalankan Bringup.launch:

roslaunch linorobot bringup.launch 

Di terminal lain, jalankan tumpukan navigasi:

roslaunch linorobot navigasi.launch 

Jalankan Rviz di komputer pengembangan Anda:

roscd lino_visualize/rvizrviz -d navigasi.rviz 

Buka terminal lain di komputer pengembangan Anda dan jalankan:

rostopic echo move_base_simple/goal 

Ini akan menggemakan koordinat dan heading dari pose target yang akan Anda klik di 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.

Skema