Definizione e nesting di messaggi personalizzati – ROS (Noetic) Italian Tutorial

Definizione e nesting di messaggi personalizzati – ROS (Noetic) Italian Tutorial

This tutorial is created by Robotics Ambassador Alessandro

Robotics Ambassador Program https://www.theconstruct.ai/robotics-ambassador/

In questo tutorial andremo a vedere come definire messaggi personalizzati da utilizzare all’interno dei nostri nodi e come comporli per ottenere messaggi più elaborati. Inoltre vedremo come poter accedere ai singoli campi dei messaggi in modo più intuitivo all’interno del codice.
Il progetto descritto da questo tutorial è disponibile sul sito di TheConstruct al seguente link: Definizione e nesting di messaggi personalizzati [ROS Noetic] [Python]

Definire la struttura dei messaggi

All’interno del package in cui vogliamo andare a definire i nostri messaggi personalizzati (in questo caso custom_messages_nesting) andiamo a creare una nuova cartella, identificata dal nome “msg”. Questa sarà la cartella che durante la compilazione sarà utilizzata per verificare la presenza dei file di definizione dei messaggi personalizzati (che indicheremo successivamente).
Quindi possiamo creare un file con estensione .msg per ogni tipo di messaggio personalizzato che vogliamo definire.
Nel caso di questo tutorial assumiamo di voler avere un messaggio che contiene delle letture provenienti da sensori di un robot mobile con una componente di edge computing visiva, e avremo quindi:

  • NestedCustomMessage.msg che conterrà un’istanza dei seguenti messaggi e vi aggiungerà un ID
  • LidarGradient.msg rappresentante i valori del gradiente computato su una serie di letture da parte di un LiDAR
  • BoundingBoxLabeled.msg contenente le coordinate di una bounding box e la relativa label
  • EncodersReadings.msg con i valori letti dagli encoder delle ruote del nostro robot

Di seguito riportiamo le definizioni dei messaggi, in modo da avere un’idea chiara e immediata della loro struttura. In particolare possiamo notare come messaggi personalizzati possano essere annidati per andare a comporne altri più complessi, nel caso di NestedCustomMessage.

NestedCustomMessage.msg
int32 id
LidarGradient gradient
BoundingBoxLabeled bb_labeled
EncodersReadings enc_readings
LidarGradient.msg
float32[] measures
BoundingBoxLabeled.msg
string label
float32 x_left
float32 x_right
float32 y_top
float32 y_bottom
EncodersReadings.msg
float32 wheel1
float32 wheel2
float32 wheel3

Garantire la compilazione e generazione dei messaggi

Per poter usufruire dei messaggi che abbiamo definito è necessario dare indicazione a ROS di dove si trovino e delle dependencies necessarie alla loro compilazione e generazione. Per questo motivo apporteremo delle modifiche al file CMakeLists.txt e al Package.xml del nostro package.

Package.xml

All’interno di questo file dobbiamo aggiungere le due seguenti righe:

<build_depend>message_generation</build_depend>
<exec_depend>message_runtime</exec_depend>

CMakeLists.txt

Qui partiamo dal modificare le required components in questo modo:

find_package(catkin REQUIRED COMPONENTS
   rospy
   std_msgs
   message_generation
)

Indichiamo poi i file in cui abbiamo definito i messaggi (i file verranno cercati all’interno della cartella “msg” del nostro package):

add_message_files(
   FILES
   LidarGradient.msg
   BoundingBoxLabeled.msg
   EncodersReadings.msg
   NestedCustomMessage.msg
)

E includiamo le dependencies necessarie per la generazione dei nostri messaggi. In questo caso i nostri messaggi dipendono solo da std_msgs (abbiamo usato solo stringhe e float), per cui sarà sufficiente includere:

generate_messages(
   DEPENDENCIES
   std_msgs
)

Generazione dei messaggi

Possiamo a questo punto verificare che tutto sia stato definito in modo corretto e che ROS sia in grado di trovare, identificare e generare i nostri messaggi personalizzati.
Ci spostiamo all’interno di un terminale, a livello del nostro workspace di catkin, e ricompiliamo.

catkin_make

Importare e accedere ai singoli campi dei messaggi

La situazione di partenza di questo tutorial è un semplice publisher (custom_messages_nesting/script/custom_user_node.py) che pubblica un Float32. Andremo ora a modificare il codice per poter includere i nostri messaggi.

#! /usr/bin/env python3

import rospy
from std_msgs.msg import Float32

def start_chatter():
   rospy.init_node('custom_chatter')
   pub = rospy.Publisher('custom_chatter_topic', Float32, queue_size = 10)
   rate = rospy.Rate(1)
   id = 0
   while not rospy.is_shutdown():
      id += 1
      pub.publish(id)
      rate.sleep()

if __name__ == "__main__":
   try:
      start_chatter()
   except rospy.ROSInterruptException:
      pass

Vogliamo per prima cosa importare i messaggi personalizzati. Aggiungiamo quindi (o rimpiazziamo l’import già presente con):

from custom_messages_nesting.msg import LidarGradient.msg, BoundingBoxLabeled.msg, EncodersReadings.msg, NestedCustomMessage.msg

Possiamo poi quindi ridefinire il publisher in modo che pubblichi il nostro NestedCustomMessage:

pub = rospy.Publisher('custom_chatter_topic', NestedCustomMessage, queue_size = 10)

Per poter accedere ai singoli campi della struttura del NestedCustomMessage (nel caso della pubblicazione) sarà sufficiente istanziare i sottomessaggi di cui è composto e assegnare ai rispettivi campi i valori letti dai nostri ipotetici sensori.
Istanziamo quindi tutti i messaggi necessari:

nc = NestedCustomMessage()
gradient_msg = LidarGradient()
bb_labeled_msg = BoundingBoxLabeled()
enc_readings_msg = EncodersReadings()

E procediamo ad assegnare loro dei valori, accedendo ai campi del messaggio con il nome che abbiamo indicato all’interno della rispettiva definizione. In particolare per questo esempio abbiamo selezionato i seguenti valori:

gradient_msg.measures = range(36)
bb_labeled_msg.label = 'Persona'
bb_labeled_msg.x_left = bb_labeled_msg.y_bottom = 1.0
bb_labeled_msg.x_right = bb_labeled_msg.y_top = 2.0
enc_readings_msg.wheel1 = enc_readings_msg.wheel2 = enc_readings_msg.wheel3 = 0.035

Avendo assegnato valori a tutte le componenti di NestedCustomMessage, queste possono poi essere unite per andare a comporre il nostro messaggio finale in questo modo:

nc.id = id
nc.gradient = gradient_msg
nc.bb_labeled = bb_labeled_msg
nc.enc_readings = enc_readings_msg

Test del publisher

Per verificare che tutto funzioni correttamente sarà sufficiente eseguire il nodo e osservare il relativo topic.
In una prima shell:

roscore

In una seconda shell:

rosrun custom_messages_nesting custom_user_node.py

E infine in una terza shell:

rostopic echo /custom_chatter_topic

Il risulato che ci aspettiamo è di osservare che il nostro messaggio viene pubblicato una volta al secondo, con ID crescente e con gli altri campi in accordo con quello che abbiamo indicato nel codice del nodo.

E con questo abbiamo accesso a infinite possibilità, componendo i messaggi come più conviene e utilizzandoli all’interno della nostra implementazione!

Video Tutorial

How to Create MoveIt Package for Robotic Arm

How to Create MoveIt Package for Robotic Arm

This tutorial is created by Robotics Ambassador Muhammad

 

Robotics Ambassador: theconstruct.ai/robotics-ambassador/

What are we going to Learn?

  1. How to create ROS2 Package
  2. How to compile ROS2 workspace
  3. How to create node in Python to spawn new object in Gazebo Simulation

List of Resources in this Post

  1. ROSJect Link: https://app.theconstruct.ai/l/5fcb7f9e/
  2. Robotic Arm Used as Resource: https://github.com/hamzamerzic/ros-threeseg/
  3. The Construct App: https://app.theconstructsim.ai/

Overview:

ROS (Robot Operating System) is a de facto standard for Robotics. In order to program Robots, simulation of Real world systems is very important to test and debug the systems. MoveIt is most commonly used Motion Planning Library for Robotic Arms or Manipulators. In this tutorial we will create MoveIt Package for simple robotic arm.

Opening the ROSJect:

To follow along the post, we need to have ROS2 installed in our system. To make things easier, we have created ROSJect to follow along: https://app.theconstruct.ai/l/5fcb7f9e/.

Next, fort the ROSJect and click Run. You will be presented with the interface like following.

In terminal, go to your workspace. by running the following command

cd catkin_ws/src

and then clone the resource Robotic arm Package from Github. by typing

git clone https://github.com/hamzamerzic/ros-threeseg/

Next run,

cd ..

and then run the ROS Workspace

catkin_make

Next, you need to install some MoveIt packages for ROS version.

sudo apt update

Then run,

sudo apt install ros-noetic-moveit

This will install MoveIt Motion Planning Library with ROS.

Creating MoveIt Package:

Now we are going to create MoveIt Package for our Robotic Arm. In the terminal, source your ROS Workspace.

cd /home/user/catkin_ws

source devel/setup.bash

After that,

roslaunch moveit_setup_assistant setup_assistant.launch

Click on “Create New MoveIt Configuration Package”. and select URDF File for package we have cloned in our ROS Workspace.

Next, go to “Planning Groups” and create new Group “Add Group”, and write name of group, kinematic solver and Group Default planner as follows

Then Create new Kinematic Chain, as follows

Then select joints for this group

and after that select Links for this Planning Group

After going through this step, we can configure various poses for Robotic Arm.

Next fill out some author information,

and generate the MoveIt Package.

Final Thoughts

Now that we have generated the MoveIt package for our robotic arm, next we will add custom controllers and hardware interfaces for simulating this in Gazebo. MoveIt is very practically useful tool for robotic arms as it can be used for motion planning, trajectory generation and solving Inverse Kinematics for Robotic arms.

Video Tutorial

Simulação do BB8 com ROS Noetic: Mensagens Customizadas em C++ para Services | Portuguese ROS Tutorial

Simulação do BB8 com ROS Noetic: Mensagens Customizadas em C++ para Services | Portuguese ROS Tutorial

O que nós vamos aprender:

  1. Entender o funcionamento dos serviços no ROS Noetic, e como eles podem ser utilizados para controlar o robô BB-8.
  2. Desenvolver mensagens customizadas em C++ para enviar comandos específicos ao BB-8.
  3. Configurar e compilar um pacote ROS do zero, incluindo a criação de serviços e mensagens de serviço.
  4. Lançar e interagir com a simulação do BB-8 no Gazebo, utilizando os comandos desenvolvidos para controlar o robô.
  5. Escrever e rodar um servidor de serviços em ROS, que permitirá enviar comandos para o BB8.

Lista de recursos usados neste post:

  1. Use este rosject: https://app.theconstructsim.com/l/5e7ce8b4/
  2. The Construct: https://app.theconstructsim.com/
  3. ROS Courses: ROS Basics in 5 Days (C++) https://app.theconstructsim.com/courses/56

Panorama

Olá! Hoje vamos explorar os serviços do ROS, focando no ROS 1 Noetic e em um dos robôs mais fascinantes disponíveis na plataforma: o BB-8 de Star Wars. Utilizaremos os serviços para criar comandos que permitam ao BB-8 desenhar formas no chão ou seguir trajetórias específicas, como quadrados ou círculos, por meio de mensagens customizadas.

Abrindo o rosject

Para acompanhar este tutorial, utilize um rosject, que é essencialmente um projeto ROS configurado para rodar um exemplo. Acesse o link fornecido e clique no botão vermelho.

https://app.theconstructsim.com/l/5fc3aef0/

Criando o pacote

Inicie abrindo um terminal e siga os comandos abaixo para criar o pacote e os arquivos necessários para nossa aplicação.

roscd; cd ..; cd src/bb8; catkin_create_pkg bb8_service_pkg roscpp std_msgs
cd bb8_service_pkg; mkdir srv;
cd srv; touch bb8ServiceMessage.srv; cd ..;
cd src; touch bb8_service_server.cpp; chmod +x *.cpp

