Khi làm việc với robots trong các môi trường khác nhau thì bản đồ (map) là một trong những thông tin hữu ích giúp đỡ cho robot có thể định vị tọa độ, cũng như xây dựng phương hướng di chuyển để né tránh chướng ngại vật. Cho nên, trong bài blog sẽ chia sẽ cách để các bạn tạo ra map bằng việc kết hợp các package có sẵn trong ROS2 như turtlebot3, navigation. Bên cạnh đó mình cũng giới thiệu Cartographer một công cụ rất hữu ích sử dụng thuật toán SLAM được ROS tích hợp. Đây là package sẽ hỗ trợ các bạn rất nhiều trong các dự án liên quan tới robot. Tuy nhiên, blog này không đào sâu vào thuật toán SLAM mà chỉ giới thiệu tới các bạn cách cài đặt và một ví dụ về catographer.
Khởi động rosject
The Construct đã tạo ra một công cụ rất hữu ích là rosject, nơi các bạn dễ dàng truy cập và khởi tạo các project cùng với ROS ở các phiên bản khác nhau:
Như hình bên dưới là một rosject hoàn chỉnh, bạn chỉ việc nhấn vào nút RUN để khởi động rosject.
https://flic.kr/p/2pujgPJ
Sau khi nhấn vào nút RUN bạn sẽ thấy rosject được chạy trên màn hình. Ở đây, rosject cung cấp cho bạn cả terminal để có thể nhập các câu lệnh:
https://flic.kr/p/2puiHBB
Bây giờ cùng nhau đến bước tiếp theo trong ví dụ này nhé.
Cài đặt các package cần thiết
Đầu tiên các bạn cần cài đặt các package cần thiết để có thể thực hiện project này, ở đây chúng ta sử dụng turtlebot3 và ros2 navigation, cartographer, gazebo:
Sau khi cài đặt thành công các package phía trên. Cuối cùng là cài đặt package liên quan đến turtlebot3. Các bạn có thể cài đặt thông qua câu lệnh dưới đây:
sudo apt install ros-humble-turtlebot3*
https://flic.kr/p/2puhbcb
Mô phỏng trên Gazebo cùng robot
Sau khi đã thành công kiểm tra hoặc cài đặt turtlebot3 trong ROS2, tiếp theo các bạn sẽ mô phỏng robot trên môi trường Gazebo.
Tiếp theo, sau khi đã cài đặt đầy đủ các package cần thiết. Bước tiếp theo bạn cần chọn model robot cho project của bạn. mình sử dụng waffle trong project này:
export TURTLEBOT3_MODEL=waffle
Sau đó để sử dụng môi trường gazebo và robot, bạn thực hiện câu lệnh:
Cửa sổ Gazebo sẽ xuất hiện như trên cùng với robot waffle.
Khởi động Rviz cùng với cartographer
Như bạn thấy môi trường và robot đã có, tiếp theo bắt đầu với SLAM bằng việc sử dụng cartographer package. Ở cửa sổ thứ 2, các bạn thực hiện câu lệnh này, tuy nhiên khi mở cửa sổ mới đồng nghĩa với việc môi trường làm việc ko thể nhớ loại robot nào bạn đang dùng nên bạn cần export mỗi lần mở cửa sổ mới nhé:
Ở đây mình có thêm vào use_sim_time vì dùng thời gian thực của gazebo nếu như chúng ta làm việc với robot thực thì các bạn ko cần sử dụng use_sim_time. Ở đây sau khi thực hiện câu lệnh, RVIZ sẽ xuất hiện với môi trường grid map, ở đây là mô phỏng 2D từ gazebo qua, bạn có thể tùy chỉnh các lựa chọn ở mục bên trái của RVIZ để có được trải nghiệm tốt hơn về mô phỏng.
https://flic.kr/p/2pujgL7
Tạo và lưu bản đồ cùng nav2_map_server
Như các bạn đã biết, để có một bản đồ hoàn chỉnh hay còn gọi là môi trường đã biết trước, robot cần nhận biết hết các sự kiện trong môi trường. Cho nên trong project này, mình sẽ điều khiển robot di chuyển bằng cách sử dụng teleop_keyboard để robot có thể sử dụng cảm biến nhận diện môi trường xung quanh. Đầu tiên, các bạn cần đồng nhất mẫu robot mà bạn đang sử dụng trong môi trường gazebo cũng như Rviz. Tiếp theo là sử dụng turtlebot3_teleop package để di chuyển robot. Dưới đây là các câu lệnh để thực hiện:
export TURTLEBOT3_MODEL=waffle
ros2 run turtlebot3_teleop teleop_keyboard
https://flic.kr/p/2puhbcM
Ở đây, với mong muốn từng khu vực hay chướng ngại vật sẽ được thể hiện rõ trên map nên các bạn cố gắng di chuyển robot đến những khu vực đó.
https://flic.kr/p/2pujgPo
Như các bạn đã thấy, mình đã di chuyển robot để có thể quét hết toàn bộ bản đồ của môi trường. Bản đồ sẽ thể hiện rõ như hình trên. Các bạn mở cho mình một cửa sổ khác và lưu map lại nhé, bằng việc sử dụng câu lệnh sau:
ros2 run nav2_map_server map_saver_cli -f turtlebot_map
https://flic.kr/p/2puiHBg
Hy vọng qua blog này các bạn đã có thêm một số kiến thức cũng như công cụ hỗ trợ cho các dự án liên quan tới robotics sử dụng ROS. Bên cạnh đó, các bạn có thể theo dõi các blog khác cũng như các khóa học liên quan trên The Construct nhé.
Le but de ce tutoriel est d’apprendre à créer et utiliser des bibliothèques dans les packages ROS2 Python. Lors du développement d’un projet, il est essentiel de garder son code structuré pour assurer un développement efficace. L’utilisation de bibliothèque (ou library) custom est indispensable pour cela car cela permet de regrouper les codes sources en fonction de leurs usages et donc de séparer des fonctionnalités distinctes. La création de bibliothèques est donc essentielle pour rendre votre code plus structuré, modulaire et réutilisable. Nous allons donc voir ensemble comment déclarer et faire appel une custom library dans les packages ROS2 Python.
Pré-requis
Pour lancer et tester le code, vous devez lancer la simulation du turtlebot3 sur gazebo. Si vous voulez effectuer le tutoriel sur votre installation local, vous devez avoir ROS2 installé (https://docs.ros.org/en/humble/Installation.html), avoir configuré un workspace (https://docs.ros.org/en/humble/Tutorials/Beginner-Client-Libraries/Creating-A-Workspace/Creating-A-Workspace.html) et avoir installé le turtlebot3.
# pour installer tous les packages du turtlebot3 # remplacez humble par votre distro ROS2 sudo apt-get install ros-humble-turtlebot3* # n'oubliez pas d'exporter le modèle de Turtlebot3 que vous souhaitez utiliser export TURTLEBOT3_MODEL=waffle_pi
Si vous effectuez ce tutoriel en utilisant un Rosject vous pouvez directement enter les commandes suivantes dans le terminal:
# Declare le model de turtlebot3 à simuler export TURTLEBOT3_MODEL=waffle_pi # Lance la simulation du turtlebot dans gazebo ros2 launch turtlebot3_gazebo turtlebot3_world.launch.py
Une fois la simulation du turtlebot3 lancée, celle-ci va publier sur le topic /odom que nous allons utiliser dans le code exemple.
Après avoir exécuté ces commandes, appuyez sur le bounton de l’interface gazebo et selectionnez Open Gazebo.
Vous devriez obtenir le résultat suivant.
Part 1: Créer un package qui va contenir le source code de la library
Nous allons commencer par créer le package python qui va servir de bibliothèque. Ouvrez un terminal et executez les commandes suivantes:
cd ~/ros2_ws/src ros2 pkg create --build-type ament_python custom_library
Maintenant que le package est initialisé, nous allons créer le fichier qui va contenir le source code de la library. Pour faire cela, ouvrez un terminal et executez les commandes suivantes:
cd ~/ros2_ws/src/custom_library/custom_library touch odom_toolbox.py
Affichez l’éditeur de code et ouvrez le fichier odom_toolbox.py. Ajouter ensuite le code suivant:
Ce code d’exemple déclare une class contenant une méthode permettant de soustraire terme à terme la position d’une odom avec une autre et de retourner le point obtenu.
Vous pouvez compiler le package pour tester que tout fonctionne.
cd ~/ros2_ws colcon build source install/setup.bash
Part 2: Créer un package qui va utiliser la library créée précédemment
Nous allons créer un package python qui va utiliser la bibliothèque créee dans la partie une. Ouvrez un terminal et executez les commandes suivantes:
cd ~/ros2_ws/src ros2 pkg create --build-type ament_python my_package
Une fois le package créer, nous allons créer un fichier main.py qui contiendra le node exemple.
cd ~/ros2_ws/src/my_package/my_package touch main.py
Collez ensuite le code ci-dessous dans le fichier main.py.
# main.py
import rclpy
from rclpy.node import Node
from geometry_msgs.msg import Point
from nav_msgs.msg import Odometry
# importer la custom library
from custom_library.odom_toolbox import OdometryToolbox
class OdomToPointNode(Node):
def __init__(self):
super().__init__('odom_to_point_node')
# Initialiser le subscriber sur le topic odom du turtlebot3
Pour pouvoir utiliser votre library custom dans votre package, vous devez mettre à jour le setup.py du package.
# setup.py
from setuptools import setup
package_name = 'my_package'
setup(
name=package_name,
version='0.0.0',
packages=[package_name],
data_files=[
('share/ament_index/resource_index/packages',
['resource/' + package_name]),
('share/' + package_name, ['package.xml']),
],
install_requires=[
'setuptools',
# ajouter votre library dans les install_requires
'custom_library'],
zip_safe=True,
maintainer='user',
maintainer_email='user@todo.todo',
description='TODO: Package description',
license='TODO: License declaration',
tests_require=['pytest'],
entry_points={
'console_scripts': [
# Ajouter le node dans les console_scripts
'odom_to_point_node = my_package.main:main',
],
},
)
Une fois que les fichiers suivants ont été modifiés, vous pouvez build le package.
cd ~/ros2_ws colcon build source install/setup.bash
Step 3: Tester le node
Pour lancer le node, lancez la simulation comme indiqué dans les prérequis. Vous devez ensuite exécuter les commandes suivantes dans un terminal:
ros2 run my_package odom_to_point_node
Maintenant que le code est en cours d’exécution, vous devriez avoir un print des coordonnées du robot en ayant pour origine la position du robot au moment du lancement le node.
Merci d’avoir suivi ce poste.
Ressources
• ROS Ignite Academy
• ROS2 Full course for beginner
• Rosject utilisé pour le poste
Feedback
Cet article vous a plu ? Avez-vous des questions sur ce qui est expliqué ? Quoi qu’il en soit, n’hésitez pas à laisser un commentaire dans la section des commentaires ci-dessous, afin que nous puissions interagir et apprendre les uns des autres.
Si vous souhaitez en savoir plus sur d’autres sujets liés à ROS, faites-le nous savoir dans l’espace commentaires et nous ferons une vidéo ou un article à ce sujet.
Topics: ROS Q&A | ros2
This tutorial is created by Rosbotics Ambassador 019 Christian
Unit 1 Introduksyon sa Kurso
Mabuhay!
Sa ating nakaraang ROSject, ating tinutukan ang hinggil sa paglikha at pag-organisa ng ating ROS Workspaces at Directories. Ngayon naman sa maikling gabay na ito, ating dadaluban ang paggawa ng mga ROS package para sa ROS2 Humble Hawksbill!
Bilang gabay sa mga tatalakayin ng proyektong ito, sila ay nakalista bilang mga sumusunod:
Introduksyon sa Kurso 1.1 Mga Pangangailangan sa Kurso at mga Sanggunian
Ano ang mga ROS Package? 2.1 Madaliang Introduksyon sa ROS Packages 2.2 Paano gamitin ang mga ROS Package? Demo 2.2.1: Turtlesim + Ubuntu 22.04 w/ ROS2 Humble Hawksbill Virtual Machine
Paano Gumawa ng Package sa ROS2
BONUS: Paggawa ng Iyong Unang Node sa ROS2
Pangkaragdagan: Maaari mo ring gamitin ang Ingles na bersyon ng naturang notebook sa pamamagitan ng pagbukas ng default_Copy.ipynb notebook sa loob ng notebook_ws folder.
Unit 1.1 Mga Pangangailangan sa Kurso at mga Sanggunian
Para sa kursong ito, tinataya ng may-akda na may kaalaman ka na sa pangunahing operasyong pang-terminal ng mga sistemang gumagana sa Ubuntu 22.04 LTS na OS at maging sa pangunahing nabigasyon and commands na ginagamit sa mga Linux terminals. Kung nais mo pang matuto ng mga programming fundamentals na kailangan para sa pag-aral ng ROS, mangyaring tumungo at tignan ang kursong Code Foundation for ROS Learning Path ng The Construct! Tiyak na matututunan mo ang lahat ng kailangan mong kaalaman upang masimulan mo na ang paggamit ng ROS!
Mga Akdang Kasama sa Code Foundation for ROS Learning Path:
Linux for Robotics
Python 3 for Robotics
Examination
Iba pang mga Sanggunian:
The Construct Blog
Course Support of The Construct and Robot Ignite Academy
The Official Rosbotics Ambassadors Channel
This playlist from Robotics Back-End
Kung nais mong matuto hinggil sa kung paano gumawa at mag-ayos ng workspace directories sa ROS1 at ROs2, maaari mong tignan ang aking nakarrang gabay na ito: * How to Create and Organize Workspaces in ROS1 and ROS2
Sa ilang bahagi ng tutorial na ito, kakailanganin nating gumamit ng Virtual machine na tumatakbo sa Ubuntu. Para dito, ating susundan ang OS-to-Distribution compatibilities na siyang ibinahagi ng opisyal na dokumentasyon ng ros.org para sa ROS2 Humble Hawksbill
ROS2 Humble Hawksbill: PC o Virtual Machine na may Ubuntu 22.04 LTS
Unit 2 Ano ang mga ROS Packages?
Ngayong may pangunahing kaalaman na tayo hinggil sa pagsasaayos ng mga directories sa ROS — partikular na sa ROS2, ating naman ngayong daluban ang paggawa ng mga ROS packages. Bilang panguna, ano nga muna ang mga ROS Packages? Sa madaling salita, maaari nating silang tignan sa lente na kung saan ang isang package ay maaring tumutukoy sa isang partikular na bahagi o functionality ng ating robot. Bilang payak na halimbawa, maaring itong maging isang camera. Ating isipin na ang camera ng ating robot ang siyang kabuuan ng package — at sa loob nito, mayroon tayong iba pang mas maliliit ng kumpuni na, sa kontektso ng ROS, ay silang mga modyul, code, at iba pang mga bahagi na kailangan upang mabuo at mapagana ang ating camera. Yan ang ideya ng mga package sa ROS — maaari itong ilarawan bilang isang koleksyon o lipon ng mga sub-component na sa simulang sila’y paganahin ay mabubuo nila ang isang operasyon na siyang maihahalintulad sa naturang katangian, kumpuni, o functionality ng ating robot. Sa maikling bahagi na ito, tayo’y gagawa ng isang demonstrasyon hinggil sa kung paano ginagamit ang mga packages sa ROS2 sa pamamagitan ng Turtlesim! Para dito, kakailanganin nating gumamit ng hiwalay na virtual machine na mayroong Ubuntu 22.04 LTS na OS at may naka-install nang ROS2 Humble. Matapos dito ay tutungo na tayo sa paggawa ng ROS2 package sa ROSject na ito!
Demo 2.1 ROS2 Turtlesim –
Atin munang buksan ang ating virtual machine. Matapos niyo ay maghanda tayo ng isang terminal na kung saan ay nai-source na natin ang ating ROS distro.
# Sa Terminal 1
# i-source ang ROS Distro
source /opt/ros/humble/setup.bash
Atin naman ngayong bubuksan ang turtlesim simulation sa naturang terminal:
# In Terminal 1
ros2 run turtlesim turtlesim_node
Dapat ay magkaroon ka rin ng kahalintulad nito:
Pansining ang syntax na nauugnay sa pagtakbo ng nodes mula sa mga package ay sumusunod sa syntax na maaaring gawing pangkalahatang bilang:
ros2 run “package_name” “node_name”
Mula rito, tayo naman ay magbukas ng isa pang terminal at muling i-source ang ating ROS Distro. Matapos nito ay bubuksan naman natin ang magiging controller ng ating turtlebot:
# Sa Terminal 2
ros2 run turtlesim turtle_teleop_key
Mule sa code na inilathala sa ibabaw, alinsunod sa ating napagtanto hinggil sa syntax, maaaring sabihin na ang package na ‘turtlesim’ ay naglalaman ng node na ang pangalan ay turtle_teleop_key. Ano kaya sa palagay niyo ang ginagawa nitong node na ito? Atin itong subukan sa pamamagitan ng pag-enter ng naturang command!
Mukhang sa pamamagitan ng node na ito, maaari na nating manipulahin ang paggalaw ng ating turtlebot! Mangyaring masubukan niyo rin!
Mula dito, ating mapagtatantong ang mga packages, alinsunod sa ating kaninang naging kahulugan, ay tila kumakatawan sa mga partikular na parte o bahagi ng ating robot. Sa kaso ng turtlesim, tayo’y nagpatakbo ng dalawang nodes — ang turtlesim_node at turtle_teleop_key — na silang nagsisilbin bilang paraan upang maipakita ang ating robot at macontrol ito! Tayo naman ay tumungo sa susunod na paksa: Ang paggawa ng ating unang ROS2 Package.
Unit 3 Paglikha ng Unang ROS2 Package
Bumalik muli tayo sa ating ROSject platform na handog ng The Construct. Susundan natin ang kaparehong mga hakbang mula sa gabay na creating and organizing workspaces in ROS1 and ROS2. Tayo muna’y gagawa ng Workspaces folder na siyang maglalaman ng lahat ng ating mga workspaces; susundan naman ito ng paggawa ng ating workspace folder na ating papangalanang ‘sample_ws’ at sa loob nito, ay isang ‘src’ folder.
Matapos na gawin ito, tayo ay dapat na magkaroon ng direktori na kahawig ng sumusunod:
Workspaces -sample_ws -build -install -log -src
# Sa Terminal 1
user:~$ mkdir Workspaces # Lalamanin nito ang lahat ng ating magiging workspaces
user:~$ cd Workspaces # Tutungo tayo sa Workspaces folder
user/Workspaces:~$ mkdir sample_ws # Lilikha tayo ng workspace na nagngangalang ‘sample_ws’
user/Workspaces:~$ cd sample_ws
user/Workspaces/sample_ws:~$ mkdir src # Gagawa tayo ng src folder na maglalaman ng ating package
user/Workspaces/sample_ws:~$ colcon build # Ating buuin ang Workspace
user/Workspaces/sample_ws:~$ source /install/setup.bash # i-source ang workspace
File “<ipython-input-1-96164921a7fb>”, line 3
user:~$ mkdir Workspaces # Lalamanin nito ang lahat ng ating magiging workspaces
^
SyntaxError: invalid syntax
Matapos nating maayos at mabuo ang ating workspace, tayo naman ay tutungo na sa paggawa ng mismong package!
Upang masimulan ito, tutungo muna tayo sa ‘src’ folder at papatakbuhin ang sumusunod na command:
Gamit ang naturang syntax, papangalanan natin ang ating package bilang ‘test_robot’ na siyang python ang kabuuan; dahil rito, ating gagamitin ang ament_python na build type kaakibat ng dependency na rclpy. Gamit ang bagong impormasyon na ito, atin muling patatakbuhin ang naturang syntax upang mabuo ang ating package:
Matapos nito, tayo naman ay muling tutungo sa ating workspace folder, sample_ws, at muli itong bubuuin gamit ang ‘colcon build’ at i-sosource ang workspace
# Sa Terminal 1
user/Workspaces/sample_ws/src:~$ cd ../ # Angat ng isang directory!
user/Workspaces/sample_ws:~$ colcon build
user/Workspaces/sample_ws:~$ source install/devel
At ayan! Matagumpay nating nalikha ang ating unang package sa ROS2! Pero sandali lang, hindi tayo diyan nagtatapos!
Unit 4 BONUS – Paglikha ng Iyong Unang ROS2 Node
Sa pangkaragdagang bahaging ito, ating mabilisang papasadahan ang paglikha ng node sa ROS2. Mula sa kaninang naging talakayan, kung ang ating package ay siyang naglalarawan ng kabuuan ng ating kumpuni, ang mga nodes, sa kontesktong ito, ay silang mga tinutukoy na sub-component o sekundaryong mga bahagi na siyang bumubuo sa ating package. Tulad na lamang ng ating turtlesim demo, ating nasilayan ang interaksyon sa pagitan ng mga nodes na ‘turtlesim_node’ at ‘turtle_teleop_key’
Mula rito, atin nang simulan ang paggawa ng ating unang node sa ROS2!
Para sa code ng ating node, gagamit tayo ng syntax na hango sa likha ni Edouard Renard ng Robotics Backend.
Ngayon, sa ating IDE, tayo ay tumungo sa directory na ito:
~/Workspaces/sample_ws/src/test_robot/test_robot
Dito, gagawa tayo ng python script na ating papangalanang ‘test_node.py’
# Sa terminal 1
user/Workspaces/sample_ws:~$ cd src/test_robot/test_robot
user/Workspaces/sample_ws/src/test_robot/test_robot:~$ touch test_node.py
Ngayon at nalikha na natin ang script, isa sa pinakamahalagang masigurado natin ay dapat executable ang file na ito!
Kung ating patatkbuhin ang syntax na ‘ls -la’ sa naturang directory, mapapansing natin na mayroong mga karakter na kahawig ang format na ‘rw–r–r–‘. Ang mga ito ang siyang tumutukoy sa mga access permissions. Upang gawing executable ang ating script, ating patakbuhin ang sumusunod na syntax:
# Sa terminal 1
user/Workspaces/sample_ws/src/test_robot/test_robot:~$ chmod +x test_node.py
# Upang matignan kung matagumpay nating napalitan ang access permissions
user/Workspaces/sample_ws/src/test_robot/test_robot:~$ ls -la
# Ngayon ay may nakikita ka na rapat na mga x’s sa permission ng iyong file; at sa terminal naman, iyong mapapansin na nakasulat ito sa kulay luntian!
Matapos nito, atin nang susulatin ang code para sa mismong node. Hindi niyo muna kailangang daluban gaano ng diwa ang mga detalye ng code na ito sa kasalukuyan subalit akin rin kayong hinihikayat na aralin na rin kung para saan ang mga ito!
#!/usr/bin/env python3
# Atin munang i-import ang mga kinakailangang libraries import rclypy from rclpy.node import Node
class TestNode(Node): def __init__(self):
super().__init__(“first_node”)
self.get_logger().info(“ROS2 The Construct”)
def main(args=None):
rclpy.init(args=args)
node = TestNode() # ito ang ating Node
rclpy.spin(node) # Hinahayaan nitong tumatakbo ang ating node hanggangs sa atin itong patayin gamit ‘ctrl + c’
rclpy.shutdown()
if __name__ == ‘__main__’:
main()
Ngayon ay subukan nating patakbuhin ang node!
# Sa terminal 1
user/Workspaces/sample_ws/src/test_robot/test_robot:~$ ros2 run test_robot test_node.py
Ano nangyari? Mukhang pinapakita sa atin na hindi pa nakikita ng ating sistema ang package. Bakit kaya nagkaganito? Ating alalahanin na una, nilikha natin ang node; subalit, ang ating package ay hindi pa na-update sa kasalukuyan. Kaya sa ganitong palagay ay lumalabas na hindi pa installed ito sa ating ‘workspace’ kasama ng ating node. Maliban rito, sa syntax ng ating pagpapatakbo, isa ito sa mga kamalian na nararanasan ng ilang nagsisimula pa lamang sa ROS.
Alalahanin natin kung paano natin pinatakbo ang Turtlesim node. Ang ating syntax ay alinsunod sa format na ‘ros2 run ‘ – ang pinapatakbo natin ay isang nakatalagang pangalan para sa ating node at hindi mismo yung executable. Upang maresolba ang isyu na ito, tayo’y tutungo sa setup.py file na nasa loob ng ating pangunahing package folder, test_robot.
Sa loob nito, hananapin natin ang syntax na nakasulat ang “entry_points” — halintulad sa litrato sa ilalim.
Sa loob ng ‘console scripts’, ating ipapasok o iiinstall ang ating node sa ating workspace gamit ang sumusunod na syntax:
Matapos na i-save ang file naito, mangyaring tumungo muli sa workspace folder at buuin muli ang workspace at ang mga packages gamit ang colcon build. Matapos nito, huwag kakaligtaang i-source muli ang iyong ROS Distro and ang /install/setup.bash ng iyong workspace.
# Sa terminal 1
user/Workspaces/sample_ws/src/test_robot/test_robot:~$ cd ../../../
user/Workspaces/sample_ws/:~$ colcon build
user/Workspaces/sample_ws/:~$ source install/setup.bash
Ngayon, subukan muling patakbuhin ang naturang node:
# Sa terminal 1
user/Workspaces/sample_ws:~$ ros2 run test_robot node
Kahawig dapat niyo ang iyong makukuhang resulta:
At ayan! Matagumpay nating nagawa ang ating unang node sa ROS2 kasama na ng ating unang package! Kapag tapos ka nang magsiyasat, maaarin mong pindutin ang “ctrl + c” upang patayon na ang naturang node. At diyan nagtatapos ang ating maikling gabay hinggil sa paggawa ng packages sa ROS2! Nawa’y may natutunan kayong bago na makatutulong sa inyong pag-aaral ng ROS!
Para sa iba pang mga ROSject na tulad nito, mangyaring bisitahin ang The Construct. Nag-aalok sila ng napakaraming praktikal na mga gabay sa ROS mula sa mga payak hanggang sa mga konseptong pangbihasa na!
Hanngang sa muli! Ito si Christian C. Anabeza, ang inyong ROSbotics Ambassador para sa Pilipinas!
In this course, you’ll cover the foundational concepts needed to start working with ROS 2, as well as more advanced topics, all while engaging in hands-on practice.
Opening the rosject
In order to follow this tutorial, we need to have ROS2 installed in our system, and ideally a ros2_ws (ROS2 Workspace). To make your life easier, we have already prepared a rosject for that: https://app.theconstructsim.com/l/5e6f9418/
Just by copying the rosject (clicking the link above), you will have a setup already prepared for you.
After the rosject has been successfully copied to your own area, you should see a Run button. Just click that button to launch the rosject ( see this example).
After pressing the Run button, you should have the rosject loaded. Now, let’s head to the next section to get some real practice.
In order to interact with ROS2, we need a terminal.
Let’s open a terminal by clicking the Open a new terminal button.
Setup the package architecture
Create a standard ROS2 package using ament_python
With dependencies on rclpy:
cd ~/ros2_ws/src/
ros2 pkg create py_pkg –build-type ament_python –dependencies rclpy
Run the “tree .” command to see the folder structure. If you don’t have the command installed, you can install it using:
sudo apt-get update
sudo apt-get install -y tree
You should be able to see this structure which you are already familiar with:
Add custom Python module(s) that you want to import
You will need to add module files under the directory with the same name as the package (in this case py_pkg):
cd py_pkg/py_pkg
touch module_to_import.py
For this tutorial for simplicity, we can just add this minimal function to the module_to_import.py file that just prints “hello world”:
def function_to_import():
print(“hello world”)
Create a ‘scripts’ directory for your Python node(s)
Specify the directory as a Python package by creating an empty__init__.pyfile (essential for the folder to be recognized by Python as a package), then add a Python node:
cd ..
mkdir scripts
touch scripts/__init__.py
touch scripts/py_node.py
Here is a simple node implementation (to paste in py_node.py) that imports and uses the function from the module we just created:
import rclpy
from rclpy.node import Node
# Import a specific function/class from your module
from py_pkg.module_to_import import function_to_import
class MyPythonNode(Node):
def __init__(self):
super().__init__(“my_node_name”)
# Run the imported function
function_to_import()
def main(args=None):
# Initiate ROS communications
rclpy.init(args=args)
# Instantiate the node
node = MyPythonNode()
# Make the node spin
rclpy.spin(node)
# Destroy the node object
node.destroy_node()
# Shutdown ROS communications
rclpy.shutdown()
if __name__ == ‘__main__’:
main()
Final package architecture
Run the “tree.” command to see the folder structure inside py_pkg:
This is so that later when you build with colcon, ROS2 knows to put the Python packages here ~/<workspace_name>/install/<package_name>/lib/<python_version>/site-packages/<package_name> (in our case <workspace_name> is ros2_ws, <python_version> ispython3.10, and <package_name> is py_pkg).
If there is no warning then that’s great, but don’t worry if you get it as it is just a warning (not an error) and you will still be able to build successfully.
As of the time of writing this tutorial, the developers hope to have it fixed for Jazzy in May 2024, but for now, there are workarounds to remove the warning. The original workaround was to downgrade the version of setuptools that is currently installed by doing pip install setuptools==58.2.0 in the terminal. However, that is not recommended. Instead you should use the PYTHONWARNINGS environment variable to suppress that particular warning by adding this to the ~/.bashrc file:
PYTHONWARNINGS=”ignore:setup.py install is deprecated::setuptools.command.install”; export PYTHONWARNINGS
You could do this by entering this into the terminal:
echo “PYTHONWARNINGS=\”ignore:setup.py install is deprecated::setuptools.command.install\”; export PYTHONWARNINGS” >> ~/.bashrc
Don’t forget to source the .bashrc in the terminal before compiling the package to register the changes:
source ~/.bashrc # . ~/.bashrc
You should now be able to compile the package without the warning.
cd ~/ros2_ws/
colcon build –packages-select py_pkg
Run the node
In the terminal, source the ROS2 environment and start the Python node:
source ~/ros2_ws/install/setup.bash
ros2 run py_pkg py_node_executable
If you get the following output, that means it was successful!
hello world
Congratulations. You now know how to import custom Python3 modules in a ROS 2 package.
To learn more about ROS 2, have a look at the course below:
