Pengantar Sistem Operasi Robot: Kerangka Aplikasi Robot Utama

Robot Operating System (ROS) bukanlah sistem operasi yang sebenarnya, tetapi kerangka kerja dan seperangkat alat yang menyediakan fungsionalitas sistem operasi pada cluster komputer yang heterogen. Kegunaannya tidak terbatas pada robot, tetapi sebagian besar alat yang disediakan difokuskan untuk bekerja dengan perangkat keras periferal.

ROS terbagi dalam lebih dari 2000 paket, setiap paket menyediakan fungsionalitas khusus. Jumlah alat yang terhubung ke kerangka mungkin adalah kekuatan terbesarnya.

Mengapa Saya Harus Menggunakan Robot OS?

ROS menyediakan fungsionalitas untuk abstraksi perangkat keras, driver perangkat, komunikasi antar proses melalui beberapa mesin, alat untuk pengujian dan visualisasi, dan banyak lagi.

Fitur utama ROS adalah cara perangkat lunak dijalankan dan cara berkomunikasi, memungkinkan Anda merancang perangkat lunak yang kompleks tanpa mengetahui cara kerja perangkat keras tertentu. ROS menyediakan cara untuk menghubungkan jaringan proses (node) dengan hub pusat. Node dapat dijalankan di beberapa perangkat, dan terhubung ke hub itu dengan berbagai cara.

Cara utama untuk membuat jaringan adalah dengan menyediakan layanan yang dapat diminta, atau menentukan koneksi penerbit/pelanggan dengan node lain. Kedua metode berkomunikasi melalui jenis pesan tertentu. Beberapa tipe disediakan oleh paket inti, tetapi tipe pesan dapat ditentukan oleh paket individual.

Pengembang dapat merakit sistem yang kompleks dengan menghubungkan solusi yang ada untuk masalah kecil. Cara sistem diimplementasikan, memungkinkan kita untuk:

• Ganti komponen dengan antarmuka serupa dengan cepat, menghilangkan kebutuhan menghentikan sistem untuk berbagai perubahan

• Multiplexing output dari beberapa komponen menjadi satu input untuk komponen lain, memungkinkan pemecahan paralel berbagai masalah

• Hubungkan komponen yang dibuat dalam berbagai bahasa pemrograman hanya dengan menerapkan konektor yang tepat ke sistem pesan, sehingga mudah untuk mengembangkan perangkat lunak dengan menghubungkan modul yang ada dari berbagai pengembang

• Buat node melalui jaringan perangkat, tanpa mengkhawatirkan di mana kode dijalankan dan menerapkan sistem Interprocess communication (IPC) dan Remote Procedure Call (RPC)

• Langsung terhubung ke feed on demand dari perangkat keras jarak jauh tanpa menulis kode tambahan, dengan menggunakan dua poin poin sebelumnya

Kami berencana untuk mendemonstrasikan betapa bergunanya hal itu dengan mengembangkan solusi sederhana secara iteratif. Ada beberapa keunggulan utama dibandingkan dengan pendekatan lain. ROS memiliki dukungan multi platform dan memungkinkan koneksi antar proses melalui beberapa perangkat melalui koneksi peer-to-peer yang ditangani di belakang layar. Desainnya memungkinkan dukungan untuk bahasa apa pun dengan membungkus kelas komunikasi C++, atau mengembangkan kelas secara manual untuk antarmuka bahasa.

ROS dibuat oleh komunitasnya sendiri, dimaksudkan untuk komunitasnya. Setelah beberapa tahun, itu menghasilkan sejumlah besar paket yang dapat digunakan kembali yang mudah diintegrasikan, berkat arsitektur sistem.

Pendekatan alternatif seperti MRPT, CARMEN, LCM, Player, Microsoft RDS, dan lainnya menyediakan beberapa fitur tersebut, tetapi tidak semuanya. Sebagian besar waktu, kekurangan desain adalah keterbatasan dukungan bahasa, komunikasi antar proses yang tidak dioptimalkan, atau kurangnya dukungan untuk berbagai perangkat yang bisa dibilang merupakan masalah tersulit untuk diperbaiki.

Apa yang Akan Kita Bangun?

Karena fokus kami adalah kerangka kerja dan bukan algoritme aktual untuk masalah tertentu, masalah yang diberikan akan cukup sederhana. Tujuan kami adalah membangun perangkat lunak untuk komputer terpasang yang memungkinkan kami mengontrol dan memantau robot dari jarak jauh, terhubung dengan kami melalui Wi-Fi, dengan menggunakan gamepad di komputer kami dan umpan dari kamera yang dipasang di robot.