Você notará que novos arquivos surgirão na árvore de pastas da janela IDE.

Configurando a mensagens de serviço
As mensagens de serviço incluem sempre os requests e responses. Para comandar o BB-8, trataremos isso como uma string. Edite o arquivo bb8ServiceMessage.srv com o seguinte conteúdo:

string command # A string command representing the action
---
bool success # Did it achieve it?

Preparando para compilar

É importante modificar o CMakeList.txt copiando e colando o conteúdo abaixo, substituindo o conteúdo existente.

cmake_minimum_required(VERSION 3.0.2)
project(bb8_service_pkg)

find_package(catkin REQUIRED COMPONENTS
roscpp
std_msgs
message_generation
)

add_service_files(
FILES
bb8ServiceMessage.srv
)

generate_messages(
DEPENDENCIES
std_msgs
)

catkin_package(
CATKIN_DEPENDS roscpp
)

include_directories(include ${catkin_INCLUDE_DIRS})

add_executable(bb8_service_server src/bb8_service_server.cpp)
add_dependencies(bb8_service_server ${bb8_service_server_EXPORTED_TARGETS} ${catkin_EXPORTED_TARGETS})
target_link_libraries(bb8_service_server
${catkin_LIBRARIES}
)

Não esqueça de adicionar as três linhas indicadas no final do package.xml. Atençã0, não substitua todo o conteúdo do arquivo! Apenas adicione as linhas:

<build_depend>message_generation</build_depend>
<build_export_depend>message_runtime</build_export_depend>
<exec_depend>message_runtime</exec_depend>

 Escrevendo o servidor de serviços

Agora, você pode prosseguir para a parte onde os comandos são recebidos pelo servidor do serviço. Na pasta src, abra o arquivo bb8_service_server.cpp e insira o conteúdo necessário.

#include "geometry_msgs/Twist.h"
#include "ros/ros.h"
#include <bb8_service_pkg/bb8ServiceMessage.h>
#include
#include

ros::Publisher pub;
geometry_msgs::Twist mov;

using namespace std;

bool my_callback(bb8_service_pkg::bb8ServiceMessage::Request &req,
bb8_service_pkg::bb8ServiceMessage::Response &res) {

ROS_INFO("The Service has been called");

if (req.command == "square") {
int j = 0;
while (j < 4) {
// straight
mov.linear.x = 0.5;
mov.angular.z = 0.0;
pub.publish(mov);
usleep(4000000);

// spin
mov.linear.x = 0;
mov.angular.z = 1.0;
pub.publish(mov);
usleep(2000000);
j++;
}
}

if (req.command == "circle") {
mov.linear.x = 1.5;
mov.angular.z = 1.5;
pub.publish(mov);
usleep(6000000);
}

if (req.command == "dance") {
int j = 0;
while (j < 4) {
mov.linear.x = 1.5;
mov.angular.z = 0.5;
pub.publish(mov);
usleep(2000000);

mov.linear.x = -0.5;
mov.angular.z = -1.0;
pub.publish(mov);
usleep(3000000);
j++;
}
}

mov.linear.x = 0;
mov.angular.z = 0;
pub.publish(mov);
ROS_INFO("Finished service");

res.success = true;
return res.success;
}

int main(int argc, char **argv) {
ros::init(argc, argv, "server_node");
ros::NodeHandle nh;

ros::ServiceServer my_service = nh.advertiseService("/move_bb8", my_callback);
pub = nh.advertise("cmd_vel", 1000);
ROS_INFO("Service Ready");
ros::spin();

return 0;
}

Compilando o pacote e lançando a simulação

No terminal 1, xecute o comando abaixo para compilar apenas o pacote que criamos, economizando tempo.

cd ~/catkin_ws/; catkin_make --only-pkg-with-deps bb8_service_pkg; source devel/setup.bash

Se tudo foi feito corretamente, você não verá nenhum erro no prompt:

Após a compilação, inicie o Gazebo com o comando apropriado para visualizar o robô BB-8 preparado para funcionar.

