http://www.generationrobots.com/en/content/75-gazebo-and-ros

In questo workspace creeremo 3 package di esempio, per simulare un piccolo carrello chiamando Gazebo dentro ROS

1. mybot_gazebo: file world e launch
2. mybot_description: modello 3d
3. mybot_control: interfaccia per ROS (file yaml e launch)

mkdir -p ~/catkin_ws/src
cd ~/catkin_ws/src
catkin_init_workspace
cd ..
catkin_make

Avremo generato delle nuove cartelle

Ogni volta che vogliamo usare questo pacchetto dovremo preventivamente dare su ogni terminale:

source ~/catkin_ws/devel/setup.bash

Oltre al solito

source /opt/ros/indigo/setup.bash

cd ~/catkin_ws/src
catkin_create_pkg mybot_gazebo gazebo_ros
catkin_create_pkg mybot_description
catkin_create_pkg mybot_control

Abbiamo creato CMakeLists.txt e package.xml dentro ogni cartella

non usare cd, ma roscd

roscd mybot_gazebo 
mkdir launch worlds
cd worlds
nano mybot.world

<?xml version="1.0"?>
<sdf version="1.4">
<world name="myworld">
	<include>
		<uri>model://sun</uri>
	</include>
 
	<include>
		<uri>model://ground_plane</uri>
	</include>
</world>
</sdf>

roscd mybot_gazebo/launch
nano mybot_world.launch

Quest è una prima versione del file.launch, ma vedere anche modificare filelaunch

 
  <launch>	  
	<include file="$(find gazebo_ros)/launch/empty_world.launch">	    
		<arg name="world_name" value="$(find mybot_gazebo)/worlds/mybot.world"/>	    
		<arg name="gui" value="true"/>	  
	</include>	
</launch>

roslaunch mybot_gazebo mybot_world.launch

• Si possono utilizzare modelli esistenti (Ora NON uso .sdf perché oltre a Gazebo c'è anche ROS)
  • http://wiki.ros.org/urdf/Examples (guardian robotnik) (husky clearpath)
  • http://wiki.ros.org/Robots
• Si può creare il proprio modello con un metalinguaggio di programmazione come xacro

roscd mybot_description
mkdir urdf
cd urdf
nano mybot.xacro

approfondimento XACRO

I modelli ottenuti dovranno avere opportuni tag per colore, coefficiente di attrito, opportuni giunti (joint) e opportuni controlli sui movimenti (Attuatori)

myrobot.gazebo

Ogni elemento che compone il robot (case, ruote, braccio, manipolatore, sensori, ecc.) avrà un diverso file.urdf che dovranno essere messi insieme tramite apposito tag <robot> nel file myrobot.gazebo

<robot>
  <gazebo reference="chassis">
    <material>Gazebo/Orange</material>
  </gazebo>

  <gazebo reference="caster_wheel">
    <mu1>0.0</mu1>
    <mu2>0.0</mu2>
    <material>Gazebo/Red</material>
  </gazebo>

</robot>

NOTA: Il tag <gazebo> può essere inserito anche nel file.xacro………???

<!-- urdf xml robot description che verrà convertita e caricata da ROS usando un parametro "robot_description" vedi sotto-->
<param name="robot_description" command="$(find xacro)/xacro.py '$(find mybot_description)/urdf/mybot.xacro'" />
 
<!-- carica robot_description per costruire e depositare il robot in gazebo -->
<node name="mybot_spawn" pkg="gazebo_ros" type="spawn_model" output="screen"
 args="-urdf -param robot_description -model mybot" />
 
<!-- verrà realizzato anche un file launch per il ros_control  -->
<include file="$(find mybot_control)/launch/mybot_control.launch" />

La connessione a ROS si ottiene per mezzo di un plugin di Gazebo

Avendo usato un tag <transmission> nel file.urdf, ora posso collegarci un plugin modificando il file myrobot.gazebo

<gazebo>
  <plugin name="gazebo_ros_control" filename="libgazebo_ros_control.so">
    <robotNamespace>/mybot</robotNamespace>
  </plugin>
</gazebo>

roscd mybot_control
mkdir config
cd config
nano mybot_control.yaml

Definisco: 2 giunti perché uso due ruote, e un sensore che restituisce l'angolo delle ruote (propriocezione)

mybot:
  # Publish all joint states -----------------------------------
  joint_state_controller:
    type: joint_state_controller/JointStateController
    publish_rate: 50  
  

  # Effort Controllers ---------------------------------------
  leftWheel_effort_controller:
    type: effort_controllers/JointEffortController
    joint: left_wheel_hinge
    pid: {p: 100.0, i: 0.1, d: 10.0} # gain??
  rightWheel_effort_controller:
    type: effort_controllers/JointEffortController
    joint: right_wheel_hinge
    pid: {p: 100.0, i: 0.1, d: 10.0}

roscd mybot_control
mkdir launch
cd launch
nano mybot_control.launch

<launch>
 
  <!-- Caricare controllo giunti (joint) e configurazioni da file.yaml -->
  <rosparam file="$(find mybot_control)/config/mybot_control.yaml" command="load"/>
 
  <!-- load the controllers -->
  <node name="controller_spawner"
    pkg="controller_manager"
    type="spawner" respawn="false"
    output="screen" ns="/mybot"
    args="joint_state_controller rightWheel_effort_controller leftWheel_effort_controller"
  />
 
 
  <!-- avvierà un node ROS che trasforma TF lo stato dei giunti (joint) in 3D per vedere la traiettoria su rviz, ecc -->
  <node name="robot_state_publisher" pkg="robot_state_publisher" type="robot_state_publisher" respawn="false" output="screen">
    <param name="robot_description" command="$(find xacro)/xacro.py '$(find mybot_description)/urdf/mybot.xacro'" />
    <remap from="/joint_states" to="/mybot/joint_states" />
  </node>
 
</launch>

Dopo aver specificato il mio robot???

source ~/catkin_ws/devel/setup.bash???

roslaunch mybot_gazebo mybot_world.launch

In un altro terminale, questo comando permette di vedere i controllori in azioine

rostopic list

In altro terminale, dopo opportuna inizializzazione???, inviare i comandi di controllo, uno per ruota. Successivamente si potrà aggiungere un plugin che è subscriber del topic cmd_vel, e inviare opportuni comandi alle due ruote.

rostopic pub -1 /mybot/leftWheel_effort_controller/command std_msgs/Float64 "data: 1.5"
rostopic pub -1 /mybot/rightWheel_effort_controller/command std_msgs/Float64 "data: 1.0"

Questo permette di monitorare lo stato dei giunti

rostopic echo /mybot/joint_states

Aggiungere telecomando e telecamera