Sa maikling gabay na ito, ating dadaluban nang pahapyaw ang konsepto ng ROS2 Services at kung paano gumawa ng Service Server.
Bilang gabay sa mga tatalakayin ng proyektong ito, sila ay nakalista bilang mga sumusunod:
1. Introduksyon sa Kurso 2. Pagpapahayag ng Konsepto ng ROS2 Services 3. Paglikha at Paggamit ng ROS2 Service sa Pamamagitan ng Isang Service Server
– Dulo ng Buod –
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!
At kung interesado ka na rin sa kung paano gumawa ng mga packages at nodes sa ROS2, mangyaring tignan mo na rin ang gabay na ito: How to Create Packages and Nodes in ROS2
Sa tutorial na ito, Gagamitin natin ang ROSject platform na handog ng TheConstruct! Subalit, kung nais niyong gumamit ng sariling virtual machine o computer, mangyaring gawing gabay 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: ROS2 Services
Noong nakaraan, ating tinalakay ang kalikasan ng iba’t-ibang interfaces na maaari nating gamitin sa ROS2, partikular na ang mga mesages. Ngayon, atin namang tatalakayin ang konsepto ng mga Services!
Bilang panguna, ano nga ba ang mga ROS2 Services?
Kung ating aalalahanin, ang mga ROS2 messages ay naglalaman lamang ng isang lipon ng mga variable na maaari nating gamitin para sa ugnayang publisher-subscriber. At dahil sa ganitong istruktura, masasabing unidirectional lamang ang nagaganap na komunikasyon. Ang kahulugan nito ay walang interaksyon o feedback mechanism na nagaganap sa pagitan ng mga nodes. Ngayon, ang services naman ay siyang nagtataglay ng dalawang pangunahing fields — ang request at response.
Ang request field ay siyang lipon ng mga variable na, mula sa client, ay kukunin ng isang server mula sa isang service, at siyang gagamitin upang makapgpabalik ng tinatawag na response. Maaari natin itong ihalintulad sa proseso ng pagtala natin ng order mula sa isang kainan. Tayo ang nagsisilbing mga client, ang mga staff ang silang itinuturing na service, at ang kainan naman ang mismong server. Bale, magpapadala tayo ng ating request — depende sa kung ano ang ating nais na kainin (request)– at ito naman ay ipapadala sa kusina (server) sa pamamagitan ng mga staff (service), at pagtapos nang lutuin ay siyang ibibigay sa atin (response).
Kung ating ihahalintulad ang arkitektura nito sa ugnayang publisher-subscriber, maituturing nating katimbang ng publisher ang service client na siyang nagpapadala ng mga message. At maituturing nating kahalintulad ng /topic ang /service na siyang nagsisilbing channel upang mapadala at matanggap ang mga ito. Ang pinakamalaking pinagkaiba lamang sa konteksto ng client-server na ugnayan ay ang pagkakaroon ng tinatawag na response. Sa publisher-subscriber, matapos na matanggap ng subscriber ang message mula sa topic, wala na itong ibinabalik na value para sa node na nagpadala ng naturang halaga na iyon; subalit, para naman sa client-server na ugnayan, magpapadala ng request ang client at ibabalik naman ng server ang response.
Ngayon at malinaw na sa atin ang konsepto ng Services at ang Client-Server na uganayan, halina’t gumawa tayo ng Server!
Unit 3: Paglikha at Paggamit ng ROS2 Service sa Pamamagitan ng Isang Service Server
1. Lumikha ng Workspaces folder na siyang maglalaman ng lahat ng ating workspaces
# In Terminal 1
user@user:~$ mkdir Workspaces
2. Sa loob nito, gumawa ng ating workspace folder – ros2_ws – at sa loob ng workspace folder na ito, gumawa ng isa pang ‘src’ folder na siyang maglalaman ng ating package na siyang papangalanang ‘simple_adder’
# In Terminal 1
user@user:~$ cd Workspaces
user@user:~/Workspaces$ mkdir ros2_ws
user@user:~/Workspaces$ cd ros2_ws
user@user:~/Workspaces/ros2_ws$ mkdir src
user@user:~/Workspaces/ros2_ws$ cd src
user@user:~/Workspaces/ros2_ws/src$ ros2 pkg create simple_adder --build-type ament_python --dependencies rclpy std_msgs example_interfaces
3. Buuin ang naturang workspace
user@user:~/Workspaces/ros2_ws$ colcon build
4. Sa loob nito, gawin natin ang ating server file – simple_adder_server.py – at gawin itong executable
user@user:~/Workspaces/ros2_ws$ cd src/simple_adder/simple_adder
user@user:~/Workspaces/ros2_ws/src/simple_adder/simple_adder$ touch simple_adder_server.py
user@user:~/Workspaces/ros2_ws/src/simple_adder/simple_adder$ chmod +x simple_adder_server.py
5. Source Code para sa simple_adder_server.py
#!/usr/bin/env python3
# Import necessary libraries | I-import ang mga kinakailangang library
import rclpy
from rclpy.node import Node
from example_interfaces.srv import AddTwoInts
class SimpleAdderNode(Node):
def __init__(self):
super().__init__("simple_adder")
# Likhain ang server
self.server_ = self.create_service(AddTwoInts, "add_ints_service", self.callback_add_ints_service)
# Gumawa ng logger upang malaman kung gumagana na ang server
self.get_logger().info("Add Ints Server Currently Active!")
# Ilikha ang callback para sa ginawang server. Dito mangyayari ang pagproproseso ng requests upang makapagpadala ng response
def callback_add_ints_service(self, request, response):
response.sum = request.a + request.b
self.get_logger().info("The sum of "+str(request.a)+" and "+str(request.b)+" is "+str(response.sum))
return response
def main(args=None):
rclpy.init(args=args)
node = SimpleAdderNode()
rclpy.spin(node)
rclpy.shutdown()
if __name__=="__main__":
main()
6. I-install ang node sa loob ng setup.py
# Hanapin ang console scripts sa ilalim ng setup.py at idagdag ang mga ito:
"simple_adder_server=simple_adder.simpler_adder_server:main"
7. Muling buuin ang package
user@user:~/Workspaces/ros2_ws/src/simple_adder/simple_adder$ cd ../../../
user@user:~/Workspaces/ros2_ws$ colcon build --packages-select simple_adder --symlink-install
user@user:~/Workspaces/ros2_ws$ ros2 run simply_adder simple_adder_server
10. Sa isa pang terminal, i-source ang install/setup.bash ng naturang workspace
user@user:~$ cd Workspaces/ros2_ws
user@user:~/Workspaces/ros2_ws$ source install/setup.bash
11. Tawagin ang naturang server
user@user:~/Workspaces/ros2_ws$ ros2 service call add_ints_server example_interfaces/srv/AddTwoInts "{a: 5, b: 10}"
At ayan! Matagumpay tayong nakalikha ng Service Server at matawag ang service nito! Kapag tapos ka nang magsiyasat, maaarin mong pindutin ang “ctrl + c” upang patayin na ang naturang node. At diyan nagtatapos ang ating maikling gabay hinggil sa paggawa ng custom messages! 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!
Hanggang sa muli! Ito si Christian C. Anabeza, ang inyong FIlipino Robotics Ambassador!
This tutorial is created by Robotics Ambassador Christian
Unit 1 Introduksyon sa Kurso
– Buod –
Tinatayang Oras na Kakailanganin: 30 minuto
Mabuhay!
Sa maikling gabay na ito, ating dadaluban kung ano nga ba ang mga ROS2 Messages at paano natin magagamit ang mga ito sa ating paggawa ng mga robots.
Bilang gabay sa mga tatalakayin ng proyektong ito, sila ay nakalista bilang mga sumusunod:
1. Introduksyon sa Kurso 1.1 Mga Pangangailangan sa Kurso at mga Sanggunian 2. Pagpapahayag ng Konsepto ng ROS2 Messages 3. Praktikal na Halimbawa: Paggawa ng Sariling Message at Paggamit nito sa uganayang publisher-subscriber
– Dulo ng Buod –
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!
At kung interesado ka na rin sa kung paano gumawa ng mga packages at nodes sa ROS2, mangyaring tignan mo na rin ang gabay na ito: How to Create Packages and Nodes in ROS2
Sa tutorial na ito, Gagamitin natin ang ROSject platform na handog ng TheConstruct! Subalit, kung nais niyong gumamit ng sariling virtual machine o computer, mangyaring gawing gabay 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: ROS2 Messages – Ano nga ba sila?
Sa kasalukuyan ay dapat pamilyar na tayo sa konsepto ng mga topics sa ROS2. Kung ating babalikan ang naging halimbawa noong nakaraan, ang mga ROS2 topics ay siyang mga nagsisilbing lagusan ng impormasyon kung saan maaari itong gamitin ng mga subscriber para mapatakbo ang isang feature ng robot. Ngayon naman’y ating dadaluban ang isa sa mga mahalagang aspeto ng mga ito at ito ang mga messages!
Sa ROS2, may tatlong pangunahing uri ng interface — ang messages, services, at actions. Sa gabay na ito, ating tatalakayin ang mga messages. Sa madaling salita, ang mga dokumentong ito ang siyang naglalaman ng mga variables na gagamitin ng ating robot o program hinggil sa pagpapagana ng naturang feature. Isang magandang halimbawa na nito ay ang Twist() message na gamit natin upang bigyan ng velocities and ating turtlesim.
Kung ating sisiyasatin ang laman ng Twist() message type, ito ang ating masisilayan: Vector3 linear Vector3 angular
At sa loob ng bawat Vector, ito naman ang laman nila:
Ibigsabihin nito ay mayroong tatlong posibleng velocities na pwedeng ipublish gamit ang message na ito. Ang mga linear velocities ay siyang tumutkoy sa paharap at palikod, pagilid, at pataas na galaw ng robot; habang ang mga angular naman ay tinatawag na pitch, yaw, at roll. Para sa mga groundbot, ang madalas gamitin na angular velocity ay ang yaw; habang para sa mga robot na panghimpapawid ay ginagamit ang anim na yan dahil mas marami ang kanilang Degrees of Freedom (DoF).
Ngayon, kung ating papansinin ang pagsulat ng mga messages sa ROS2, masasabi nating napakasimple ng kanilang istruktura. Ang tanging kailangan lamang na ilagay ay yung klase ng variable at yung pangalan nito — at hinggil naman sa pagpapangalan, dapat ay masimulan lamang ito sa kapital ng letra at ang file extension ay ‘.msg’.
<variable type> <variable name>
Ngayon at alam na natin kung ano sila, halina’t ating simulan ang paggawa at paggamit ng ating mga customized na ROS2 messages!
Unit 3: Paggawa ng Sariling Message at Paggamit nito sa Uganayang Publisher-Subscriber
Bilang panimula, tayo muna ay gumawa ng ating Workspaces folder na siyang maglalaman ng lahat ng ating workspace para sa ROS2.
# Sa Terminal 1
user:~$ mkdir Workspaces
Matapos niyan ay gumawa tayo ng workspace na ating papangalanang sample_ws. Mangyaring patakbuhin na rin ang ‘colcon build’ pagkatapos sa loob nito.
# Sa Terminal 1
user:~/Workspaces$ mkdir sample_ws
user:~/Workspaces$ colcon build
Para sa gabay na ito, gagawa tayo ng dalawang packages — una ay ating tatawaging ‘my_interface_pkg’ na siyang maglalaman ng ating custom message at ang isa naman ay ating tatawagin ‘use_custom_interface_pkg’ kung saan natin gagawin ang mga publisher at subscriber na gagamit ng ating nagawang interface.
Ngayon ay ating unahin muna ang ‘my_interface_pkg’
# Sa Terminal 1
user:~/Workspaces$ cd sample_ws
user:~/Workspaces/sample_ws$ mkdir src
user:~/Workspaces/sample_ws$ cd src
user:~/Workspaces/sample_ws/src$ ros2 pkg create my_interface_pkg --build-type ament_cmake --dependencies std_msgs rclcpp
Isang mahalagang konseptong alalahanin ay sa tuwing gagawa ng package para sa mga interfaces ay dapat na ament_cmake ang build type ng mga ito at nakadepende sa rclcpp. Subalit para sa paggawa ng nodes ay malaya tayong pumili kung nais nating gumamit ng python o cpp na environment.
Kasunod ng paggawa ng package ay gumawa tayo ng folder na ating papangalanang ‘msg’ sa loob ng my_interface_pkg. Mula rito ay gumawa na rin tayo ng ating message file na ating papangalanang ‘Numbers.msg’
# Sa Terminal 1
user:~/Workspaces/sample_ws/src$ cd my_interface_pkg
user:~/Workspaces/sample_ws/src/my_interface_pkg$ mkdir msg
user:~/Workspaces/sample_ws/src/my_interface_pkg$ cd msg
user:~/Workspaces/sample_ws/src/my_interface_pkg/msg$ touch Numbers.msg
Mangyaring kopyahin ang naturang code sa ilalim na siyang magiging laman ng Numbers.msg
int32 a
int32 b
Tumungo sa CMakeList.txt na file at idagdag ang sumusunod na mga linya:
cmake_minimum_required(VERSION 3.8)
project(my_interface_pkg)
if(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
add_compile_options(-Wall -Wextra -Wpedantic)
endif()
# find dependencies
find_package(ament_cmake REQUIRED)
find_package(std_msgs REQUIRED)
find_package(rclcpp REQUIRED)
find_package(rosidl_default_generators REQUIRED)
if(BUILD_TESTING)
find_package(ament_lint_auto REQUIRED)
# the following line skips the linter which checks for copyrights
# comment the line when a copyright and license is added to all source files
set(ament_cmake_copyright_FOUND TRUE)
# the following line skips cpplint (only works in a git repo)
# comment the line when this package is in a git repo and when
# a copyright and license is added to all source files
set(ament_cmake_cpplint_FOUND TRUE)
ament_lint_auto_find_test_dependencies()
endif()
rosidl_generate_interfaces(${PROJECT_NAME}
"msg/Numbers.msg"
)
ament_package()
Ngayon naman ay tumungo sa package.xml at idagdag ang mga sumusunod na sipi ng code:
Siguraduhing na-save ang lahat ng mga file at i-compile ang naturang package
# Terminal 1
user:~/Workspaces/sample_ws/src/my_interface_pkg/msg$ cd ../../../
user:~/Workspaces/sample_ws$ colcon build
Ngayon naman ay tumungo tayo sa paggawa ng publisher at subscriber na gagamit ng ating custom message.
Una, gumawa ng python package na ating papangalanang ‘use_custom_interface_pkg’
# Sa Terminal 1
user:~/Workspaces/sample_ws$ cd src
user:~/Workspaces/sample_ws/src$ ros2 pkg create use_custom_interface_pkg --build-type ament_python --dependencies rclpy std_msgs geometry_msgs my_interface_pkg
Para sa ating mga codes, atin itong ilalagay sa loob ng /use_custom_interface_pkg/use_custom_interface_pkg na directory at papangalanan natin ang publisher at subscriber bilang sumusunod:
Matapos i-code ang mga ito, mangyaring muling i-compile ang kabuuan ng ‘sample_ws’. At ngayon, atin nang patakbuhin ang ating mga nagawang node na gumagamit ng ating custom message!
# Sa Terminal 1
user:~/Workspaces/sample_ws/src/use_custom_interface_pkg/cd use_custom_interface_pkg$ cd ../../../
user:~/Workspaces/sample_ws$ colcon build
Para sa bahaging ito, i-source ang terminal 2 and 3 para sa sample_ws
# Sa Terminal 2 at 3
user:~$ cd Workspaces/sample_ws
user:~/Workspaces/sample_ws$ source install/setup.bash
Patakbuhin ang publisher at subscriber sa Terminal 2 at 3
# Sa Terminal 2
user:~/Workspaces/sample_ws$ ros2 run use_custom_interface_pkg custom_publisher
# Sa Terminal 3
user:~/Workspaces/sample_ws$ ros2 run use_custom_interface_pkg custom_subscriber
Ganito dapat ang lalabas sa iyong pagpapatakbo:
[INFO] [1711264604.204593355] [custom_subscriber]: Received Numbers: a=3, b=8, sum=11
[INFO] [1711264604.204593546] [custom_subscriber]: Received Numbers: a=3, b=5, sum=8
[INFO] [1711264604.187348953] [custom_subscriber]: Received Numbers: a=2, b=3, sum=5
[INFO] [1711264604.237378829] [custom_subscriber]: Received Numbers: a=4, b=4, sum=8
[INFO] [1711264604.142367827] [custom_subscriber]: Received Numbers: a=1, b=6, sum=7
...
[INFO] [1711264604.204593355] [custom_subscriber]: Received Numbers: a=7, b=9, sum=16
[INFO] [1711264604.204593355] [custom_subscriber]: Received Numbers: a=3, b=1, sum=4
At ayan!
Matagumpay nating nagawa ang ating custom message sa ROS2 at magamit ang mga ito sa publisher at subscriber! Kapag tapos ka nang magsiyasat, maaarin mong pindutin ang “ctrl + c” upang patayin na ang naturang node at maging ang simulation. At diyan nagtatapos ang ating maikling gabay hinggil sa paggawa ng custom messages! 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!
Hanggang sa muli! Ito si Christian C. Anabeza, ang inyong Filipino ROSbotics Ambassador!
Sa ating nakaraang ROSject, ating tinutukan ang hinggil sa paglikha ng mga packages at nodes sa ROS2. Ngayon naman sa maikling gabay na ito, ating dadaluban kung paano natin magagamit ang mga ito upang magpatakbo ng isang robot!
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
Panunumbalik sa Konsepto ng Packages at Nodes
2.1 Madaliang Introduksyon sa ROS Package at Node
Paano Gumawa ng Packages at Nodes sa ROS2 para mapagalaw ang Turtlebot
3.1 Pagpapagalaw Padiretso 3.2 Pagpapagalaw ng Pabilog 3.3 Pagpapagalaw ng Parisukat
Takda: Paggawa ng Simpleng Obstacle Avoidance Algorithm para sa Turtlebot
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:
At kung interesado ka na rin sa kung paano gumawa ng mga packages at nodes sa ROS2, mangyaring tignan mo na rin ang gabay na ito: How to Create Packages and Nodes in ROS2
Sa tutorial na ito, Gagamitin natin ang ROSject platform na handog ng TheConstruct! Subalit, kung nais niyong gumamit ng sariling virtual machine o computer, mangyaring gawing gabay 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 ROS Packages at Nodes?
Ating balikan ang konsepto ng mga ROS packages at nodes.
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.
Ngayon, ano namana ng mga tinatawag na NODES? Kung ang package ang siyang kumakatawan sa kabuuan ng isang kumpuni ng ating robot, ang nodes naman ang siyang maituturing na parte ng kumpuni ng ating robot. Ang mga ito, kapag pinagsama, ay siyang bumubuo o kumakatawan sa mga kakayanan o functionalities ng mga parte ng ating robot. Maaari nating isipin ito na parang ang workspace ang kabuuan ng ating robot habang ang isang parte nito, halimbawa na ay ang mga motor, ang siyang tinutukoy na package; habang ang mga nagpapagana naman sa ating motor ang siyang itinuturing na ROS Nodes!
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!
Paano Gumawa ng Packages at Nodes sa ROS2 para mapagalaw ang Turtlebot
Ngayon at may ideya na tayo hinggil sa Packages at Nodes, atin nang simulan ang pagpapatakbo ng ating Turtlebot! Para sa takdang ito, ating muling gagamitin ang Turtlesim platform upang magsilbing simulasyon para sa ating munting proyekto!
Bilang panimula, sa ating home directory, mangyaring gumawa ng Workspaces na folder na siyang maglalaman ng lahat ng ating mga workspaces. Matapos nito ay gumawa tayo ng turtlebot_ws na workspace sa loob na siyang maglalaman ng ating mga scripts upang mapatakbo ang turtlebot — at mangyaring patakbuhin ang colcon build upang mabuo ito.
In [ ]:
# Gawin sa Terminal 1
user:~$ mkdir Workspaces
user:~$ cd Workspaces
user:~/Workspaces$ mkdir turtlebot_ws
user:~/Workspaces$ cd turtlebot_ws
user:~/Workspaces/turtlebot_ws$ colcon build
Matapos patakbuhin ang mga ito, ganito dapat ang kalalabasan ng iyong directory para sa naturang workspace.
Sunod, siguraduhing naka-source nang maigi ang ating workspace sa papamamagitan ng pagpapatakbo ng:
In [ ]:
user:~/Workspaces/turtlebot_ws$ cd ~
user:~$ source ~/Workspaces/turtlebot_ws/install/devel/setup.bash
Ngayon naman ay ating nang gawin ang naturang package na magpapagalaw sa ating turtlesim!
Muli tayong bumalik sa ating turtlesim_ws, gumawa ng src folder at sa loob nito ay patakbuhin ang:
In [ ]:
user:~$ cd Workspaces/turtlebot_ws
user:~/Workspaces/turtlebot_ws$ mkdir src
user:~/Workspaces/turtlebot_ws$ cd src
user:~/Workspaces/turtlebot_ws/src$ ros2 pkg create moveturtle –build-type ament_python –dependencies rclpy geometry_msgs sensor_msgs std_msgs
Pag matagumpay ang iyong paggawa ng package, mangyaring tumungo muli sa ating workspace folder — turtlebot_ws — at patakbuhin ang colcon build. Dapat ay makita mong successful ang paggawa ng iyong package matapos ang hakbang na ito.
In [ ]:
user:~/Workspaces/turtlebot_ws$ colcon build
Kapag may lumabas na ganitong error o warning sa inyong webshell:
Mangyaring patakbuhin ang naturang syntax upang ma-update ang version ng setuptools na ginagamit ng ROSject na ito:
pip install setuptools==58.2.0
Matapos ang hakbang na ito, maaari na tayong gumawa ng ating mga nodes upang mapatakbo ang ating turtlebot!
Ngayon, tayo naman ay tumungo sa ating /moveturtle/moveturtle directory kung saan natin gagawin ang ating mga nodes.Para sa takdang ito, gagawa tayo ng tatlong uri ng galaw para sa ating turtlesim: Padiretso, Pabilog, at Parisukat na ating papangalanang line.py, circle.py, at square.py.
Upang matignan kung executable na ang ating mga nagawang file, mangyaring patakbuhin ang ‘ls-la’ sa terminal. Dapat ay may x nanakakabit sa access types ng iyong mga nalikhang files at makikita mo ring kulang luntian ang mga pangalan nito.
Ngayon, ang mga sumusunod na cells ay tumutukoy sa syntax ng bawat galaw na ating patatakbuhin para sa Turtlebot. Naglagay na rin ako ng mga pagpapaliwanang hinggil sa kung ano ang gamit ng bawat linyang nasa code.
–Syntax Para sa line.py–
In [ ]:
#!/user/env/python3
import rclpy
from rclpy.node import Node
from geometry_msgs.msg import Twist
class LineNode(Node):
def __init__(self):
super().__init__("line")
self.cmd_vel_publisher_ = self.create_publisher(Twist, '/turtle1/cmd_vel', 10)
self.timer_ = self.create_timer(0.5, self.publish_velocity)
self.get_logger().info("Moving in a Line")
def publish_velocity(self):
msg = Twist()
msg.linear.x = 0.2
self.cmd_vel_publisher_.publish(msg)
def main(args=None):
rclpy.init(args=args)
node = LineNode()
rclpy.spin(node)
rclpy.shutdown
if __name__=='__main__':
main()
–Huling Bahagi ng Syntax Para sa line.py–
–Syntax Para sa circle.py–
In [ ]:
#!/user/env/python3
import rclpy
from rclpy.node import Node
from geometry_msgs.msg import Twist
class CircleNode(Node):
def __init__(self):
super().__init__("circle")
self.cmd_vel_publisher_ = self.create_publisher(Twist, '/turtle1/cmd_vel', 10)
self.timer_ = self.create_timer(0.5, self.publish_velocity)
self.get_logger().info("Moving in a Circle")
def publish_velocity(self):
msg = Twist()
msg.linear.x = 0.2
msg.angular.z = 0.1
self.cmd_vel_publisher_.publish(msg)
def main(args=None):
rclpy.init(args=args)
node = CircleNode()
rclpy.spin(node)
rclpy.shutdown
if __name__=='__main__':
main()
Pagkatapos ng iyong paggawa ng mga program na ito, mangyaring pumunta sa setup.py at iinput ang mga sumusunod:
Muling bumalik sa workspace folder — turtlebot_ws — at patakbuhin ang colcon build. Kapag matagumpay itong nagawa, maaari na anting subukang patakbuhin ang ating turtlesim!
Sa ikalawang terminal, patakbuhin ang sumusunod na syntax upang mabuksan ang turtlesim:
In [ ]:
user:~$ ros2 run turtlesim turtlesim_node
Pagkatapos nito ay lalabas na ang naturang simulation:
Bumalik muli tayo sa terminal 1 at muling i-source ang workspace upang masigurong gumagana na ito. Matapos naman nito ay atin nang subukang patakbuhin ang mga nodes na ating nagawa!
In [ ]:
user:~/Workspaces/turtlebot_ws$ source install/setup.bash
Sa parehong terminal, atin munang siyasatin ang mga nainstall na nodes sa pamamagitan ng pagpapatakbo ng:
In [ ]:
user:~/Workspaces/turtlebot_ws$ ros2 run moveturtle
Kasunod nito ay pindutin ang ‘tab’ nang dalawang beses at ganito ang kaniyang kalalabasan.
Kung ating papansinin, makikita natin ang ating mga nalikhang nodes: circle_node, line_node, at square_node. Halina’t patakbuhin natin sila nang isa-isa.
In [ ]:
# Pagpapatakbo sa cirle_node
user:~/Workspaces/turtlebot_ws$ ros2 run moveturtle circle_node
In [ ]:
# Pagpapatakbo sa line_node
user:~/Workspaces/turtlebot_ws$ ros2 run moveturtle line_node
In [ ]:
# Pagpapatakbo sa square_node
user:~/Workspaces/turtlebot_ws$ ros2 run moveturtle square_node
Sa bawat pagtakbo nito, dapat makikita niyong bumubuo na ng mga hugis ang ating turtlesim — pabilog, padiretso, at parisukat!
At ayan! Matagumpay nating nagawa ang ating nodes sa ROS2 upang mapatakbo ang Turtlesim! Kapag tapos ka nang magsiyasat, maaarin mong pindutin ang “ctrl + c” upang patayon na ang naturang node at maging ang simulation. At diyan nagtatapos ang ating maikling gabay hinggil sa paggawa ng nodes para sa Turtlesim! 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!
Sa maikling ROSject na ito, ating tatalakayin ang isa sa mga pinakamahalagang aspeto na kailangan nating matutunan at maging bihasa bilang mga nagnanais na maging robotics developer na siyang gagamit ng ROS (Robot Operating System) para sa ating mga proyekto — at yan ay ang paggawa ang pag-aayos ng ating mga workspaces!
Ang pangunahing paksa sa kursong ito ay ang paggawa ng mga workspace at maging mga diskurso sa mga best practices sa pag-oorganisa ng mga direktori upang siguraduhin na madali at mabilis nating mahanap, magagamit, at mabubuksan ang ating mga kinakailangang programa o dokumento para sa ating mga susunod na proyektong pang-robotics!
Mayroong dalawang bahagi ang kursong ito — ang una ay siyang tatalakay sa paggawa ng workspace gamit ang ROS1 Noetic Ninjemys at ang ikalawa naman ay siyang gumagamit ng ROS2 Humble Hawksbill.
Para sa kursong ito, inaasahang may payak na kaalaman na ang user sa paggamit ng mga sistemang tumatakbo sa Ubuntu at maging ang pagkumpuni gamit ang Linux Terminal. Kung nais niyong matutunan pa lalo ang mga paksang patungkol sa pangunahing kaalmaan hinggil sa pag-proprogram gamit ang ROS, mangyaring pumunta sa website ng The Construct ukol sa kanilang kursong Code Foundation for ROS Learning Path! Ang mga maiikling kursong ito’y siguradong maghahanda sa inyo para inyong mahasa ang inyong kaalaman hinggil sa mga kinakailangang programming languages na ginagamit sa ROS.
Mga Modules na Nilalaman ng Code Foundation for ROS Learning Path:
Linux for Robotics
Python 3 for Robotics
Examination
Para sa mga nagnanais na gamitin ang kanilang sariling mga kompyueter, para sa parehong kurso ay susundan natin ang OS-to_Distribution compatiblities na galing mula sa opsiyal na dokumentasyon ng ros.org para sa parehong ROS1 Noetic Ninjemys at ROS2 Humble Hawksbill
ROS1 Noetic: PC o Virtual Machine na tumatakbo sa Ubuntu 20.04 LTS
ROS2 Noetic: PC o Virtual Machine na tumatakbo sa 22.04 LTS
1.2 ROS Workspaces
Sa bawat ROS project, lahat ng ito ay nagsisimula sa tinatwag na Workspace. Ang folder na ito ang siyang maglalaman ng halos lahat na kakailanganin ng iyong robot para ito ay tumakbo — maging mga packages, scripts, at sa pagdalob sa mga partikular ng ROS, ng iyong mga nodes at topics na siyang gagamitin sa kabuuan ng operasyon at pagdisenyo ng robot. Sa ganitong palagay ay tila napakahalagang matutunan natin ang tamang pamamaraan ng paggawa at pag-organisa ng mga nilalaman ng mga ito sapagkat dahil sa natural na pagiging komplikado ng mga ganitong sistema, maaring sa pagtagal ay tila mahirapan tayo dahil sa dami ng mga kumpuni na ating nagawa para sa naturang robot. At sa kursong ito ay siyang mismo ang ating tatalakayin – ang pagsigurado ng kaayusan at kalinisan ng ating mga folder at directory sa kabuuan ng ating development!
Halina’t simulan na natin!
1.3 1.3 Paglikha ng Iyong Unang Workspace sa ROS1
Masasabing hindi komplikado ang paggawa ng workspace sa ROS2. Sa industriya, sinusunod natin ang format ng pagpapangalan sa ating mga folder na naaayon sa syntax na ‘projectname_ws’. Para tayo ay magsimula, una muna tayong pupunta sa root directory at gagawa ng halimbawang workspace na ating papangalanang ‘robot1_ws’
Kung inyong mapapapansin, opo, ang isang workspace ay siyang kumakatawan sa isang buong robot. Sa kabuuan ng iyong development, ang folder na ito ang maglalaman ng lahat ng parte and kumpuni ng iyong proyekto.
# Patakbuhin sa Terminal 1 # Pagpunta sa Root Directory cd ~ # Paglikha ng Workspace mkdir robot1_ws
Matapos patakbuhin ang mga code na ito, iyong makikita ang iyong panibagong folder na nakalagay na sa iyong root folder:
Mula sa kaninang diskurso, kakailanganin nating pagdaluban ng diwa ang isang mahalagng tanong: Ano kaya ang magiging kalabasan ng ating directory matapos ang 100 mga workspace?
Tunay ngang maari itong magmukhang magulo lalo na at sa root folder natin silang lahat nilalagay. Upang mas mainam ang ating pag-oorganisa sa mga ito ay mangyaring gumawa tayo ng Master Folder na siyang maglalaman ng lahat ng ating mga workspace upang mas mabilis natin silang mahanap at mabuksan.
Papangalanan natin itong “Workspaces” at matapos natin itong magawa, ililipat naman natin ang kaninang “robot1_ws” na folder sa loob nito.
# Patakbuhin sa Terminal 1 # Likhain ang Master Folder mkdir Workspaces # Ilipat ang robot1_ws sa Workspaces mv robot1_ws ~/Workspaces/
Matapos nating gawin ang ating workspace folder, mangyaring gawan natin ito ng ‘src’ folder sa loob.
# Patakbuhin sa Terminal 1 cd ~/Workspaces/robot1_ws mkdir src
Ganito dapat ang kalalabasan ng iyong diretory:
Ngayon, ano ang halaga ng ‘src’ folder na ito?
Ito lang naman ang siyang naglalaman ng mga ROS Packages na ating gagamitin para sa pagdisenyo ng ating robot – nandito ang mga nodes, topics, messages, at maging mga python o c++ scripts na ating iproprogram para sa mga parte ng ating robot.
Kaya’t gumawa rin tayo ng halimbawang package at pangalanan nating camera1_pkg.
# Patakbuhin sa Terminal 1 # Pumunta sa loob ng src folder bilang paghahanda sa paggawa ng package cd src
Kung inyong papansinin, ang mag ros package ay siyang mga maituturing na mismong kumpuni ng inyong robot – maaaring ito yung para sa camera, para sa motion planning, at iba pa.
Ngayon, ang paggawa ng package sa ROS1 ay hindi nadadaan sa simpleng paglikha ng folder sa ‘src’ folder; bagkus, ay kakailanganin nating magpatakbo ng mga commands upang maisagawa ito nang maayos.
# Patakbuhin sa Terminal 1 # Siguraduhing nasa loob na ng ‘src’ folder ng iyong nagawang workspace catkin_create_pkg camera1_pkg roscpp rospy std_msgs
Matapos nito, iyong makikita ang ganitong compigurasyon ng iyong terminal
Iyo ring mapapansin ang mga panibagong laman nito tulad ng CMakeLists.txt at Package.xml na siyang naglalarawan ng mga katangian ng package na ating nalikha.
Ang bagong ‘src’ folder sa loob ng ating package naman ang siyang ating paglalagayan ng lahat ng ating c++ scripts para sa paglikha ng ating mga node. Kung nais nating mag-develop gamit ang python, mainam na lumikha tayo ng folder na pinangalanang ‘scripts’ upanag manatiling organisado at maayos ang ating mga dokumento para sa naturang proyekto.
Upang kumpletuhin ang proseso, ngayon naman ay atin nang bubuuin ang workspace gamit ang syntax na:
catkin_make
Ngunit bago natin ito gawin, siguraduhin nasa loob tayo ng folder ng ating workspace na siyang si ‘robot1_ws’
# Patakbuhin sa Terminal 1 # Bumalik sa robot1_ws folder cd ../ # Buuin ang Workspacce catkin_make
Ito ang halimbawa ng resultang lalabas sa inyong mga terminal:
Matapos nito, may mga lalabas ring panibagong mga folder at dokumento sa directory ng inyong workspace:
Pag kapareho nito ang lumabas sa inyong IDE, isang masigasig na pagbati! Matagumpay nating nagawa ang ating unang workspace gamit ang ROS1 Noetic.
Para sa ikalawang parte nitong tutorial na ito, atin namang titignan ang proseso ng paggawa ng workspace para sa ROS2 Humble. Mangyaring inyo na rin itong matignan gamit ang ROSject link na ito:
Para sa kursong ito, inaasahang may payak na kaalaman na ang user sa paggamit ng mga sistemang tumatakbo sa Ubuntu at maging ang pagkumpuni gamit ang Linux Terminal. Kung nais niyong matutunan pa lalo ang mga paksang patungkol sa pangunahing kaalmaan hinggil sa pag-proprogram gamit ang ROS, mangyaring pumunta sa website ng The Construct ukol sa kanilang kursong Code Foundation for ROS Learning Path! Ang mga maiikling kursong ito’y siguradong maghahanda sa inyo para inyong mahasa ang inyong kaalaman hinggil sa mga kinakailangang programming languages na ginagamit sa ROS.
Mga Modules na Nilalaman ng Code Foundation for ROS Learning Path:
Linux for Robotics
Python 3 for Robotics
Examination
Para sa mga nagnanais na gamitin ang kanilang sariling mga kompyueter, para sa parehong kurso ay susundan natin ang OS-to_Distribution compatiblities na galing mula sa opsiyal na dokumentasyon ng ros.org para sa parehong ROS1 Noetic Ninjemys at ROS2 Humble Hawksbill
ROS1 Noetic: PC o Virtual Machine na tumatakbo sa Ubuntu 20.04 LTS
ROS2 Noetic: PC o Virtual Machine na tumatakbo sa 22.04 LTS
1.2 ROS Workspaces
Sa bawat ROS project, lahat ng ito ay nagsisimula sa tinatwag na Workspace. Ang folder na ito ang siyang maglalaman ng halos lahat na kakailanganin ng iyong robot para ito ay tumakbo — maging mga packages, scripts, at sa pagdalob sa mga partikular ng ROS, ng iyong mga nodes at topics na siyang gagamitin sa kabuuan ng operasyon at pagdisenyo ng robot. Sa ganitong palagay ay tila napakahalagang matutunan natin ang tamang pamamaraan ng paggawa at pag-organisa ng mga nilalaman ng mga ito sapagkat dahil sa natural na pagiging komplikado ng mga ganitong sistema, maaring sa pagtagal ay tila mahirapan tayo dahil sa dami ng mga kumpuni na ating nagawa para sa naturang robot. At sa kursong ito ay siyang mismo ang ating tatalakayin – ang pagsigurado ng kaayusan at kalinisan ng ating mga folder at directory sa kabuuan ng ating development!
Halina’t simulan na natin!
1.3 Paglikha ng Iyong Unang Workspace sa ROS2
Masasabing hindi komplikado ang paggawa ng workspace sa ROS2. Sa industriya, sinusunod natin ang format ng pagpapangalan sa ating mga folder na naaayon sa syntax na ‘projectname_ws’. Para tayo ay magsimula, una muna tayong pupunta sa root directory at gagawa ng halimbawang workspace na ating papangalanang ‘robot1_ws’
Kung inyong mapapapansin, opo, ang isang workspace ay siyang kumakatawan sa isang buong robot. Sa kabuuan ng iyong development, ang folder na ito ang maglalaman ng lahat ng parte and kumpuni ng iyong proyekto.
# Patakbuhin in Terminal 1 # Pagpunta sa Root Directory cd ~ # Paggawa ng Workspace mkdir robot1_ws
Matapos patakbuhin ang mga code na ito, iyong makikita ang iyong panibagong folder na nakalagay na sa iyong root folder:
Mula sa kaninang diskurso, kakailanganin nating pagdaluban ng diwa ang isang mahalagng tanong: Ano kaya ang magiging kalabasan ng ating directory matapos ang 100 mga workspace?
Tunay ngang maari itong magmukhang magulo lalo na at sa root folder natin silang lahat nilalagay. Upang mas mainam ang ating pag-oorganisa sa mga ito ay mangyaring gumawa tayo ng Master Folder na siyang maglalaman ng lahat ng ating mga workspace upang mas mabilis natin silang mahanap at mabuksan.
Papangalanan natin itong “Workspaces” at matapos natin itong magawa, ililipat naman natin ang kaninang “robot1_ws” na folder sa loob nito.
# Patakbuhin sa in Terminal 1 # Likhain ang Master Folder mkdir Workspaces # Ilipat ang robot1_ws sa Workspaces mv robot1_ws ~/Workspaces/
Matapos nito, ganito na dapat ang lalabas sa ating directory:
Upang ating masubukan mamaya kung paano gumamit ng mahigit sa isang workspace sa ROS2, tayo’y gumawa pa ng isang folder na ating papangalanang robot2_ws sa loob ng Workspaces master folder. Matapos na ito’y gawin, ganito dapat ang kalalabasan:
# Patakbuhin sa Terminal 1 # Solusyon A: mkdir robot2_ws mv robot2_ws ~/Workspaces #Solusyon B: cd ~/Workspaces mkdir robot2_ws
Mahusay!
Ngayong nalikha na natin ang ating mga workspace folder, ang sunod na hakbang ay ang paggawa ng mga ‘src’ folder sa bawat workspace natin.
# Patakbuhin sa Terminal 1 cd ~/Workspaces/robot1_ws mkdir src cd ../ cd robot2_ws mkdir src
Ganito na dapat ang kalalabasan ng ating directory:
Matapos nito ay babalik tayo sa main folder ng ating workspace at tsaka patatakbuhin ang command na ‘colcon build’
# Patakbuhin sa Terminal 1 cd ~/Workspaces/robot1_ws colcon build cd ~/Workspaces/robot2_ws colcon build
Maglalabas ang terminal ng naturang output:
MAHALAGA: Kahit mapapansing gumana ang command na ito sa terminal, nararapat lamang na sa inyong mga lokal na kompyuter ay siguraduhing na-source nang maigi ang ating ROS Distro (Distribusyon) sa pamamagitan ng pagtakbo ng code na ito sa root folder:
# Hindi kailangang patakbuhin ngunit PALAGING TANDAAN!!! cd ~ source ~/opt/ros/[–distro–]/setup.bash # Note: the -distro- is to be replaced with the disitrbution that you have installed and are currently using. In this case, we will use humble source ~/opt/ros/humble/setup.bash
Matapos gawin ang mga ito, dapat na lumabas ang mga panibagong folder na ito sa inyong mga workspace:
Ngayon, ating talakayin ang iilan sa mga payak ngunit mahahalagang folder na kailangan nating pagtuunan ng pansin matapos ang paggawa ng ating workspace. Magsimula tayo sa ‘src’ folder, ang folder na ito ang maglalaman ng lahat ng packages na ating nalikha para sa ating robot. Bilang maikling pagtalakay, ang package ay masasabing isang esensyal na lipon ng mga script na siyang naglalarawan o naglilikha sa isang partikular na parte ng ating robot — maari itong maging camera, pang-motion-planning, at iba pa. May hiwalay na commands na kailangan upang makagawa ng package sa ROS2 na siyang tatalakayin sa iba pang maiksing kurso.
Pumunta naman tayo sa ‘install’ folder. Kung inyong mapapansin mula sa inyong mga IDE, napakaraming bagong dokumento sa loob nito at isa sa mga kailangan nating tignan ay ang ‘setup.bash’. Sa ROS2, pag nais nating gamitin ang mahigit sa isang workspace, nararapat nating ma-source nang maigi hindi lamang ang distro na gamit natin; bagkus, maging na rin ang workspace na ating patatakbuhin.
Sa ganitong palagay, kung nais nating gamitin ang laman ng ‘robot1_ws’ na workspace, kakailanganin nating i-source ito sa terminal gamit ang sumusunod na code:
# Patakbuhin sa in Terminal 1 cd ~/Workspaces source robot1_ws/install/setup.bash
Kung nais mo namang gamitin at ‘robot2_ws’ workspace, mangyaring patakbuhin ang sumusunod na command:
Ang karaniwang panuntunan na ating susundin ay ang pag-source ng setup.bash file ng workspace mula sa ‘install’ folder nito
source ~/folder1/sample_ws/install/setup.bash
# Patakbuhin sa Terminal 1 cd ~/Workspaces source robot2_ws/install/setup.bash
At ayan! Matagumpay nating nagawa ang ating workspace gamit ang ROS2 Humble Hawksbill.
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!