Pertama-tama, kita akan membuat program sederhana terhubung ke simulasi sederhana, hanya untuk mendemonstrasikan prinsip dasar ROS. Kami akan melampirkan gamepad ke komputer dan mencoba merancang skema kontrol yang baik untuk mengubah input gamepad menjadi sinyal kontrol untuk robot.

Bahasa utama untuk menulis kode ROS adalah C++ dan Python, C++ lebih disukai karena kinerjanya yang lebih baik. Kami akan menjelaskan contoh kami dengan Python karena lebih sedikit boilerplate dalam kode dan tidak perlu membangun secara eksplisit.

Instalasi dan Konfigurasi

Versi ROS disebut dengan nama. Sampai saat ini, rilis terbaru adalah Jade Turtle , dan versi LTS terbaru Indigo Igloo . Menggunakan versi LTS lebih disukai, dan kompatibilitas mundur tidak dijamin di ROS, jadi semua contoh akan ditulis untuk Indigo .

ROS tersedia di berbagai platform *NIX. Versi yang didukung secara resmi ada di Ubuntu. Versi OS X, Arch Linux, Debian, Raspbian dan Android didukung oleh komunitas.

Kami akan melalui proses instalasi untuk Ubuntu 14.04 di desktop. Proses untuk semua versi dan platform yang didukung tersedia di situs web resmi. Mesin virtual dengan ROS terpasang juga tersedia.

Instalasi bergantung pada platform (dan sebagian besar platform memiliki paket yang disediakan), tetapi konfigurasi ruang kerja sama untuk semua platform.

Instalasi di Ubuntu

ROS menyediakan repositorinya sendiri. Langkah pertama adalah menambahkannya.

 sudo sh -c 'echo "deb http://packages.ros.org/ros/ubuntu $(lsb_release -sc) main" > /etc/apt/sources.list.d/ros-latest.list' sudo apt-key adv --keyserver hkp://pool.sks-keyservers.net --recv-key 0xB01FA116 sudo apt-get update

Setelah itu Anda akan memiliki semua paket yang dihosting untuk semua versi ROS yang tersedia untuk versi Ubuntu Anda. Misalnya, Ubuntu 14.04 mendukung indigo dan jade .

Menginstal paket dasar di desktop memiliki salah satu dari tiga opsi:

• sudo apt-get install ros-indigo-ros-base untuk instalasi minimal

• sudo apt-get install ros-indigo-desktop karena memiliki alat GUI tambahan dasar

• sudo apt-get install ros-indigo-desktop-full untuk memiliki semua fitur resmi, termasuk berbagai simulator dan perpustakaan untuk navigasi dan persepsi

Untuk pengalaman kerja terbaik, opsi lengkap direkomendasikan. Untuk instalasi pada perangkat yang hanya akan digunakan untuk menjalankan node, versi dasar sudah cukup. Apa pun opsi yang Anda pilih, Anda dapat menginstal paket apa pun yang diperlukan bernama package_name dengan menjalankan:

 sudo apt-get install ros-indigo-<package-name>

Garis bawah diganti dengan tanda hubung di nama akhir, jadi stage_ros akan ada dalam paket ros-indigo-stage-ros .

Langkah selanjutnya adalah menginisialisasi rosdep . Paket di ROS dapat mendeklarasikan komponen apa yang mereka andalkan. rosdep memungkinkan Anda untuk mengompilasi paket-paket itu tanpa terlalu banyak penanganan ketergantungan manual. Untuk menginisialisasi, panggil:

 sudo rosdep init rosdep update

ROS memiliki beberapa variabel lingkungan yang digunakan oleh alat-alatnya. Dengan instalasi default, skrip bash untuk menginisialisasinya terletak di /opt/ros/indigo/setup.bash . Variabel perlu diinisialisasi dalam setiap sesi bash, jadi solusi terbaik adalah menambahkannya ke ~/.bashrc .

 echo "source /opt/ros/indigo/setup.bash" >> ~/.bashrc source ~/.bashrc

Beberapa paket menginstal dependensi eksternal melalui rosinstall , yang tersedia sebagai paket dan diinstal melalui sudo apt-get install python-rosinstall .