roslaunch bb_8_gazebo main.launch

Isto fará aparecer a janela do Gazebo.

Rodando o servidor de serviços

No terminal 2, execute o comando para iniciar o servidor de serviços:

rosrun bb8_service_pkg bb8_service_server

Uma mensagem confirmará que o serviço está pronto.

Chamando o serviço criado

Utilize um terceiro terminal para enviar comandos ao BB-8. Por exemplo, para fazê-lo se mover em um quadrado ou círculo, ou até mesmo dançar, use os comandos apropriados.

rosservice call /move_bb8 "command: 'square'"
rosservice call /move_bb8 "command: 'circle'"
rosservice call /move_bb8 "command: 'dance'"

Esperamos que este post seja útil e que você se divirta trabalhando com o BB-8, um robô incrível tanto em termos gráficos quanto funcionais.

 Vídeo no YouTube

Este foi o post de hoje. Lembre-se que nós temos uma versão deste post em vídeo no YouTube.

Se você gostou do conteúdo, por favor, considere se inscrever no nosso canal do YouTube. Estamos publicando novos conteúdos quase todos os dias.

Continue avançando no seu aprendizado de ROS.

Video Tutorial

Paano Gumawa ng mga Nodes Upang Pagalawin ang Turtlebot – Filipino ROS Tutorials

Paano Gumawa ng mga Nodes Upang Pagalawin ang Turtlebot – Filipino ROS Tutorials

Unit 1 Introduksyon sa Kurso

Mabuhay!

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:

  1. Introduksyon sa Kurso

    1.1 Mga Pangangailangan sa Kurso at mga Sanggunian

  2. Panunumbalik sa Konsepto ng Packages at Nodes

    2.1 Madaliang Introduksyon sa ROS Package at Node

  3. 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

  4. 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:

Iba pang mga Sanggunian:

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

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.

In [ ]: user:~/Workspaces/turtlebot_ws$ cd src/moveturtle/moveturtle user:~/Workspaces/turtlebot_ws/src/moveturtle/moveturtle$ touch line.py user:~/Workspaces/turtlebot_ws/src/moveturtle/moveturtle$ touch circle.py user:~/Workspaces/turtlebot_ws/src/moveturtle/moveturtle$ touch square.py user:~/Workspaces/turtlebot_ws/src/moveturtle/moveturtle$ chmod +x line.py circle.py 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()

–Huling Bahagi ng Syntax Para sa circle.py–

 

–Syntax Para sa square.py–

In [ ]: import rclpy from rclpy.node import Node from geometry_msgs.msg import Twist class SquareNode(Node): def __init__(self): super().__init__('square') self.cmd_vel_publisher_=self.create_publisher(Twist, 'turtle1/cmd_vel', 10) self.timer = self.create_timer(2.0, self.timer_callback) self.timer_count=0 def timer_callback(self): msg = Twist() if self.timer_count % 4 == 0: msg.linear.x = 1.0 msg.angular.z = 0.0 elif self.timer_count % 4 == 1: msg.linear.x = 0.0 msg.angular.z = -0.1 elif self.timer_count % 4 == 2: msg.linear.x = 1.0 msg.angular.z = 0.0 else: msg.linear.x = 0.0 msg.angular.z = -1.0 self.cmd_vel_publisher_.publish(msg) self.get_logger().info(f"Publishing: {msg.linear.x}, {msg.angular.z}") self.timer_count+=1 def main(args=None): rclpy.init(args=args) node = MoveSquare() rclpy.spin(node) node.destroy_node() rclpy.shutdown() if __name__=='__main__': main()

–Huling Bahagi ng Syntax Para sa square.py–

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!


Video Tutorial

ROS su più macchine – Italian ROS Tutorial

ROS su più macchine – Italian ROS Tutorial

In questo tutorial vedremo come sia possibile configurare ROS per funzionare su più macchine connesse attraverso la rete, espandendo le possibilità per i tuoi progetti.

La configurazione iniziale parte da un nodo publisher minimale chatter.py appartenente al pacchetto chatter, con un singolo publisher di stringhe.

 

Pin It on Pinterest