Bangun Robot Asisten Rumah Otonom: Daftar Lengkap Komponen & Panduan Pengaturan

Aplikasi dan layanan online

	Amazon Alexa Alexa Skills Kit
	Amazon Web Services AWS Lambda
	ROS Robot Operating System
	PubNub Publish/Subscribe API

Tentang proyek ini

1. Pendahuluan

Mengenal O'nine! Seorang teman robot rumah pribadi yang dapat bergerak, mengambil benda, dan menjaga rumah Anda. Berkat Alexa, O'nine dapat mendengar Anda dan melakukan tugas terprogram seperti memberi makan ikan Anda.

Proyek ini bertujuan untuk memperluas kemampuan Alexa dengan menyediakan platform robot yang terukur dan terbuka yang dapat melakukan tugas dinamis di lingkungan rumah pintar. Solusi rumah pintar saat ini memerlukan rangka khusus yang dirancang hanya untuk fungsi tertentu. O'nine bertujuan untuk menutup kesenjangan ini dengan meminimalkan persyaratan perangkat keras ini dan menggunakan robotika sebagai alternatif. Ideanya adalah membuat platform pembuktian teknologi untuk menguji kelayakan dan kelangsungan penggunaan robot sebagai komponen lain dari sistem otomatisasi 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?" seperti yang dulu merupakan solusi statis sekarang dapat bergerak seluler dengan bantuan robot.

Berikut adalah video O'nine memberi makan ikan saya.

TL;DW (Video Time-Lapse)

Video lengkap.

Anda ingin memeriksa bayi Anda atau siapa yang di pintu? O'nine memiliki kamera built-in jadi Anda juga dapat memintanya untuk mengambil gambar.

Tutorial ini akan memandu Anda tentang cara membangun robot dan cara membuat Keterampilan Alexa yang dapat memerintah robot untuk melakukan tugas otonom.

2. Arsitektur Tingkat Tinggi

Secara ringkas, inilah cara kerja integrasi O'nine - Alexa:

1. Amazon Echo Dot mendengarkan perintah suara.

2. Keterampilan Alexa kustom mendeteksi Intent.

3. Fungsi AWS Lambda menerima permintaan dari Keterampilan Alexa Amazon dan menerbitkan ke broker MQTT PubNub.

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

5. O'nine mengeksekusi tugas yang diperlukan secara otonom.

3. Perangkat Keras

3.1 Basis Robot

Rangkaikan komponen seperti yang ditunjukkan di bawah ini. Rangkaian ini menterjemahkan semua perintah kecepatan yang dikirim dari ROS Navigation Stack menjadi gerakan motor. Firmware menyertakan pengontrol PID untuk memelihara kecepatan yang diperlukan menggunakan umpan balik dari enkoder motor.

Beberapa foto dari basis robot yang dirangkit.

Bodi robot adalah kaleng kertas A4 yang didaur ulang. Anda juga dapat menggunakan kotak plastik lama untuk menempatkan komponen Anda.

Anda dapat memeriksa proyek Linorobot saya untuk tutorial komprehensif tentang cara membangun robot ROS kompatibel DIY.

3.2 Rangkaian Pengangkat Vertikal (Induk Lengan)

Rangkaikan komponen seperti yang ditunjukkan di bawah ini. Rangkaian ini mengontrol penguatan vertikal lengan dan menterjemahkan tinggi yang diperlukan yang dikirim dari https://moveit.ros.org/ menjadi gerakan stepper. Ini adalah sistem Open-Loop yang menghitung tinggi saat ini dari lengan dengan mengaitkan jumlah langkah yang dilakukan menjadi jarak dalam milimeter. Mikrokontroler juga meneruskan data yang dikirim dari MoveIt ke lengan robot yang dipasang pada platform vertikal yang bergerak.

Berikut adalah foto dari rangkaian yang dirangkit untuk penguatan vertikal.

Kabel spiral menempatkan kabel Tx/Rx untuk komunikasi serial antara rangkaian penguatan vertikal dan pengontrol lengan robot, dan pasokan +12V DC untuk menyiram lengan robot.

3.3 Pengontrol Lengan Robot (Anak Lengan)

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

Berikut adalah foto dari pengontrol lengan robot yang dirangkit dan ditumpuk pada Arduino Uno.

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