Ini adalah akhir dari instalasi di Ubuntu. Berikut ini adalah pengantar singkat untuk menginstal ruang kerja.

Konfigurasi

Sejak Groovy Galapagos , ruang kerja ROS dikelola melalui catkin . Kita perlu mendefinisikan direktori untuk semua paket yang kita host. Di dalam direktori kami membuat folder src , dan memanggil formulir catkin_init_workspace di dalamnya. Itu akan membuat berbagai tautan simbolis ke versi ROS yang bersumber saat ini. Langkah selanjutnya adalah menambahkan ruang kerja ini ke variabel lingkungan juga.

Untuk melakukan konfigurasi seluruh ruang kerja ini, pilih direktori kosong dan jalankan perintah berikut:

 mkdir src cd src catkin_init_workspace cd .. catkin_make echo "source $(pwd)/devel/setup.bash" >> ~/.bashrc source ~/.bashrc

Anda sekarang telah membuat ruang kerja di mana Anda dapat membuat paket ROS Anda sendiri.

Mengenal Alat-Alatnya

Membuat kode apa pun adalah lompatan besar. Mari kita kenali dulu beberapa sistem yang berjalan di belakang layar. Langkah pertama kami akan menjalankan GUI dasar dan melihat pesan apa yang dihasilkannya.

Untuk menjalankan apa pun di ROS, proses inti perlu diluncurkan. Semudah membuka jendela terminal baru dan mengetik:

 roscore

Di seluruh jaringan perangkat Anda yang terhubung, roscore hanya perlu diluncurkan sekali, pada perangkat yang akan menghosting hub pusat untuk pengiriman komunikasi.

Peran utama roscore adalah memberi tahu node ke node lain mana mereka harus terhubung, dan dengan cara apa (baik melalui port jaringan atau memori bersama). Tujuannya adalah untuk memungkinkan node hanya peduli tentang data apa yang ingin mereka ketahui, daripada node apa yang ingin mereka hubungkan, sambil meminimalkan waktu dan bandwidth yang dibutuhkan untuk melakukan semua komunikasi.

rqt

Setelah menjalankan roscore , kita dapat meluncurkan alat GUI utama untuk ROS: rqt . Apa yang kami lihat sangat mengecewakan - jendela kosong. rqt menghosting berbagai macam plugin yang dapat dikonfigurasi ke dalam konfigurasi visual apa pun dan sejumlah tampilan yang telah ditentukan sebelumnya.

Sebagai permulaan, mari kita jalankan plugin Robot Steering , dengan memilihnya di Plugins > Robot Tools > Robot Steering . Apa yang kami dapatkan adalah dua bilah geser, yang mewakili gerakan linier dan rotasi yang kami inginkan untuk dimiliki robot kami. Di bagian atas plugin kita melihat kotak teks dengan /cmd_vel di dalamnya. Kita bisa mengganti namanya menjadi apapun yang kita inginkan. Ini mewakili nama topik yang diterbitkan oleh kemudi. Alat terminal adalah tempat terbaik untuk melihat apa yang terjadi di latar belakang.

Alat Terminal

ROS memiliki beberapa alat canggih untuk memeriksa apa yang terjadi dalam sistem. Alat pertama yang akan kami perkenalkan adalah rostopic . Ini memungkinkan kami untuk memeriksa topik yang dapat dilanggani dan dipublikasikan oleh node. Menjalankan rostopic list akan menghasilkan:

 /cmd_vel /rosout /rosout_agg

2 topik terakhir selalu berjalan dan terkait dengan sistem ROS pusat. Topik /cmd_vel sedang diterbitkan oleh kemudi kami. Mengganti nama topik di kemudi akan mengubah namanya di sini juga. Sekarang, kami tertarik pada apa yang terjadi di dalam topik. Menjalankan rostopic echo /cmd_vel tidak akan menunjukkan apa-apa kepada kami (kecuali jika Anda mengotak-atik bilah geser). Proses berjalan sampai kami membatalkannya. Sekarang mari kita pindahkan penggeser vertikal ke 20 m/s. Melihat gema, kita dapat melihat yang berikut ini berulang-ulang:

 linear: x: 0.2 y: 0.0 z: 0.0 angular: x: 0.0 y: 0.0 z: 0.0

