Après avoir suivi ce premier tuto vous voudriez bien faire bouger votre robot ! Voici comment faire :

Voyons maintenant comment simuler cette base roulante !

SIMULATION DE LA BASE ROULANTE :

Maintenant que nous avons défini une base propre qui est comprise par ROS nous devons y ajouter certains tags de ce modèle dans Gazebo.

Définissons les collisions :

Le tag <collision> est nécessaire au même titre que <visual> dans le tag <link> comme suit :

<collision>
      <origin
        xyz="0 0 0"
        rpy="1.5707963267949 0 3.14" />
      <geometry>
        <mesh filename="package://robot_description/meshes/robot_base.stl" />
      </geometry>
</collision>

Pour le lien avec les roues il nous faut aussi ajouter ces quelques lignes à robot_essential.xacro :

    <collision>
      <origin
        xyz="0 0 0"
        rpy="1.5707963267949 0 0" />
      <geometry>
        <mesh filename="package://robot_description/meshes/wheel.stl" />
      </geometry>
    </collision>

Nous devons maintenant ajouter le tag <inertial> pour ajouter la masse et l’inertie de notre robot. Dans le fichier base on ajoute sous le tag <link> :

<inertial>
      <origin
        xyz="0.0030946 4.78250032638821E-11 0.053305"
        rpy="0 0 0" />
      <mass
        value="47.873" />
      <inertia
        ixx="0.774276574699151"
        ixy="-1.03781944357671E-10"
        ixz="0.00763014265820928"
        iyy="1.64933255189991"
        iyz="1.09578155845563E-12"
        izz="2.1239326987473" />
</inertial>

Pour le fichier xacro :

<inertial>
      <origin
        xyz="-4.1867E-18 0.0068085 -1.65658661799998E-18"
        rpy="0 0 0" />
      <mass
        value="2.6578" />
      <inertia
        ixx="0.00856502765719703"
        ixy="1.5074118157338E-19"
        ixz="-4.78150098725052E-19"
        iyy="0.013670640432096"
        iyz="-2.68136447099727E-19"
        izz="0.00856502765719703" />
</inertial>

Créons maintenant les actionneurs :

Dans le fichier robot_base_essential.xacro :

<xacro:macro name="base_transmission" params="prefix ">

<transmission name="${prefix}_wheel_trans" type="SimpleTransmission">
  <type>transmission_interface/SimpleTransmission</type>
  <actuator name="${prefix}_wheel_motor">
  	<hardwareInterface>hardware_interface/VelocityJointInterface</hardwareInterface>
  	<mechanicalReduction>1</mechanicalReduction>
  </actuator>
  <joint name="${prefix}_wheel_joint">
   	<hardwareInterface>hardware_interface/VelocityJointInterface</hardwareInterface>
  </joint>
</transmission>

</xacro:macro>

Et donc l’insérer dans le robot_robot.urdf.xacro :

<xacro:base_transmission prefix="front_left"/>
<xacro:base_transmission prefix="front_right"/>
<xacro:base_transmission prefix="rear_left"/>
<xacro:base_transmission prefix="rear_right"/>

Appelons maintenant ros_controllers pour rendre notre robot dynamique !

Pour faire ça nous devons créer un nouveau fichier qui s’appelle gazebo_essentials_base.xacro qui va contenir le tag <Gazebo> ainsi que le plugin gazebo_ros_control :

<?xml version="1.0"?>

<robot xmlns:xacro="http://ros.org/wiki/xacro" name="gazebo_essentials" >

<gazebo>
    <plugin name="gazebo_ros_control" filename="libgazebo_ros_control.so">
      <robotNamespace>/</robotNamespace>
      <controlPeriod>0.001</controlPeriod>
      <legacyModeNS>false</legacyModeNS>
    </plugin>
 </gazebo>

Le plugin du différentiel des roues est le suivant :