3.4 Integrasi semua rangkaian

Terakhir, hubungkan semua rangkaian yang telah Anda rangkaikan sebelumnya seperti yang ditunjukkan di bawah ini. Diagram juga menunjukkan cara memberikan daya pada setiap rangkaian:

4. Perangkat Lunak

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

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

4.1 Instalasi ROS

Instal ROS di kedua mesin:

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

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

4.2 Instalasi Paket ROS

4.2.1 Instal hal berikut pada mesin pengembangan:

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 

4.2.2 Instal Linorobot pada komputer robot (basis robot):

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

Ini menginstal firmware basis robot, perangkat lunak navigasi, dan driver perangkat keras/sensor.

4.2.3 Instal paket O’nine di kedua mesin:

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

Ini menginstal firmware lengan robot, pemecah kinematika, dan tugas otonom Onine.

4.2.4 Instal alexa_tasker:

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

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

5. Pengaturan Perangkat Lunak

5.1 Pengaturan Keterampilan Alexa

5.1.1 Daftar dan Masuk

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

Masukkan alamat email dan kata sandi Anda:

5.1.2 Mulai Keterampilan Alexa

Klik 'Mulai' Di bawah Alexa Skills kit.

Klik 'Tambahkan sebuah Keterampilan Baru' di sudut kanan atas jendela:

5.1.3 Informasi Keterampilan

Centang 'Model Interaksi Kustom' di bawah Tipe Keterampilan.

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

Masukkan nama panggilan keterampilan Anda (nama untuk mengaktifkan keterampilan Anda) di bawah 'Nama Panggilan'.

Klik 'Berikutnya'.

5.1.4 Model Interaksi

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

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

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. Perhatikan Nama Sumber Daya Amazon setelah Anda selesai membuat fungsi.

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

Klik 'Berikutnya'.

5.1.6 Menguji keterampilan

Masukkan perintah suara di bawah 'Masukkan Ucapan' dan klik ' Tanyakan <nama keterampilan>'

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

5.2 Pengaturan Fungsi Lambda

5.2.1 Daftar dan Masuk

Buat akun AWS Lamda di sini dan klik 'Masuk ke Konsol' di sudut kanan atas jendela:

Masukkan alamat email dan kata sandi Anda.

5.2.2 Buat Fungsi Lambda

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

Pilih 'NodeJS 4.3' di bawah Runtime*.

Pilih 'Pilih peran yang sudah ada' di bawah Role*.

Pilih 'lambda_basic_execution' di bawah Peran yang Sudah Ada*.

Klik 'Buat Fungsi'.

5.2.3 Hubungkan Alexa

Tambahkan pemicu dan Pilih 'Kit Keterampilan Alexa'

Masukkan ID Keterampilan Alexa Anda di bawah ID Keterampilan.

kemudian 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/app nano 

Sekarang buat file zip yang akan diunggah ke AWS Lambda:

cd ~/onine_ws/src/onine_alexa/lambda/app npm install ./zipme 

Ini akan mengompres fungsi lambda dan node_modules yang diperlukan ke dalam .zip

Pada Kode Fungsi, pilih 'Unggah sebuah .ZIP File' di bawah tipe entri Kode.

Klik 'Unggah' dan pilih Onine.zip yang dibuat sebelumnya untuk diunggah.

Klik 'Simpan' di sudut kanan atas 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 di 'Buat APLIKASI Baru' di sudut kanan atas jendela:

Masukkan nama aplikasi Anda di bawah 'Nama Aplikasi':

5.3.3 Catat kunci publik dan langganan Anda.

5.3.4 Masukkan kunci publik dan langganan Anda pada baris ini.

5.4 Membuat Pemberitahuan Pushover

O'nine menggunakan Pushover untuk mengirim foto ke ponsel pengguna. Daftar untuk akun di sini dan unduh aplikasi 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 berhasil masuk.

5.4.2 Buat aplikasi

Klik di 'Aplikasi & Plugin' di atas jendela. Klik 'Buat sebuah Aplikasi / Token API' .

Masukkan nama Aplikasi di bawah 'Nama'.

Pilih 'Aplikasi' di bawah 'Tipe'.

Masukkan deskripsi apa pun tentang aplikasi.

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 Menginstal 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 pada komputer robot.

 rosrun lino_udev lino_udev.py 