Seberapa sering mengirim spam ke pesan ini? rostopic hz /cmd_vel mengatakan pada kecepatan rata-rata 10 Hz. Nah, berapa banyak topik seperti ini yang bisa saya jalankan melalui koneksi Wi-Fi saya yang lambat? rostopic bw /cmd_vel mendeteksi rata-rata 480 B/s.

Nah, itu semua baik dan bagus, tapi kami berbicara tentang jenis pesan. Data ini baik untuk manusia, tetapi aplikasi akan membutuhkan data mentah, dan perlu mengetahui jenis pesan agar dapat menginterpretasikan data. Jenisnya dapat ditentukan dengan rostopic type /cmd_vel , memberi tahu kami bahwa itu adalah geometry_msgs/Twist . Semua alat terminal ROS yang dipanggil tanpa argumen apa pun mengembalikan pesan bantuan standar.

ROS Wiki cukup baik untuk melakukan pencarian web untuk string ini menghasilkan penjelasan Wiki tentang apa yang dikandungnya dan bagaimana strukturnya. Tapi kita tidak harus bergantung padanya. rosmsg adalah alat umum untuk jenis pesan. Menjalankan rosmsg show geometry_msgs/Twist akan mengembalikan:

 geometry_msgs/Vector3 linear float64 x float64 y float64 z geometry_msgs/Vector3 angular float64 x float64 y float64 z

Pesan terdiri dari dua vektor 3D, yang mewakili kecepatan linier dan sudut dalam ruang 3D.

Jika kita ingin topik apa yang terhubung dengan sebuah node, rosnode info <node-name> akan memberi kita data rinci tentang node tersebut. Alat rostopic , rosmsg dan rosnode adalah alat utama untuk memeriksa fungsionalitas ROS mentah. ROS memiliki lebih banyak GUI dan alat terminal, tetapi itu di luar cakupan kami untuk pengantar ini.

Alat utama untuk menjalankan node ROS adalah rusrun dan roslaunch . rosrun dapat menjalankan node melalui rosrun <package_name> <node_name> , dan roslaunch menjalankan node berdasarkan file peluncuran, yang sebagian kecil akan kita kenal karena mereka adalah elemen paling kompleks dari otomatisasi ROS.

Kami dapat mematikan semua yang kami jalankan untuk mulai mengerjakan kode pertama kami. Untuk referensi di masa mendatang, tidak perlu dikatakan lagi bahwa menjalankan apa pun yang terkait dengan ROS memerlukan instance aktif roscore . Banyak masalah yang Anda hadapi dapat diselesaikan dengan menutup jendela terminal tempat roscore dijalankan, dan membuka jendela baru untuk meluncurkannya kembali. Ini memperbarui semua dependensi yang perlu dimuat ulang, baik di bash maupun di roscore .

Membuat Teleoperasi Gamepad

Tujuan pertama kami adalah meniru fungsionalitas Robot Steering dengan membuat simpul yang memublikasikan data geometry_msgs/Twist ke /cmd_vel berdasarkan input gamepad. Perhentian pertama kami adalah paket joy .

Paket joy

Paket joy menyediakan driver ROS generik untuk joystick dan gamepad. Itu tidak termasuk dalam instalasi default, sehingga perlu diinstal melalui:

 sudo apt-get install ros-indigo-joy

Setelah instalasi, kita dapat menjalankan rosrun joy joy_node . Ini akan menghubungkan kita ke joystick atau gamepad default. Menjalankan rostopic list menunjukkan kepada kita bahwa kita memiliki topik yang disebut /joy . Mendengarkannya melalui rostopic echo menunjukkan kepada kami pesan dengan format berikut (perhatikan bahwa Anda harus berinteraksi dengan gamepad atau joystick agar pesan dapat dipublikasikan).

 header: seq: 4156 stamp: secs: 1450707466 nsecs: 204517084 frame_id: '' axes: [0.0, 0.0, 0.0, -0.0, 0.0, 0.0, 0.0, 0.0] buttons: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

Anda dapat mengabaikan header untuk saat ini. Selain itu, kami memiliki axes dan buttons , menjelaskan dengan baik apa yang mereka wakili. Memindahkan sumbu dan menekan tombol pada pengontrol akan menyebabkan angka-angka ini berubah. Dengan menggunakan alat kami, kami dapat menentukan bahwa jenis pesannya adalah sensor_msgs/Joy dan formatnya adalah:

 std_msgs/Header header uint32 seq time stamp string frame_id float32[] axes int32[] buttons

Membuat Teleoperasi Kami