<gazebo>
      <plugin name="diff_drive_controller" filename="libgazebo_ros_diff_drive.so">
        <legacyMode>false</legacyMode>
        <alwaysOn>true</alwaysOn>
        <updateRate>1000.0</updateRate>
        <leftJoint>front_left_wheel_joint, rear_left_wheel_joint</leftJoint>
        <rightJoint>front_right_wheel_joint, rear_right_wheel_joint</rightJoint>
        <wheelSeparation>0.5</wheelSeparation>
        <wheelDiameter>0.2</wheelDiameter>
        <wheelTorque>10</wheelTorque>
        <publishTf>1</publishTf>
        <odometryFrame>map</odometryFrame>
        <commandTopic>cmd_vel</commandTopic>
        <odometryTopic>odom</odometryTopic>
        <robotBaseFrame>base_link</robotBaseFrame>
        <wheelAcceleration>2.8</wheelAcceleration>
        <publishWheelJointState>true</publishWheelJointState>
        <publishWheelTF>false</publishWheelTF>
        <odometrySource>world</odometrySource>
        <rosDebugLevel>Debug</rosDebugLevel>
      </plugin>
</gazebo>

Nous ajoutons aussi maintenant les frictions que les roues peuvent avoir sur le sol :

<xacro:macro name="wheel_friction" params="prefix ">

<gazebo reference="${prefix}_wheel">
 <mu1 value="1.0"/>
 <mu2 value="1.0"/>
 <kp value="10000000.0" />
 <kd value="1.0" />
 <fdir1 value="1 0 0"/>
</gazebo>

</xacro:macro>

L’appelle de ce macro dans le fichier de robot_base.urdf.xacro est :

<xacro:wheel_friction prefix="front_left"/>
<xacro:wheel_friction prefix="front_right"/>
<xacro:wheel_friction prefix="rear_left"/>
<xacro:wheel_friction prefix="rear_right"/>

Maintenant que nous avons ajouté toutes les macros dans notre fichier robot avec les plugins de Gazebo il nous faut juste les ajouter au fichier robot_base ! Rien de plus facile, il vous faut seulement ajouter ces deux lignes dans le tag <robot> de robot_base.urdf.xacro :

<xacro:include filename="$(find robot_description)/urdf/robot_base_essentials.xacro" />
<xacro:include filename="$(find robot_description)/urdf/gazebo_essentials_base.xacro" />

NOUS AVONS ENFIN FINI AVEC NOTRE URDF !

Configurons maintenant les controllers. Créez le fichier de config suivant : control.yaml

$ cd ~/botuto_ws/src/robot_description/config/ 
$ gedit control.yaml

robot_base_joint_publisher:
  type: "joint_state_controller/JointStateController"
  publish_rate: 50

robot_base_velocity_controller:
  type: "diff_drive_controller/DiffDriveController"
  left_wheel: ['front_left_wheel_joint', 'rear_left_wheel_joint']
  right_wheel: ['front_right_wheel_joint', 'rear_right_wheel_joint']
  publish_rate: 50
  pose_covariance_diagonal: [0.001, 0.001, 0.001, 0.001, 0.001, 0.03]
  twist_covariance_diagonal: [0.001, 0.001, 0.001, 0.001, 0.001, 0.03]
  cmd_vel_timeout: 0.5
  wheel_separation : 0.445208
  wheel_radius : 0.0625
  base_frame_id: base_link
  odom_frame_id: odom
  enable_odom_tf: true
  estimate_velocity_from_position: false
  wheel_separation_multiplier: 1.0 
  wheel_radius_multiplier    : 1.0 
  linear:
    x:
      has_velocity_limits    : true
      max_velocity           : 2.0   
      has_acceleration_limits: true
      max_acceleration       : 3.0   
  angular:
    z:
      has_velocity_limits    : true
      max_velocity           : 3.0   
      has_acceleration_limits: true
      max_acceleration       : 6.0   

/gazebo_ros_control:
    pid_gains:
      front_left_wheel_joint: {p: 20.0, i: 0.01, d: 0.0, i_clamp: 0.0}
      front_right_wheel_joint: {p: 20.0, i: 0.01, d: 0.0, i_clamp: 0.0}
      rear_left_wheel_joint: {p: 20.0, i: 0.01, d: 0.0, i_clamp: 0.0}
      rear_right_wheel_joint: {p: 20.0, i: 0.01, d: 0.0, i_clamp: 0.0}

