ROS custom messages

As mensagens personalizadas no ROS (ROS custom messages) são constituidas a partir das  mensagens préviamente disponiveis.

Para criar novas mensagens personalizadas (custom messages) deveremos proceder do seguinte modo:

Primeiro deveremos definir o novo tipo de mensagem num ficheiro que tem de ser criado dentro da pasta msg do respectivo pacote.

Preferencialmente deve existir um pacote exclusivo para as mensagens pois assim elas são mais facilmente reutilizaveis.

# MyCustomMsg.msg

Header header
float64 data

Para criar as mensagens, quer seja num pacote dedicado quer sejam incluidas num outro pacote em que convivem com outras funcionalidades, as instruções de compilação tem de obedecer a alguns requisitos:

O ficheiro package.xml deve conter:

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

No ficheiro CMakeLists.txt, tem de incluir vários blocos de texto:

Incluir o pacote message_generation na entrada find_package, no ficheiro CMakeLists.txt, como no exemplo abaixo:

find_package(catkin REQUIRED COMPONENTS
   roscpp
   rospy
   std_msgs
   message_generation
)

Exportar a dependência em tempo de execução incluindo a seguinte entrada no ficheiro CMakeLists.txt:

catkin_package(
  ...
  CATKIN_DEPENDS message_runtime ...
  ...
)

Declarar o ficheiro com a mensagem personalizada com a seguinte entrada no ficheiro  CMakeLists.txt.

add_message_files(
  FILES
  MyCustomMsg.msg
)

Se existirem mais mensagens será é uma por linha. Adequar o nome do ficheiro(s) indicado nesta entrada.

Fica assim completa a parte dos requisitos para a nossa mensagem personalizada ser compilada e disponivel para ser usada.

Caso esta mensagem esteja num pacote diferente daquele onde vai ser usadas, por exemplo um pacote dedicado a mensagens, para usar esta mensagem é necessário incluir as seguintes entradas nos ficheiros package.xlm e CMakeLists.txt.

No ficheiro package.xlm incluir o nome do pacote (substituir pelo nome correcto do pacote), conforme o exemplo abaixo:

<depend package="message_package" />

No ficheiro CMakeLists.txt, incluir message_package (substituir pelo nome correcto do pacote) na entrada adequada (ver exemplo abaixo).

find_package(catkin REQUIRED COMPONENTS
   roscpp
   rospy
   std_msgs
   message_package
)

No que respeita ao inclusão e utilização da mensagem personalizada no código C++, é necessário proceder da seguinte forma:

Importar para o código C++ code.

#include <message_package/MyCustomMsg.h>

Declarar o topic  publisher:

my_msg_pub_ = n.advertise<message_package::MyCustomMsg>("topic", 10);

Criar uma instancia da mensagem numa variavel:

message_package::MyCustomMsg msg;

Atribuir o(s) valor(es) e publicar a mensagem.

msg.header.stamp = ros::Time::now();
msg.header.frame_id = "/world";
msg.data = 0.0;

my_msg_pub_.publish(msg);

Que me lembre é tudo.

Fontes:

  • http://wiki.ros.org/ROS/Tutorials/CreatingMsgAndSrv
  • http://wiki.ros.org/ROS/Tutorials/DefiningCustomMessages

 

arm3dof_jpc_nolim_nofb

O pacote do ROS arm3dof_jpc_nolim_nofb é um pacote didático para controlar um braço robótico baseado em servos sem feedback (com quatro articulações) que funciona com o ros control com um modelo simples e funcional de software do hardware interface necessário para o ros controller joint position controller.

Esta é uma das implementações mais simples que conheço de um hardware interface para o ros control.

Neste pacote existem as seguintes limitações:

  • O feed back do hardware não é real. O método limita-se a entregar o valor que da posição desejada que é enviada para o hardware (micro controlador);
  • Não existe a imposição de limites às articulações;

O pacote está funcional e disponivel no seguinte link:

https://github.com/inaciose/ros_hardware_interfaces/tree/master/arm3dof_jpc_nolim_nofb

Existe uma versão deste hardware_interface com implementação de limites.

arm3dof_jpc_nofb