Langkah pertama untuk menulis kode adalah membuat paket. Di dalam folder src ruang kerja, jalankan:

 catkin_create_pkg toptal_tutorial rospy joy geometry_msgs sensor_msgs

Di sini kami menyatakan nama paket yang kami buat, diikuti oleh paket yang kami rencanakan untuk diandalkan. Jangan khawatir, dependensi dapat diperbarui secara manual nanti.

Kami sekarang memiliki folder toptal_tutorial . Di dalam folder, buat folder scripts yang akan menampung semua skrip Python kami.

Mari buat file bernama teleop.py , dan di dalamnya kita akan mengatur:

 #!/usr/bin/env python import rospy from sensor_msgs.msg import Joy def joy_callback(data): print data def main(): rospy.init_node('teleop') rospy.Subscriber('joy', Joy, joy_callback) while not rospy.is_shutdown(): pass if __name__ == '__main__': main()

Kita juga perlu menyetel chmod +x teleop.py agar skrip dapat dijalankan. Menjalankan rosrun joy joy_node di satu terminal dan rosrun toptal_tutorial teleop.py di terminal lain akan menghasilkan keluaran terminal teleop.py diisi dengan pesan Joy.

Mari kita periksa apa yang dilakukan kode tersebut.

Pertama, kami mengimpor rospy, yang menampung perpustakaan untuk berinteraksi dengan kerangka kerja ROS. Setiap paket yang mendefinisikan pesan memiliki sub-paket msg dengan definisi pesan di dalamnya. Kami mengimpor Joy untuk menangani input. Tidak perlu mengimpor jenis pesan yang disematkan (seperti Header dari std_msgs.msg yang ada di pesan Joy ) kecuali jika kita ingin menyebutkannya secara eksplisit.

Langkah pertama kami adalah menginisialisasi sebuah node dengan nama tertentu (dalam hal ini, kami menyebutnya "teleop"). Setelah itu kami membuat pelanggan yang berlangganan topik "kegembiraan" dengan tipe sensor_msgs.msg.Joy , dan yang menangani setiap pesan dengan memanggil fungsi joy_callback . Callback menerima satu parameter, data dari pesan. Mengakses anggota data sederhana. Jika kita ingin mencetak status sumbu pertama, jika kita mengingat jenis pesannya, kita akan memanggil print data.axes[0] , dan itu akan menjadi float. Loop di loop akhir sampai ROS dimatikan.

Langkah kami selanjutnya adalah menangani data kami. Kita harus membuat pesan Twist yang berubah tergantung pada input, dan kemudian kita akan mempublikasikannya ke topik cmd_vel .

 #!/usr/bin/env python import rospy from sensor_msgs.msg import Joy from geometry_msgs.msg import Twist # new from functools import partial # new def joy_callback(pub, data): # modified cmd_vel = Twist() # new cmd_vel.linear.x = data.axes[1] # new cmd_vel.angular.z = data.axes[0] # new pub.publish(cmd_vel) # new def main(): rospy.init_node('teleop') pub = rospy.Publisher('cmd_vel', Twist, queue_size=1000) # new rospy.Subscriber('joy', Joy, partial(joy_callback, pub)) # modified while not rospy.is_shutdown(): pass if __name__ == '__main__': main()

Pertama, kami menambahkan pesan Twist , dan kami menambahkan dukungan untuk argumen fungsi pengikatan melalui functools.partial . Kami membuat penerbit, pub , yang menerbitkan ke cmd_vel pesan bertipe Twist . Kami mengikat penerbit itu ke panggilan balik, dan membuatnya menerbitkan pesan Putar pada setiap input dengan kecepatan yang diwakili oleh dua sumbu pertama. Kode ini melakukan apa yang kita harapkan, dan kita dapat melihat output yang dihasilkan melalui rostopic echo /cmd_vel .

