Após iniciar o turtlesim através de

$ rosrun turtlesim turtlesim_node

é possível ver os tópicos e mensagens disponíveis pro desenvolvimento da aplicação usando

$ rostopic list

nota-se que há 3 novos topics disponíveis e /turtle1/cmd_vel é o responsável pelo movimento do robô.

Para obter informações sobre esse tópico faça

$ rostopic info /turtle1/cmd_vel

Nota-se que o tipo de mensagem usado nesse tópico é geometry_msgs/Twist e será usado como import na aplicação.

Para obter os parâmetros da mensagem faça

$ rosmsg show geometry_msgs/Twist

e perceba que a mensagem é composta por componentes x, y e z linear e angular. Os movimentos dessa aplicação serão apenas planos, nesse caso, o componente z linear será 0(zero), assim como os componentes x e y angular.

O tópico pose é o responsável por informações sobre a localização atual do robô no plano e também será usado.

Da mesma forma é possível obter os parâmetros da sua mensagem que referem-se ao posicionamento x e y no plano e também a orientação theta. As velocidades angular e linear serão as componentes linear.x e angular.z da mensagem Twist.

O primeiro passo da aplicação aqui desenvolvida é fazer um movimento em linha reta. No git clonado o código encontra-se com nome de turtlesim_cleaner.py e é desenvolvido em python.

Utilizando a ferramenta turtlesim, vamos assumir que o movimento ocorre de um ponto inicial (x0,y0) até um ponto final (x,y)

########################################################
#!/usr/bin/env python

import rospy
from geometry_msgs.msg import Twist
from turtlesim.msg import Pose
import math
import time
from std_srvs.srv import Empty

def move(velocity_publisher, speed, distance, is_forward):
#declare a Twist message to send velocity commands
velocity_message = Twist()

global x, y
x0 = x
y0 = y

if (is_forward):
velocity_message.linear.x =abs(speed)
else:
velocity_message.linear.x =-abs(speed)

distance_moved = 0.0
loop_rate = rospy.Rate(10) # we publish the velocity at 10 Hz (10 times a second)

while True :
rospy.loginfo(“Turtlesim moves forwards”)
velocity_publisher.publish(velocity_message)

loop_rate.sleep()
t1 = rospy.Time.now().to_sec()
#rospy.Duration(1.0)

distance_moved = abs(0.5 * math.sqrt(((x-x0) ** 2) + ((y-y0) ** 2)))
print distance_moved
if not (distance_moved<distance):
rospy.loginfo(“reached”)
break

#finally, stop the robot when the distance is moved
velocity_message.linear.x =0
velocity_publisher.publish(velocity_message)

def poseCallback(pose_message):
global x
global y, yaw
x= pose_message.x
y= pose_message.y
yaw = pose_message.theta

if __name__ == ‘__main__’:
try:

rospy.init_node(‘turtlesim_motion_pose’, anonymous=True)

#declare velocity publisher
cmd_vel_topic=’/turtle1/cmd_vel’
velocity_publisher = rospy.Publisher(cmd_vel_topic, Twist, queue_size=10)

position_topic = “/turtle1/pose”
pose_subscriber = rospy.Subscriber(position_topic, Pose, poseCallback)
time.sleep(2)

move(velocity_publisher, 1.0, 4.0, True)

except rospy.ROSInterruptException:
rospy.loginfo(“node terminated.”)

##############################################################################

A função move() tem como parâmetros velocity_publisher que será usada para publicar cada nova mensagem twist, a velocidade, a distância do movimento e a direção.

O laço if(is_forward) define o sentido do movimento no eixo horizontal, se negativo o movimento é realizado no sentido contrário.

velocity_message = Twist() define a variável com todos os parâmetros da mensagem.

No loop while True a todo momento é publicado a velocity_message que são as coordenadas x e y para o movimento, distance_moved é o quanto o robô se moveu e quando este valor ultrapassa o valor distance dado como parâmetro o movimento é interrompido. Em seguida a posição 0 é passada para que o robô pare.

A função poseCallback será usada como subscriber sendo chamada a cada nova mensagem recebida armazenando nas variáveis o estado atual do robô.

Nas linhas finais está a chamada da função move com os parâmetros desejados, nesse caso o robô se moverá com velocidade 1 m/s por uma distância de 4 metros no sentido positivo.

Com a aplicação turtlesim aberta execute em outro terminal o comando do seu código, nesse caso

$ rosrun ros_essentials_cpp turtlesim_cleaner.py

Será possível observar na janela do turtlesim o movimento.