Colokkan papan Teensy basis robot dan ketik "linobase". Lakukan hal yang sama untuk rangkaian penguatan vertikal dan namai sebagai "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 

Konfirmasi apakah aturan uDev berfungsi:

ls /dev/linobase ls /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 enkoder, dll. Klik di sini untuk mengonfigurasi robot Anda.

Colokkan papan Teensy basis robot ke komputer robot dan jalankan:

roscd linorobot/firmware/teensy platformio run --target upload 

5.5.3 Unggah firmware penguatan vertikal

Colokkan papan Teensy penguatan vertikal ke komputer robot dan jalankan:

cd platformio run --target upload 

5.5.4 Unggah firmware pengontrol robot

Colokkan Arduino Uno ke komputer robot dan jalankan:

cd platformio run --target upload 

Ingat untuk mencabut Arduino Uno setelah mengunggah kode karena data yang diterima diurai melalui papan Teensy Penguatan Vertikal menggunakan komunikasi serial.

5.6 Mengedit kode Linorobot

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

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

<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" /> 

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

5.6.2 Ubah baris ini menjadi:

 <node pkg="tf" type="static_transform_publisher" name="base_link_to_laser" args="0.065 0 0 0 0 0 /base_link /laser 100"/> 

Ini untuk membuat frame virtual yang akan digunakan untuk menterjemahkan data titik awan yang dibaca dari Kinect menjadi data pemindaian laser 2D.

5.6.3 Komentari baris ini karena transformasi untuk tautan ini sudah didefinisikan dalam file URDF Onine.

5.6.4 Ganti baris berikut ini menjadi:

 <node name="pointcloud_to_laserscan" pkg="pointcloud_to_laserscan" type="pointcloud_to_laserscan_node" output="screen"> <remap from="cloud_in" to="/camera/depth/points"/> <param name="target_frame" value="laser" /> <param name="range_max" value="4.0" /> </node> 

Ini menjalankan paket perangkat lunak untuk menterjemahkan data titik awan yang dibaca dari Kinect menjadi data pemindaian laser 2D.

5.6.5 Ganti frame referensi basis Linorobot dari base_link ke base_footprint:

Ubah dari 'base_link' ke 'base_footprint' pada yang berikut:

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 Rekompilasi node odometri:

cd ~/linorobot_ws catkin_make 

5.7 Pengaturan detektor objek O'nine

Untuk memudahkan O'nine mendeteksi objek, ia menggunakan tag AR untuk membedakan objek yang diminati saat melakukan tugas ambil dan letak. Konsep yang sama seperti robot ini:

Cetak gambar di bawah ini dan tempelkan pada objek yang ingin Anda ambil O'nine. Dimensi gambar harus 2cm x 2cm. Angka ini sembarang, cukup ingat untuk mengubah dimensi pada file launch tracker Onine.

Perangkat lunak persepsi yang digunakan adalah https://wiki.ros.org/ar_track_alvar . Ini dapat dengan mudah diganti jika Anda memilih menggunakan perangkat lunak deteksi objek sendiri atau paket ROS kompatibel lain seperti:

https://wiki.ros.org/find_object_2d

https://wiki.ros.org/tabletop_object_detector

6. Menjalankan demo

Pastikan Anda mengonfigurasi jaringan Anda sebelum memulai demo. Periksa tutorial ROS jaringan ini untuk panduan yang lebih komprehensif.

6.1 Membuat peta

O'nine menggunakan peta yang sudah dibuat untuk melokalkan dirinya sendiri dan merencanakan jalurnya saat menavigasi di sekitar rumah. Jalankan yang berikut untuk membuat peta:

Pada komputer robot, buka 2 jendela terminal baru. Jalankan bringup.launch:

roslaunch linorobot bringup.launch 

Jalankan slam.launch:

roslaunch linorobot slam.launch 

Pada 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 

Gunakan teleop_twist_keyboard, gerakkan robot di sekitar area yang ingin Anda peta.

Setelah selesai memetakan, simpan peta dengan menjalankan map_server pada 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/maps ls -a map.pgm map.yaml 

Ubah peta yang dipanggil di navigate.launch untuk memuat peta Anda sendiri. Ubah 'house.yaml' menjadi 'map.yaml'.

6.2 Mendapatkan koordinat tujuan target

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

