ROS 101: Membuat simpul penerbit

Dalam posting sebelumnya, kita lulus dari mengendarai Husky untuk mengambil sebuah Grizzly! Sekarang saatnya untuk turun dan kotor dengan apa ROS benar-benar terbuat dari: node! Kami pertama akan menciptakan ruang kerja untuk bekerja dari, maka kita akan menulis penerbit sederhana yang akan membuat maya Husky kami berkeliling secara acak. Jika ini adalah pertama kalinya Anda mengunjungi Clearpath Robotika ROS 101 blog, memulai di sini.
Membuat ruang kerja dan paket

Sebelum kita mulai menulis sebuah node, kita perlu membuat sebuah ruang kerja dan paket. Ruang kerja hanya direktori yang menyimpan semua paket Anda. Pertama kita harus membuat sebuah direktori baru.

mkdir ~ / ros101

Hal ini menciptakan sebuah direktori di folder rumah Anda, yang akan kita gunakan sebagai direktori kerja. Kita sekarang perlu membuat subdirektori dalam direktori kerja Anda untuk menyimpan semua kode sumber Anda untuk paket Anda.

mkdir ~ / ros101 / src

Langkah terakhir untuk menciptakan ruang kerja akan menginisialisasi ruang kerja dengan catkin_init_workspace.

cd ~ / ros101 / src
catkin_init_workspace

Sekarang ruang kerja kami telah dibuat, kita akan membuat paket di direktori src saja kita buat. Hal ini dapat dilakukan dengan menavigasi ke ~ / ros101 / direktori src, yang Anda harus sudah dilakukan pada langkah terakhir, dan menggunakan perintah catkin_create_pkg diikuti oleh apa yang kita inginkan paket disebutkan namanya, dan kemudian diikuti oleh apa paket lain kami paket akan tergantung pada; Perintah ini menciptakan direktori lain untuk paket baru Anda, dan dua file konfigurasi baru di dalam direktori yang dengan beberapa pengaturan default.

catkin_create_pkg random_husky_driver roscpp std_msgs

Anda dapat melihat bahwa ini dibuat CMakeLists.txt dan package.xml dalam direktori random_husky_driver; ini juga di mana Anda akan menyimpan semua kode sumber Anda untuk paket Anda. The roscpp dan std_msgs dependensi ditambahkan ke dalam CMakeLIst.txt dan package.xml.
Menulis penerbit

Seperti disebutkan dalam posting sebelumnya, penerbit menerbitkan pesan ke topik tertentu. Untuk tutorial ini, kita akan menerbitkan perintah acak dengan topik / husky / cmd_vel untuk membuat visualisasi perjalanan Husky Anda sendiri. Mulai dengan membuat file dalam ~ / ros101 / src / random_husky_driver direktori bernama random_driver.cpp, dan salin kode berikut.

#include <ros / ros.h>
#include <geometry_msgs / Twist.h>
#include <stdlib.h>

utama int (int argc, char ** argv) {
// Menginisialisasi ROS, dan set up node
ros :: init (argc, argv, "random_husky_commands");
ros :: nh NodeHandle;

// Ceates penerbit, dan mengatakan itu untuk mempublikasikan
// dengan topik husky / cmd_vel, dengan ukuran antrian 100
ros :: Penerbit pub = nh.advertise <geometry_msgs :: Putar> ("husky / cmd_vel", 100);

// Mengatur nomor acak generator
srand (waktu (0));

// Mengatur loop untuk menerbitkan pada tingkat 10Hz
ros :: tingkat Rate (10);

sementara (ros :: ok ()) {
// Mendeklarasikan pesan yang akan dikirim
geometry_msgs :: Putar msg;
// Nilai x sembarang antara -2 dan 2
msg.linear.x = 4 * ganda (rand ()) / ganda (RAND_MAX) -2;
// Nilai y sembarang antara -3 dan 3
msg.angular.z = 6 * ganda (rand ()) / ganda (RAND_MAX) -3;
// Publikasikan pesan
pub.publish (msg);

// Penundaan Sampai akhirnya sekarang saatnya untuk mengirim pesan lain
rate.sleep ();
}
}

Mari kita memecah baris kode ini dengan baris:

#include <ros / ros.h>
#include <geometry_msgs / Twist.h>

Garis-garis ini mencakup header yang kita akan membutuhkan. The <ros / ros.h> header diperlukan untuk fungsi ROS dan <geometry_msgs / Twist.h> ditambahkan sehingga kita dapat membuat pesan dari jenis itu.

ros :: init (argc, argv, "random_husky_commands");
ros :: nh NodeHandle;