Vamos agora definir a função de rotação da tartaruga, essa função está contida no mesmo código anterior basta acrescentá-la nos locais adequados.

#######################################################################

def rotate (velocity_pusblisher, angular_speed_degree, relative_angle_degree, clockwise):

velocity_message = Twist()

angular_speed=math.radians(abs(angular_speed_degree))

if (clockwise):
velocity_message.angular.z =-abs(angular_speed)
else:
velocity_message.angular.z =abs(angular_speed)

loop_rate = rospy.Rate(10) # we publish the velocity at 10 Hz (10 times a second)
t0 = rospy.Time.now().to_sec()

while True :
rospy.loginfo(“Turtlesim rotates”)
velocity_publisher.publish(velocity_message)

t1 = rospy.Time.now().to_sec()
current_angle_degree = (t1-t0)*angular_speed_degree
loop_rate.sleep()

if (current_angle_degree>relative_angle_degree):
rospy.loginfo(“reached”)
break

#finally, stop the robot when the distance is moved
velocity_message.angular.z =0
velocity_publisher.publish(velocity_message)

##########################################################################

Do mesmo modo que a função move(), a função rotate() recebe parâmetros de velocidade, posição e sentido.

Os ângulos são recebidos em graus então usamos uma conversão para radianos e o salvamos numa variável para melhor manipulação.

Aqui o ângulo de rotação é calculado a partir do tempo, diferente de move() que usava a distância absoluta.

Por fim a função rotate() pode ser aplicada no final do código juntamente com a função move, basta adicionar por exemplo a linha rotate(velocity_publisher, 30, 90, True) após move, com isso após realizar o movimento linear definido ele irá girar no sentido horário a 30 graus/segundo durante 90 graus.

Você pode agora adicionar quantos comandos move() e rotate() forem necessários para o movimento desejado, existem outras funções de movimentos tal como go_to_goal() e spiralClean() contidas no código original que podem ser estudadas mas aqui não serão abordadas.

Um bom exemplo de ROS Service é dado através da interface turtlesim, para instalá-la use o comando adequado para sua versão ROS, nesse caso noetic.

$ sudo apt-get install ros-noetic-turtlesim

$ sudo rosdep init

$ rosdep update

Para iniciá-lo comece pela inicialização do ROS e em um novo terminal abra a interface

$ roscore

$ rosrun turtlesim turtlesim_node

Uma interface como essa deve aparecer

Em um terminal, é possível ver todos os services atualmente ativos com

$ rosservice list

Será visto nessa lista um service de nome /spawn cujo detalhes pode ser expandido com $ rosservice info /spawn

O seu tipo de mensagem é turtlesim/Spawn e seus argumentos x, y, theta e name são a localização e direção para o aparecimento de uma nova tartaruga na tela e o nome dado a ela.

Com $ rossrv info turtlesim/spawn é possível ver informações detalhadas sobre o tipo de mensagem do serviço

Podemos chamar esse serviço com o comando

$ rosservice call /spawn 7 7 0 t2

Nesse caso uma nova tartaruga deve aparecer na posição (x,y) = (7,7) rotacionada de 0 graus com nome t2 cuja informação é retornada no terminal como resposta.

Também é possível criar seu próprio serviço, aqui criaremos uma aplicação Client/Server onde o cliente envia 2 inteiros ao servidor que retorna a soma.

Em seu workspace, no diretório do pacote onde realiza suas aplicações, no nosso caso ros_essentials_cpp, deverá ser criado uma pasta de nome srv, nessa pasta criaremos um arquivo de nome AddTwoInts.srv que deverá ser preenchido com as seguintes linhas:
_____________________

int64
int b
—
int64 sum

_____________________

Os passos seguintes são reproduzidos igualmente em ROS messages e podem ser pulados com exceção do add_service_files caso já os tenha realizado.

Para que o serviço possa ser usado através de mensagens é necessário atualizar as dependências em CMakeLists.txt adicionando a linha message_generation no campo seguinte:

########################################

find_package(catkin REQUIRED COMPONENTS
roscpp
rospy
std_msgs
message_generation
)

#######################################

Ainda em CMakeLists.txt adicionar o nome do arquivo criado no campo seguinte:

####################
add_service_files(
FILES
AddTwoInts.srv
)

####################

Agora em package.xml adicionar nos locais adequados (de acordo com a sintaxe) as linhas :

<build_depend>message_generation</build_depend>

e

<exec_depend>message_runtime</exec_depend>