TESTONS MAINTENANT DANS GAZEBO NOTRE ROBOT !

Créons un launch file qui permette de lancer tout ce dont nous avons besoin d’un coup ! Allez dans le dossier launch :

$ cd ~/botuto_ws/src/robot_description/launch 
$ gedit base_gazebo_control_xacro.launch

Collez ce code :

<?xml version="1.0"?>

<launch>

  <param name="robot_description" command="$(find xacro)/xacro --inorder $(find robot_description)/urdf/robot_base.urdf.xacro" />

  <include file="$(find gazebo_ros)/launch/empty_world.launch"/>

  <node name="spawn_urdf" pkg="gazebo_ros" type="spawn_model" args="-param robot_description -urdf -model robot_base" />

  <rosparam command="load" file="$(find robot_description)/config/control.yaml" />

  <node name="base_controller_spawner" pkg="controller_manager" type="spawner" args="robot_base_joint_publisher robot_base_velocity_controller"/>

</launch>

Vous pouvez enfin visualiser votre robot dans un univers vide de gazebo !

Lancez ces quelques lignes :

$ cd ~/botuto_ws 
$ source devel/setup.bash 
$ roslaunch robot_description base_gazebo_control_xacro.launch

Dans un autre terminal lancez cette commande pour faire tout les topics que vous utilisez ou qui sont à votre dispositions :

$ rostopic list

Pour pouvoir faire bouger votre robot pour voyez le topic /robot_base_controller/cmd_vel qui va vous permettre de pouvoir faire bouger votre robot !

Lancez seulement :

$ rosrun rqt_robot_steering rqt_robot_steering

Vous pouvez maintenant vous amuser !!!

CONTRÔLEZ VOTRE ROBOT AVEC VOTRE TERMINAL :

Pour pouvoir utiliser votre terminal comme volant de votre Formule 1 vous allez devoir utiliser un nouveau package !

Pas de panique avec ROS rien n’est plus simple qu’installer un package et s’en servir (à condition de bien tout avoir au préalable!)

Le package en question est TELEOP TWIST KEYBOARD.

Pour avoir certaines info vous pouvez directement aller sur la page ROS suivante : http://wiki.ros.org/teleop_twist_keyboard

Nous allons tout de même le faire ensemble.

Pour installer ce package lancer la commande dans votre terminal :

$ sudo apt-get install ros-melodic-teleop-twist-keyboard

Ensuite pour l’utiliser lancer :

$ rosrun teleop_twist_keyboard teleop_twist_keyboard.py

Après avoir lancer cette commande vous allez sûrement vous dire que je suis un charlatant et que la commande de fonctionne pas chez vous ! Vous avez raison ! Mais pourquoi ?

Vous avez peut-être remarqué que notre topic cmd_vel est publiée sur le topic /robot_base_controller/cmd_vel et comme teleop_twist_keyboard réceptionne le topic /cmd_vel le lien ne se fait pas !

Pour palier à cela nous devons juste remaper notre topic lorsque nous lançons le launcher de teleop_twist_keyboard comme suit :

$ rosrun teleop_twist_keyboard teleop_twist_keyboard.py cmd_vel:=/robot_base_controller/cmd_vel

Le tour est joué vous pouvez maintenant contrôler votre robot avec votre terminale

C’EST BIEN BEAU DE POUVOIR CONTRÔLER UN ROBOT MAIS IL EST DANS UNE MAP VIDE !

Je vous conseille vivement pour faire ça de suivre le tutoriel de Gazebo qui est très bien expliqué : http://gazebosim.org/tutorials?cat=build_world&tut=building_editor#Overview

Si vous voulez seulement un labyrinthe vous avez juste à créer des murs sans avoir d’image au préalable. Ensuite lorsque vous avez fini, enregistrez votre construction. Ouvrez une nouvelle fois Gazebo, vous avez maintenant accès à votre construction que vous pouvez importer dans votre monde pour le moment vide.