Kami masih memiliki satu masalah. Topik /joy dapat dipublikasikan dengan kecepatan tinggi. Jika kita memantau rostopic hz /cmd_vel dan menggerakkan stik analog dalam lingkaran, kita dapat melihat banyak sekali pesan. Hal itu tidak hanya menghasilkan sejumlah besar komunikasi, tetapi proses yang menerima pesan-pesan ini harus memproses masing-masing dari mereka. Tidak perlu mempublikasikan data itu terlalu sering, dan kami lebih baik hanya mempublikasikan pada kecepatan stabil 10 Hz. Kita dapat melakukannya dengan kode berikut.

 #!/usr/bin/env python import rospy from sensor_msgs.msg import Joy from geometry_msgs.msg import Twist from functools import partial def joy_callback(cmd_vel, data): # modified cmd_vel.linear.x = data.axes[1] cmd_vel.angular.z = data.axes[0] # moved pub.publish(cmd_vel) to main loop def main(): rospy.init_node('teleop') cmd_vel = Twist() # new pub = rospy.Publisher('cmd_vel', Twist, queue_size=1000) rospy.Subscriber('joy', Joy, partial(joy_callback, cmd_vel)) # modified rate = rospy.Rate(10) # new while not rospy.is_shutdown(): pub.publish(cmd_vel) # new rate.sleep() # new if __name__ == '__main__': main()

Kami memodifikasi callback untuk menerima objek Twist yang dapat diubah dan memodifikasinya di dalam loop. Fungsi sleep dari rospy.Rate mempertahankan frekuensi output yang stabil.

Kode terakhir akan menghasilkan topik /cmd_vel mendapatkan perintah kecepatan pada 10 Hz, meniru output dari plugin Robot Steering rqt .

Menjalankan Sistem Simulasi

Mensimulasikan Dunia

Tujuan pertama kami adalah menciptakan lingkungan di mana kami dapat mensimulasikan skenario yang ingin kami capai. Node stageros dalam paket stage_ros memungkinkan kita untuk menjalankan satu robot dalam tahap 2D yang ditentukan melalui gambar. Ada seluruh sintaks, yang dijelaskan dalam paket stage_ros untuk file dunia dan cara membuatnya. Ini cukup sederhana, tetapi di luar jangkauan kami. Untungnya, paket ini dilengkapi dengan beberapa dunia demo. Pertama, mari kita pergi ke direktori file dengan menjalankan:

 roscd stage_ros cd world

Di dalam folder tersebut terdapat beberapa file. Mari kita jalankan satu.

 rosrun stage_ros stageros willow-erratic.world

Ini menciptakan beberapa topik. Arti masing-masing juga didokumentasikan dengan paket. Bagian yang penting adalah ia memiliki cmd_vel .

Di dalam panggung yang ditampilkan, ada kotak biru, yang mewakili robot yang Anda kendalikan. Dengan menggunakan kode kami atau Robot Steering , kami dapat mengontrol robot ini. Cobalah.

Menyiapkan sistem kami melalui file peluncuran

mari buat folder launch di dalam paket kita, dan di dalamnya buat file bernama teleop.launch . Struktur folder terakhir akan terlihat seperti ini:

 toptal_tutorial/ ├── CMakeLists.txt ├── launch │ └── teleop.launch ├── package.xml ├── scripts │ └── teleop.py └── src

Dalam file teleop.launch kita akan mendefinisikan satu set node dan interkoneksinya.

 <launch> <arg name="world_file" default="$(find stage_ros)/world/willow-four-erratics-multisensor.world" /> <node pkg="stage_ros" type="stageros" name="simulated_world" args="$(arg world_file)"></node> <group ns="robot_0"> <node pkg="joy" type="joy_node" name="joy_input"></node> <node pkg="toptal_tutorial" type="teleop.py" name="joy_convert"></node> </group> </launch>

Dunia baru terdiri dari empat robot, dan masing-masing topiknya memiliki awalan robot_<n> . Jadi, robot nomor 0 memiliki topik perintah kecepatan yang disebut robot_0/cmd_vel . Itulah sebabnya kami menempatkan kontrol kami dalam namespace yang disebut robot_0 , untuk menyesuaikan nama mereka ke bentuk baru. Dalam pengertian itu, Anda dapat menganggap nama topik sebagai folder dalam sistem file.

Untuk menjalankan launchfiles, tidak diperlukan roscore . Dalam arti tertentu, roscore hanyalah kasus khusus dari file peluncuran yang tidak melakukan apa-apa. Jika roscore tidak ada, hanya file peluncuran pertama yang diluncurkan yang akan menjalankan inti, sedangkan sisanya akan terhubung. Sekarang, kami menjalankan peluncuran dengan:

 roslaunch toptal_tutorial teleop.launch