Para finalizar é necessário no diretório do workspace realizar um catkin_make. E agora novos arquivos podem ser observados no diretório /catkin_ws/devel/include/ros_essentials_cpp

Agora, o código seguinte refere-se ao Server add_server.py criado em python que retorna a resposta

#################################################################
1      #!/usr/bin/env python
2
3      from ros_essentials_cpp.srv import AddTwoInts
4      from ros_essentials_cpp.srv import AddTwoIntsRequest
5      from ros_essentials_cpp.srv import AddTwoIntsResponse
6
7      import rospy
8
9      def handle_add_two_ints(req):
10       print “Returning [%s + %s = %s]”%(req.a, req.b, (req.a + req.b))
11       return AddTwoIntsResponse(req.a + req.b)
12
13    def add_two_ints_server():
14       rospy.init_node(‘add_two_ints_server’)
15       s = rospy.Service(‘add_two_ints’, AddTwoInts, handle_add_two_ints)
16       print (“Ready to add two ints.”)
17       rospy.spin()
18
19    if __name__ == “__main__”:
20       add_two_ints_server()

###########################################################

O primeiro passo é importar os arquivos de service, request e response criados. O serviço é criado na linha 15 e tem como parâmetros o nome do serviço criado, o tipo de serviço e a função que será executada sempre que houver uma nova solicitação. Essa função (linha 9) é a responsável por retornar a soma dos inteiros passados.

A seguir o código do Client add_client.py que faz a solicitação

########################################################
1      #!/usr/bin/env python
2
3      import sys
4      import rospy
5      from ros_essentials_cpp.srv import AddTwoInts
6      from ros_essentials_cpp.srv import AddTwoIntsRequest
7      from ros_essentials_cpp.srv import AddTwoIntsResponse
8
9      def add_two_ints_client(x, y):
10       rospy.wait_for_service(‘add_two_ints’)
11       try:
12          add_two_ints = rospy.ServiceProxy(‘add_two_ints’, AddTwoInts)
13          resp1 = add_two_ints(x, y)
14          return resp1.sum
15       except rospy.ServiceException, e:
16          print “Service call failed: %s”%e
17
18    def usage():
19       return “%s [x y]”%sys.argv[0]
20
21    if __name__ == “__main__”:
22       if len(sys.argv) == 3:
23          x = int(sys.argv[1])
24          y = int(sys.argv[2])
25       else:
26          print usage()
27          sys.exit(1)
28       print “Requesting %s+%s”%(x, y)
29       s = add_two_ints_client(x, y)
30       print “%s + %s = %s”%(x, y, s)

#########################################################

Para iniciar é necessário esperar o serviço para começar (linha 10) caso contrário não será possível rodar a aplicação. Na linha 12 é criado o service proxy que é responsável por enviar informação ao server e tem como parâmetros o nome do serviço definido anteriormente e o tipo.

Agora em 2 novos terminais é possível conferir a aplicação, no primeiro fazer

$ rosrun ros_essentials_cpp add_server.py

e no segundo

$ rosrun ros_essentials_cpp add_client.py 1 2

Nota-se que os inteiros que serão somados foram passados no comando do cliente e a resposta retornada deverá ser 1 + 2 = 3

Dessa forma está feito um novo ROS Service.

ROS permite que você crie sua própria mensagem no seu próprio tipo e a transmita entre nós.

Todo nome de mensagem é composto por duas partes package_name/message_type.
Em nossa aplicação Talker Listener utilizamos std_msg/String.

Aqui criaremos a mensagem de sensores como exemplo, todo sensor terá um id, um nome, a temperatura e a umidade.

Em seu workspace, no diretório do pacote onde realiza suas aplicações, no nosso caso ros_essentials_cpp, deverá ser criado uma pasta de nome msg, nessa pasta criaremos um arquivo de nome Sensor.msg que deverá ser preenchido com as seguintes linhas:

_____________________

int32 id
string name
float32 temperature
float32 humidity

_____________________

Para que a mensagem possa ser usada é necessário atualizar as dependências em CMakeLists.txt adicionando a linha message_generation no campo seguinte:

########################################

find_package(catkin REQUIRED COMPONENTS
roscpp
rospy
std_msgs
message_generation
)

#######################################

Ainda em CMakeLists.txt adicionar o nome do arquivo criado no campo seguinte:

####################
add_message_files(
FILES
Sensor.msg
)

####################

Agora em package.xml adicionar nos locais adequados (de acordo com a sintaxe) as linhas :

<build_depend>message_generation</build_depend>

e

<exec_depend>message_runtime</exec_depend>

Para finalizar é necessário no diretório do workspace realizar um catkin_make.