Après l’avoir ajouté vous pouvez un ajouter des éléments dans la partie insert de Gazebo.

Une fois toute vos modifications terminées vous pouvez l’enregistrer avec un ctrl+S sous le format world.

Ce format va nous servir dans notre fichier launch pour intégrer notre robot directement dans ce monde à son lancement.

Maintenant que vous avez la possibilité de le faire bouger ne serait-ce pas sympa de lui faire découvrir une map grâce à un lidar ?

Le robot pourra recréer une map que vous avez au préalable construit en 2D dans RVIZ.

Voici comment faire :

Vérifions que nous pouvons bien lancer notre robot dans le fichier .world que nous lui avons construit au préalable.

$ cd ~/botuto_ws/src/robot_description/
$ mkdir worlds

Mettez ici le monde que vous avez créé sous la forme d’un .world (fichier que vous avez enregistré sur gazebo).

Maintenant allons modifier notre .launch pour que votre robot apparaisse dans votre monde. Dans le fichier mobile_manipulator_gazebo_xacro.launch ajoutez :

<include file="$(find gazebo_ros)/launch/empty_world.launch">
<arg name="world_name"
value="home/robot/botuto_ws/src/robot_description/worlds/[votre_fichier].world"/>
</include>

Relancez votre fichier launch et vous verrez que votre robot apparaît maintenant aux coordonnées (0,0) de votre map.

RENDONS NOTRE ROBOT UN PEU PLUS INTELLIGENT :

Commençons à rendre notre base roulante autonome. Pour cela il faut qu’elle comprenne son environnement et qu’elle puisse bouger dans ce dernier. Nous allons utiliser Simultaneous Localization And Mapping (SLAM) pour y parvenir. SLAM a été un problème de recherche depuis maintenant une dizaine d’années et ROS a de bons packages open source qui peuvent nous aider à mapper et localiser notre robot dans un environnement.

Pour se faire, nous allons équiper notre robot de capteurs, rajouter des packages ROS à notre robot pour qu’il puisse nous sortir une belle map 2D.

Pour commencer nous allons ajouter un capteur laser : le LIDAR.

AJOUTER LE LIDAR :

Un scanner laser utilise un laser comme sourceet le principe de time of flight pour calculer la distance.

Le laser est placé sur un plateau tournant à une certaine vitesse ce qui va lui permettre d’obtenir un scan de l’environnement en 2D.

Sur Gazebo nous pouvons faire varier son nombres de degré actif (s’il agit à 360 degrés ou bien 180 etc.…) ainsi que faire varier la distance à laquelle il perçoit.

Pour cela nous avons recours à un plugin que nous allons utiliser dans notre robot. Pour le simuler nous allons tout d’abord créer une forme de cylindre pour le représenter.

Créez un nouveau fichier dans le dossier urdf du nom de mobile_manipulator.urdf (qui reprend ce que nous avons fait dans robot_base.urdf.xacro avec ses xacro) et ajoutez ces lignes :

VOUS POUVEZ RÉCUPÉRER MON CODE DANS LE ZIP

$ cd urdf
$ gedit mobile_manipulator.urdf

<link name="laser_link">
  <collision>
    <origin xyz="0 0 0" rpy="0 0 0"/>
    <geometry>
    <box size="0.1 0.1 0.1"/>
    </geometry>
  </collision>
    <visual>
      <origin xyz="0 0 0" rpy="0 0 0"/>
      <geometry>
      <box size="0.05 0.05 0.05"/>
      </geometry>
    </visual>
    <inertial>
      <mass value="1e-5" />
      <origin xyz="0 0 0" rpy="0 0 0"/>
      <inertia ixx="1e-6" ixy="0" ixz="0" iyy="1e-6" iyz="0" izz="1e-6" />
    </inertial>
</link>
      
<joint name="laser_joint" type="fixed">
  <axis xyz="0 1 0" />
  <origin xyz="0.350 0 0.115" rpy="0 0 0"/>
  <parent link="base_link"/>
  <child link="laser_link"/>