Jika semuanya benar, ini akan menghasilkan simulator dengan 4 robot, yang salah satunya dikendalikan dengan gamepad atau joystick kita. Dunia ini memiliki lebih banyak di bawah tenda daripada yang sebelumnya. Masing-masing dari empat robot memiliki:

 /robot_<n>/base_pose_ground_truth /robot_<n>/base_scan_0 /robot_<n>/base_scan_1 /robot_<n>/camera_info_0 /robot_<n>/camera_info_1 /robot_<n>/cmd_vel /robot_<n>/depth_0 /robot_<n>/depth_1 /robot_<n>/image_0 /robot_<n>/image_1 /robot_<n>/odom

Kami mengganti <n> dengan 0, 1, 2, atau 3. Ini membawa kita ke topik terakhir kita.

Melihat Data Kami dengan rqt

Kami tidak masuk terlalu dalam ke rqt , tetapi ini adalah alat yang sempurna untuk melihat data yang lebih kompleks. Anda dapat bereksperimen dengan semua topik, tetapi kami akan fokus pada image_0 , image_1 , depth_0 , dan depth_1 .

Mari luncurkan rqt dan hapus semua plugin yang terbuka. Sekarang kita akan membuka 4 visualisator gambar ( Plugins > Visualization > Image View ), dan menempatkannya dalam formasi grid 2x2. Terakhir, di sudut kiri atas setiap tampilan, mari pilih salah satu dari empat topik yang disebutkan untuk robot_0 .

Apa yang kami dapatkan adalah penglihatan stereo dengan persepsi kedalaman, dengan kamera resolusi rendah. Ingatlah bahwa kita bahkan bisa mendapatkan hasil ini tanpa sistem input kita. Jika kita menjalankan ini (dari dalam folder stage_ros/world ):

 rosrun stage_ros stageros willow-four-erratics-multisensor.world

dan tambahkan plugin Robot Steering dengan topik yang disebut /robot_0/cmd_vel , kita akan mendapatkan hasil yang sama dengan kontrol berupa slider di layar.

Menerapkan Hasil ke Sistem Nyata

Banyak perangkat keras memiliki dukungan penuh untuk ROS, sangat sering disediakan oleh sukarelawan pihak ketiga. Banyak platform robot memiliki driver yang menghasilkan jenis pesan ini, dan ROS memiliki node yang mengambil webcam dan memublikasikan umpan gambar.

Sementara hasil terakhir adalah simulasi dari apa yang ingin kita capai, hal yang sama dapat dicapai dengan modifikasi berikut:

• Instal ROS di komputer onboard robot Anda
• Buat file peluncuran untuk komputer terpasang yang menghubungkan ROS ke platform yang mendasarinya dan semua sensor tingkat tinggi seperti kamera, pencari jangkauan laser, dan lainnya. Node yang dibutuhkan sudah ada, atau dapat diimplementasikan dengan membuat penerbit/pelanggan ROS di satu sisi, dan driver untuk komunikasi serial di sisi lain
• Jalankan launchfile saat startup
• Di komputer jarak jauh Anda, tambahkan export ROS_MASTER_URI=http://<robot_hostname>:11311/ ke startup bash Anda, membuat komputer jarak jauh mencari roscore pada nama host dan port yang diberikan
• Luncurkan rqt dan/atau skrip apa pun untuk memantau dan mengendalikan robot

Apa yang sebenarnya terjadi hanyalah mengekspor variabel lingkungan yang tepat pada perangkat jarak jauh, dan sisanya menangani sendiri. Menjalankan ROS di cluster komputer hanya membutuhkan satu langkah yang dilakukan untuk setiap mesin.

Kesimpulan

Kami telah menunjukkan bagaimana, dengan pengkodean yang sangat sedikit, Anda dapat memiliki sistem variabel yang kompleks yang dapat Anda manipulasi sesuka Anda. Sistem penerbit/pelanggan yang sederhana memungkinkan Anda untuk dengan cepat mengembangkan saluran perangkat lunak yang memproses data dalam sekelompok komputer, tanpa khawatir tentang implementasi elemen-elemen tertentu yang mendasarinya.

Meskipun kami menggunakan simulator sederhana, simulator yang lebih kompleks seperti gazebo (juga disertakan dalam versi desktop lengkap) memungkinkan Anda membuat dunia 3D dengan fisika dan sensor kompleks, dan dapat memberi Anda pengalaman hasil akhir dan produk jauh sebelum dikembangkan.

Pengenalan ini sangat mendasar, tetapi harapannya adalah Anda menjadi lebih tertarik untuk bekerja dengan kerangka kerja serbaguna ini.