E agora temos um novo tipo de mensagem que pode ser usado na comunicação entre nós através de topics.

Este tutorial foi retirado do curso ROS for Beginners: Basics, Motion, and OpenCV disponível no site da Udemy e é ministrado por Anis Koubaa.

Para reproduzir este artigo é necessário implementar os códigos seguintes disponíveis em seu git.
Para isto basta clonar seu repositório no workspace de sua máquina:

$ cd catkin_ws

$ git clone https://github.com/aniskoubaa/ros_essentials_cpp.git

Exemplo Hello World (Talker Listener)

O Topic aqui é chamado de chatter e possui uma mensagem do tipo String

Código talker.py
##########################################
1     #!/usr/bin/env python
2     # license removed for brevity
3     import rospy
4     from std_msgs.msg import String
5
6     def talker():
7        pub = rospy.Publisher(‘chatter’, String, queue_size=10)
8        rospy.init_node(‘talker’, anonymous=True)
9        rate = rospy.Rate(1) # 1hz
10      i=0
11      while not rospy.is_shutdown():
12         hello_str = “hello world %s” % i
13         rospy.loginfo(hello_str)
14         pub.publish(hello_str)
15         rate.sleep()
16         i=i+1
17
18    if __name__ == ‘__main__’:
19       try:
20          talker()
21       except rospy.ROSInterruptException:
22          pass
##############################################

A linha 7 é responsável pela criação do Publisher e os parâmetros fornecidos é o nome do tópico, o tipo de mensagem e quantas mensagens será armazenada na fila simultaneamente até serem descartadas.
A linha 8 inicia o nó e os parâmetros são o nome do nó enquanto anonymous=TRUE garante que cada nó criado seja único através de um ID
A linha 10 especifica a frequencia com que é publicado, ou seja, quantas mensagens por segundo
O loop da linha 11 funciona enquanto estiver ligado, neste caso cria a mensagem na linha 12 e o publica na linha 14.

Após clonar o repósitório do Anis Koubaa é necessário iniciar o ROS com o comando

$ roscore

Em dois novos terminais abrir o workspace e fazer

$ rosrun ros_essentials_cpp talker.py
e
$ rosrun ros_essentials_cpp listener.py

Código listener.py
##################################################

1     #!/usr/bin/env python
2     import rospy
3     from std_msgs.msg import String
4
5     def callback(message):
6        print(” I heard “, message.data)
7
8     def listener():
9        rospy.init_node(‘listener’, anonymous=True)
10
11      rospy.Subscriber(“chatter”, String, callback)
12
13      rospy.spin()
14
15   if __name__ == ‘__main__’:
16      listener()
######################################################

A linha 9 inicia o nó da mesma forma que o Publisher
A linha 11 cria o Subscriber onde deve ser fornecido o mesmo nome dado ao Publisher, o mesmo tipo de mensagem e o último parâmetro é a função callback que é chamada toda vez que uma nova mensagem é recebida.

Ao executar os dois códigos em sua máquina você é capaz de ver que a comunicação acontece de forma que o que é enviado em Talker é recebido pelo Listener

Neste post está descrito como proceder com a instalação de todos os recursos necessários para a manipulação do braço através de um simulador.

Os arquivos necessários para confecção do braço encontram-se neste link.

No terminal, faça:

$ sudo apt update

$ sudo apt-get install ros-noetic-moveit*

Em seguida deve-se clonar o repositório do projeto

$ cd /catkin_ws/src/

$ git clone https://github.com/jesseweisberg/moveo_ros.git

$ cd /catkin_ws/

$ catkin_make

No código ‘moveit_convert.cpp’ contido em ‘moveo_moveit/src/’ substitua o vetor stepsPerRevolution pelos valores de passos/revolução de cada um dos motores utilizados na construção. Estes valores podem ser obtidos através de observação utilizando o código ‘MultiStepperTest.ino’ contido na IDE do Arduino.

Nota: Para cada nova alteração no vetor acima mencionado um novo catkin_make deve ser realizado com os dois últimos comandos acima mencionados.

No Arduino,  transferir o código ‘moveo_moveit_arduino.ino’ contido em ‘/moveo_moveit/moveo_moveit_arduino/’ para a placa.

Abrir no terminal a pasta de bibliotecas do arduino e instalar as bibliotecas necessárias:

$ rosrun rosserial_arduino make_libraries.py . (não ignorar o ponto no final)

Agora resta abrir a simulação e estabelecer a comunicação entre a máquina e o robô.

Abra com:

$ roslaunch moveo_moveit_config demo.launch

Estabeleça a comunicação em novos terminais:

$ rosrun rosserial_python serial_node.py

$ rosrun moveo_moveit moveit_convert

Pronto, com isto os movimentos realizados no simulador devem ser transferidos para os motores.

Se preferir os movimentos podem ser realizados através do terminal com o comando

$ rostopic pub joint_steps moveo_moveit/ArmJointState <Joint1 Joint2 Joint3 Joint4 Joint5 0>

Se você acabou de instalar o ROS do apt no Ubuntu, terá os arquivos setup.*sh em ‘/opt/ros/noetic/’, e poderá obtê-los da seguinte forma:

$ source /opt/ros/noetic/setup.bash

obs: Se a sua versão ROS instalada não for noetic basta substituir no comando acima

Você precisará executar este comando em cada novo shell que abrir para ter acesso aos comandos ROS, a menos que adicione a linha acima ao seu .bashrc.

• Workspace

O workspace é o diretório no qual trabalharemos o ROS. Este diretório simplifica o processo de construção e instalação dos pacotes necessários.

No terminal faça:

$ mkdir -p ~/catkin_ws/src

$ cd ~/catkin_ws/

$ catkin_make

O comando catkin_make é uma ferramenta conveniente para trabalhar com espaços de trabalho catkin . Executando-o pela primeira vez em seu espaço de trabalho, ele criará um link CMakeLists.txt em sua pasta ‘src’. Além disso, se você olhar em seu diretório atual, deverá agora ter uma pasta ‘build’ e ‘devel’. Dentro da pasta ‘devel’, você pode ver que agora existem vários arquivos setup.*sh. Antes de continuar aponte seu novo arquivo setup.*sh com:

$ source devel/setup.bash

Para que não seja necessário o comando acima toda vez que você reiniciar a máquina, adicione-o ao final do arquivo bashrc, basta fazer

$ cd

$ gedit .bashrc

E no fim do documento acrescente a linha “source ~/catkin_ws/devel/setup.bash” sem as aspas.

Para certificar-se de que sua área de trabalho seja devidamente sobreposta pelo script de configuração, certifique-se de que a variável de ambiente ROS_PACKAGE_PATH inclua o diretório em que você está:

$ echo $ROS_PACKAGE_PATH /home/<youruser>/catkin_ws/src:/opt/ros/noetic/share

Pronto, agora seu workspace está configurado.

Este post contém instruções práticas de instalação da versão Noetic de acordo com o site oficial http://wiki.ros.org/

• Configure seus repositórios do Ubuntu para permitir “restrito”, “universo” e “multiverso”. Estas opções encontram na janela de Software & Updates.

•  Configure seu computador para aceitar o software de packages.ros.org através do seguinte comando no terminal

$ sudo sh -c ‘echo “deb http://packages.ros.org/ros/ubuntu $(lsb_release -sc) main” > /etc/apt/sources.list.d/ros-latest.list’

• Configure a chave

$ sudo apt-key adv –keyserver ‘hkp://keyserver.ubuntu.com:80’ –recv-key C1CF6E31E6BADE8868B172B4F42ED6FBAB17C654

• Instalação

$ sudo apt update

$ sudo apt install ros-noetic-desktop-full

Você pode sempre instalar pacotes adicionais através de $ sudo apt install ros-noetic-PACKAGE

Para ver pacotes disponíveis use $ apt search ros-noetic

• Configuração do ambiente

Você deve fornecer este script em cada terminal bash em que usar o ROS.

$ source /opt/ros/noetic/setup.bash

Pode ser conveniente criar este script automaticamente toda vez que um novo shell for iniciado. Estes comandos farão isso por você.

$ echo “source /opt/ros/noetic/setup.bash” >> ~/.bashrc
$ source ~/.bashrc

• Dependências para construção de pacotes

Para criar e gerenciar seus próprios espaços de trabalho ROS existem várias ferramentas e requisitos que são distribuídos separadamente. Para instalar essas ferramentas e outras dependências para construir pacotes ROS, execute:

$ sudo apt install python3-rosdep python3-rosinstall python3-rosinstall-generator python3-wstool build-essential

Antes de usar muitas ferramentas ROS, você precisará inicializar o rosdep. O rosdep permite que você instale facilmente as dependências do sistema para o código-fonte que deseja compilar e é necessário para executar alguns componentes principais no ROS. Faça o seguinte

$ sudo rosdep init
$ rosdep update

Pronto, sua instalação está completa e agora você pode seguir para outros tutoriais.