</joint>
        
<gazebo reference="laser_link">
  <sensor type="ray" name="laser">
    <pose>0 0 0 0 0 0</pose>
    <visualize>true</visualize>
    <update_rate>40</update_rate>
    <ray>
      <scan>
        <horizontal>
          <samples>720</samples>
          <resolution>1</resolution>
          <min_angle>-1.570796</min_angle>
          <max_angle>1.570796</max_angle>
        </horizontal>
      </scan>
      <range>
        <min>0.10</min>
        <max>30.0</max>
        <resolution>0.01</resolution>
      </range>
    </ray>
    <plugin name="gazebo_ros_head_hokuyo_controller" filename="libgazebo_ros_laser.so">
      <topicName>/scan</topicName>
      <frameName>laser_link</frameName>
    </plugin>
  </sensor>
</gazebo>

Si le tag <visualize>true</visualize> est bien initialisé à true nous verrons une lumière bleue de 180 degrés. Notre laser a donc une porté de 10 centimètres à 30 mètres et un rayon de 180 degrés.

Les topics qui nous ont permis de de modifier ces paramètres sont : <min_angle>, <max_angle> et <range>.

Maintenant vous pouvez relancer votre robot dans Gazebo avec ce launch mobile_manipulator_gazebo.launch:

<?xml version="1.0"?>
<launch>

<param name="robot_description" textfile="$(find robot_description)/urdf/mobile_manipulator.urdf" />
	<include file="$(find gazebo_ros)/launch/empty_world.launch"/>
	<node name="spawn_urdf" pkg="gazebo_ros" type="spawn_model" args="-param robot_description -urdf -model mobile_manipulator" />
	<rosparam command="load" file="$(find robot_description)/config/joint_state_controller.yaml" />
	<node name="joint_state_controller_spawner" pkg="controller_manager" type="controller_manager" args="spawn joint_state_controller" respawn="false" output="screen"/>
	<rosparam command="load" file="$(find robot_description)/config/control.yaml" />
	<node name="base_controller_spawner" pkg="controller_manager" type="spawner" args="robot_base_joint_publisher robot_base_velocity_controller"/>
	<node name="robot_state_publisher" pkg="robot_state_publisher" type="robot_state_publisher" respawn="false" output="screen"/>

</launch>

et vous devriez voir ça (j'ai rajouté mon environnement directement dans Gazebo) :

MAPPER L’ENVIRONNEMENT :

Pour pouvoir se déplacer de manière autonome, le robot doit connaître son environnement donc doit le mapper en 2D grâce à son lidar comme vous l’avez compris.

Pour se faire, nous pouvons avoir recours à certains techno comme Karto, Gmapping, Google Cartographer.

Toutes ces techniques sont disponibles avec ROS et nécessite toutes ces informations :

odometry
laser scan data
tf information

Nous allons utiliser dans ce tuto Gmapping SLAM avec cette commande :

$ sudo apt-get install ros-melodic-slam-gmapping

Maintenant utilisons le :

1- La première étape est de lancer dans un nouveau terminal :

$ rosrun gmapping slam_gmapping

2. Maintenant ouvrez RVIZ depuis un nouveau terminal pour voir le laser et la map

$ rosrun rviz rviz

Une fois ouvert ajoutez les topics laser_scan et map pour tout voir en gardant les même configurations pour Fixed Frame que précédemment.

3. Maintenant utilisé teleop_twist_keyboard comme précédemment :

$ rosrun teleop_twist_keyboard teleop_twist_keyboard.py cmd_vel:=/robot_base_velocity_controller/cmd_vel

Vous devriez voir maintenant la MAP et balader vous dedans pour la remplir !

Je vous joins mes résultats :

Je vous invite à aller regarder et faire le prochain tutoriel qui va vous permettre de donner un but à votre robot pour qu'il puisse aller d'un point A à un point B. C'est ce que nous appelons le Path Finding. Tutoriel

Tutorials