O pacote do ROS arm3dof_jpc_nofb é um pacote didático para controlar um braço robótico baseado em servos sem feedback (com quatro articulações) que funciona com o ros control com um modelo simples e funcional de software do hardware interface necessário para o ros controller joint position controller.

Esta versão implementa a imposição de limites definida num ficheiro yaml.

Neste pacote existem as seguintes limitações:

  • O feed back do hardware não é real. O método limita-se a entregar o valor que da posição desejada que é enviada para o hardware (micro controlador);

O pacote está funcional e disponivel no seguinte link:

https://github.com/inaciose/ros_hardware_interfaces/tree/master/arm3dof_jpc_nofb

Existe uma implementação de um hardware interface para o ros control sem a imposição de limites e por isso mais simples.

 

Install openrave ubuntu 18.04 bionic

Required instalation to use IK-Fast on ROS moveit

Install OpenRAVE  from source on Ubuntu 18.04 bionic No official PPA.

sudo apt install git
sudo apt install libboost-filesystem-dev libboost-system-dev libboost-python-dev libboost-thread-dev libboost-iostreams-dev libboost-numpy-dev
sudo apt install libqt4-dev qt4-dev-tools libxml2-dev libode-dev
sudo apt install libsoqt4-dev libcoin80-dev
sudo apt install rapidjson-dev liblapack-dev

# For openravepy. Note that Xenial sympy is 0.7.6, see next line
sudo apt install python-scipy

# OpenRAVE ikfast needs sympy 0.7.1, https://github.com/rdiankov/openrave/p ull/407
pip install --upgrade --user sympy==0.7.1

# Open .zae files, only Ubuntu 16.04
sudo apt install libcollada-dom2.4-dp-dev

cd # go home

mkdir -p repos; cd repos # create $HOME/repos if it doesn't exist; then, enter it 
git clone --branch boost-1.6x-forcompile https://github.com/roboticslab-uc3m/openrave.git # git clone --branch master https://github.com/rdiankov/openrave.git 
cd openrave; mkdir build; cd build 
cmake .. -DOPT_VIDEORECORDING=OFF # Avoids AV errors 
make -j$(nproc) 

sudo make install; cd # install and go home

Note that you may end up requiring over 2 GB of free space during the installation of apt dependencies. To avoid that, use the –noinstall-recommends option as in:

sudo apt install –no-install-recommends package

Thus, apt would not try to install non-critical packages marked as recommended by the dependencies of OpenRAVE.

Known Issues (Ubuntu 18.04) In case you run into non-constant-expression cannot be narrowed from type ‘double’ to ‘float’ in initializer list [- Wc++11-narrowing] errors (happened on OpenRAVE 0.15 and a Clang 6.0.0/7.0.0 compiler), reconfigure CMake with the following option: cmake .. -DOPT_IKFAST_FLOAT32=OFF Install Openrave 4

 

Source of instructions

http://robots.uc3m.es/gitbook-installation-guides/installation-guides.pdf

ros_controllers

ROS controllers, ros_controllers

Os controladores no ROS, (ros_controllers) são lançados e geridos com o gestor de controladors (controller_manager) e para poderem ser executados têm de cumprir com alguns requisitos, entre os quais o principal é herdarem a classe controller_interface::Controller. Para saber mais sobre o assunto, especialmente se for necessário desenvolver um controller  ver: controller_interface.

Apesar de podermos fazer controladores personalizados, já existem vários tipos de controladores disponíveis para o ROS e que no seu conjunto compõem o meta-pacote conhecido por ros_controllers:

  • ackermann_steering_controller
  • diff_drive_controller
  • effort_controllers
  • force_torque_sensor_controller
  • forward_command_controller
  • gripper_action_controller
  • imu_sensor_controller
  • joint_state_controller
  • joint_trajectory_controller
  • position_controllers
  • velocity_controllers

Estes pacotes devem ser usados conforme o hardware que é explorado no robot.

 

ros_control

ROS control, ros_control

O ROS control é a area do ROS que se dedica à normalização e gestão da aplicação de técnicas de controlo sobre o hardware (actuadores e sensores) dos robots.  O ros_control está intimamente ao ros_controllers.

ros_control packages

Os pacotes que compõem o ros_control são os seguintes:

Dos pacotes acima destaco os seguintes pacotes por terem uma utilização generalizada no uso do ros_control.

  • controller_manager
  • hardware_interface
  • joint_limits_interface

A importância destes pacotes pode ser verificada pela observação dos includes existentes no ficheiro de cabeçalho minimalista usado num pacote de hardware interface especifico para um robot simples (ver mais em hardware_interface).

 

ROS control joint_limits_interface

ROS control joint_limits_interface

A classe joint_limits_interface contém as estruturas de dados para representar os limites das articulações, métodos para carregar os limites a aplicar a partir de formatos comuns, como ficheiros URDF e o servidor de parâmetros ROS, e métodos para impor os limites a diferentes tipos de interfaces de hardware.

O joint_limits_interface é usado na implementação do hardware_interface no método write() (ou equivalente) já após a actualização dos controladores. A imposição de limites substituirá os comandos definidos pelos controladores e  não é efectuada no mesmo buffer de dados.

Na configuração de uma interface de limites de articulação (joint limits interface), devem-se tomar em consideração os seguintes elementos:

Representação dos limites

JointLimits – Posição, velocidade, aceleração, empurrão (jerk) e esforço.

SoftJointLimits – Limites de posição de software, k_p, k_v

Mais informações sobre os joint limits e os soft joint limits mais abaixo.

Fontes para obtenção dos limites:

  • Ficheiros URDF – Existem métodos para carregar do URDF as informações dos limites ao movimento das articulações, joint limits, (posição, velocidade e esforço), assim como sobre os soft limites das articulações, soft joint limits.
  • Servidor de parâmetros do ROS – Existem métodos de para carregar a partir do servidor de parâmetros do ROS os limites ao movimento das articulações, joint limits, (posição, velocidade, aceleração, empurrão e esforço). A especificação dos parâmetros é a mesma usada no MoveIt, e inclui também os limites de empurrão e esforço.

A implementação concreta dos limites varia consoante o tipo de articulação.

  • Para articulação controladas por esforço, a implementação de limites flexíveis do PR2 foi portada.
  • Para articulação com posição controlada, uma versão modificada dos limites flexíveis PR2 foi implementada.
  • Para articulação com velocidade controlada, foi implementado um método de  saturação simples com base nos limites de aceleração e velocidade.

No seguinte link está o exemplo oficial da utilização de joint limits na implementação de uma hardware_interface de um robot.

https://github.com/ros-controls/ros_control/wiki/joint_limits_interface

Mais informação sobre a classe joint_limits_interface em:

http://docs.ros.org/melodic/api/joint_limits_interface/html/c++/index.html

Joint Limits vs Soft Joint Limits

Os limites da articulações, podem ser de dois tipos, os hard, que são simplesmente referidos de Joint Limits e os soft referidos como Soft Joint Limits.

A diferença fundamental entre os dois tipos de limites é que os soft limits consideram um limite de segurança (safety limit) que é tomado em consideração na implementação dos limites no software.

Os dois tipos de limites podem ser especificado no ficheiro urdf, conforme o exemplo abaixo. O elemento <limit> contêm os atributos correspondentes aos hard joint limits. Enquanto que o elemento <safety_controller>  contêm os atributos correspondentes aos soft joint limits.

<joint name="joint1" type="revolute">
<origin rpy="0 0 0" xyz="0 0 0.05"/>
<axis xyz="1 0 0"/>
<parent link="base"/>
<child link="link1"/>
<dynamics damping="0.1" friction="0"/>
<limit effort="300" lower="-0.523599" upper="0.523599" velocity="12"/>
<safety_controller k_position="100" k_velocity="100" soft_lower_limit="-10.5236" soft_upper_limit="10.5236"/>
</joint>

Para saber mais sobre ficheiros URDF no ROS, consultar o artigo sobre Ficheiros URDF.

Para saber mais sobre os safety limits consultar a informação disponível no seguinte endereço: https://wiki.ros.org/pr2_controller_manager/safety_limits

Instruções simples para usar o joint limits no hardware_interface do robot.

No ficheiro do header incluir:

 

Mais informação

 

https://github.com/ros-controls/ros_control/wiki/joint_limits_interface