Baris pertama, ros :: init, digunakan untuk menginisialisasi node ROS, dan nama itu "random_husky_commands", sementara ros: NodeHandle dimulai node.

ros :: Penerbit pub = nh.advertise <geometry_msgs :: Putar> ("husky / cmd_vel", 100);

Penerbitan pesan dilakukan dengan menggunakan ros: Penerbit pub = nh.advertise, diikuti oleh jenis pesan bahwa kita akan mengirim, dalam hal ini adalah geometry_msga :: Twist, dan topik yang kita akan mengirimnya juga, yang bagi kita adalah serak / cmd_vel.

100 adalah ukuran antrian pesan; yaitu, jika Anda mempublikasikan pesan lebih cepat dari apa yang roscpp dapat mengirim, 100 pesan akan disimpan dalam antrian untuk dikirim. Semakin besar antrian, semakin keterlambatan dalam gerakan robot dalam kasus buffering.

Oleh karena itu dalam contoh kehidupan nyata, Anda akan ingin memiliki antrian kecil dalam kasus gerakan robot, di mana keterlambatan perintah gerakan yang tidak diinginkan dan bahkan berbahaya, tapi menjatuhkan pesan yang diterima. Dalam kasus sensor, dianjurkan untuk menggunakan antrian yang lebih besar, karena delay diterima untuk memastikan tidak ada data yang hilang.

ros :: tingkat Rate (10)
...
rate.sleep ()

ROS mampu mengontrol loop frekuensi menggunakan ros: Tingkat mendikte seberapa cepat loop akan berjalan di Hz. rate.sleep akan menunda sejumlah variabel waktu sehingga siklus loop Anda pada frekuensi yang diinginkan. Akun ini untuk waktu yang dikonsumsi oleh bagian lain dari loop. Semua robot Clearpath memerlukan tingkat lingkaran minimal 10Hz.

sementara (ros :: ok ())

The ros :: ok fungsi akan kembali benar kecuali menerima perintah untuk menutup, baik dengan menggunakan perintah kill rosnode, atau oleh pengguna pusing Ctrl-C di terminal.

geometry_msgs :: Putar msg;

Hal ini menciptakan pesan kita akan mengirim, msg, dari jenis geometry_msgs: Putar
msg.linear.x = 4 * ganda (rand ()) / ganda (RAND_MAX) -2;
msg.angular.z = 6 * ganda (rand ()) / ganda (RAND_MAX) -3;



Garis-garis ini menghitung x linear acak dan nilai-nilai z sudut yang akan dikirim ke Husky.

pub.publish (msg)

Kami akhirnya siap untuk mempublikasikan pesan! Pub.publish menambahkan msg ke antrian penerbit untuk dikirim.
Kompilasi driver Husky acak

Kompilasi di ROS di ditangani oleh sistem catkin membangun. Langkah pertama biasanya akan mengatur dependensi paket kami di CMakeLists.txt dan package.xml. Namun ini telah dilakukan bagi kita ketika kita buat paket dan ditetapkan dependensi kami. Langkah berikutnya adalah kemudian untuk menyatakan node baru kami sebagai executable, ini dilakukan dengan menambahkan dua baris berikut ke file CMakeLists.txt di ~ / ros101 / src / random_husky_driver

add_executable (random_driver random_driver.cpp)
target_link_libraries (random_driver $ {} catkin_LIBRARIES)

Baris pertama menciptakan executable disebut random_driver, dan mengarahkan ROS ke file sumbernya. Garis kedua menentukan apa perpustakaan akan digunakan. Sekarang kita perlu membangun ruang kerja kami menggunakan perintah catkin_make di direktori kerja

cd ~ / ros101
catkin_make

Mari kita membuka visualisasi serak seperti yang kita lakukan dalam posting blog sebelumnya.

roslaunch husky_gazebo husky_empty_world.launch

Langkah terakhir adalah untuk sumber berkas setup.bash Anda di ruang kerja yang telah Anda buat. Script ini memungkinkan ROS untuk menemukan paket yang terkandung dalam ruang kerja Anda. Jangan lupa proses ini harus dilakukan pada setiap contoh terminal baru!

Sumber ~ / ros101 / devel / setup.bash

Sekarang saatnya untuk menguji itu! Pastikan Anda memiliki contoh dari roscore berjalan di terminal yang terpisah, kemudian mulai node.

rosrun random_husky_driver random_driver

Sekarang Anda akan melihat Husky berkeliling! Di jendela terminal baru, kita dapat memastikan bahwa simpul kami menerbitkan ke topik / husky / cmd_vel oleh bergema semua pesan tentang topik ini.

gema rostopic / husky / cmd_vel


Sekarang Anda akan melihat aliran acak linear x dan nilai-nilai z sudut.