Anda dapat mencetak koordinat ini dengan berlangganan ke move_base_simple/goal dan menunjuk lokasi target di Rviz.

SSH ke komputer robot dan jalankan yang berikut:

Jalankan bringup.launch:

roslaunch linorobot bringup.launch 

Di terminal lain jalankan stack navigasi:

roslaunch linorobot navigate.launch 

Jalankan Rviz pada komputer pengembangan Anda:

roscd lino_visualize/rviz rviz -d navigate.rviz 

Buka terminal lain pada komputer pengembangan Anda dan jalankan:

rostopic echo move_base_simple/goal 

Ini akan mencetak koordinat dan arah pose target yang akan Anda klik di Rviz.

Di Rviz, klik titik yang sekitar 1 meter dari tempat Anda ingin robot melakukan tugas dan seret ke arah robot seharusnya menghadap saat telah mencapai tujuannya. (1 kotak di Rviz sama dengan 1 meter persegi).

Salin koordinat di jendela tempat Anda mencetak 'move_base_simple/goal'

Edit onine/onine_apps/scripts/fishtask.py dan ganti Point(x,y,z) dengan position/x position/y, dan position/z dari nilai yang dicetak. Ganti Quaternion(x,y,z,w) dengan orientation/x, orientation/y, orientation/z, dan orientation/w dari nilai yang dicetak.

6.3 Menjalankan O'nine

6.3.1 Buka terminal baru pada komputer pengembangan dan jalankan ROSCORE:

roscore 

Buka tiga terminal baru pada komputer pengembangan dan SSH ke komputer robot.

6.3.2 Jalankan driver basis robot dan lengan robot:

roslaunch linorobot bringup.launch 

6.3.3 Jalankan perangkat lunak navigasi di terminal kedua:

roslaunch linorobot navigate.launch 

6.3.4 Jalankan perangkat lunak deteksi objek di terminal ketiga:

roslaunch onine_apps ar_tracker.launch 

Pada komputer pengembangan buka dua terminal baru.

6.3.5 Jalankan perangkat lunak MoveIt:

roslaunch onine_moveit_config demo.launch 

Ini akan menjalankan semua perangkat lunak yang diperlukan untuk menggerakkan lengan robot dan membuka Rviz untuk visualisasi data.

6.3.6 Jalankan klien PubNub yang meluncurkan tugas otonom setelah perintah suara melalui Amazon Echo Dot:

rosrun onine_alexa alexa_tasker.py 

6.3.7 Sebelum berbicara untuk mengeksekusi perintah suara, Anda harus membantu O'nine melokalkan diri relatif terhadap peta.

Di Rviz, klik 'Estimasi Posisi 2D' dan klik pada peta lokasi mendekati robot dan seret ke arah saat ini O'nine.

Setelah O'nine terlokalkan, Anda sekarang siap memerintah Alexa untuk meminta Onine melakukan tugas.

Bersenang-senanglah dengan robot asisten rumah pribadi baru Anda!

7. Karya Masa Depan

7.1 Model simulasi O'nine

Membangun perangkat keras dapat memakan waktu dan melelahkan. Saya berencana untuk membuat model simulasi Gazebo sehingga pengguna dapat bermain-main dengan O'nine tanpa kebutuhan perangkat keras. Dengan cara ini, Keterampilan Alexa kustom O'nine dapat dicoba secara murni dengan perangkat lunak.

7.2 Daya komputasi yang lebih baik

Papan ARM pertama yang saya gunakan untuk menjalankan O'nine adalah Nvidia Jetson TK1 yang cocok untuk aplikasi visi komputer. Karena alasan daya saya menggantinya dengan Odroid XU4 karena hanya memerlukan 5V dan memiliki bentuk yang lebih kecil. Saya saat ini memandang papan Rock64 yang memiliki RAM 4GB dan semoga mendapatkan lebih banyak daya untuk menjalankan lebih banyak aplikasi secara bersamaan. Pengaturan saat ini memerlukan beberapa aplikasi untuk di-offload ke laptop saya dan harus terhubung kabel ke papan pengembang (kabel ethernet) karena ada aliran data yang besar yang berjalan di antara kedua mesin.

Kode

Perangkat Lunak O'nine

Integrasi Alexa - Robot

Basis Robot

Skema